From 007f8020b045ad72f0d5fad9a352d553dc21b6d0 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Wed, 23 Nov 2022 21:10:57 +0000
Subject: [PATCH 01/42] WIP - partially parallel release optimization

---
 src/Compiler/Driver/Graph.fs                | 107 +++++
 src/Compiler/Driver/GraphProcessing.fs      | 458 ++++++++++++++++++++
 src/Compiler/Driver/OptimizeInputs.fs       | 435 +++++++++++++++----
 src/Compiler/Driver/OptimizeInputs.fsi      |   8 +
 src/Compiler/Driver/OptimizeTypes.fs        |  86 ++++
 src/Compiler/Driver/Parallel.fs             |  54 +++
 src/Compiler/FSharp.Compiler.Service.fsproj |   4 +
 7 files changed, 1060 insertions(+), 92 deletions(-)
 create mode 100644 src/Compiler/Driver/Graph.fs
 create mode 100644 src/Compiler/Driver/GraphProcessing.fs
 create mode 100644 src/Compiler/Driver/OptimizeTypes.fs
 create mode 100644 src/Compiler/Driver/Parallel.fs

diff --git a/src/Compiler/Driver/Graph.fs b/src/Compiler/Driver/Graph.fs
new file mode 100644
index 00000000000..622d1ec2d2f
--- /dev/null
+++ b/src/Compiler/Driver/Graph.fs
@@ -0,0 +1,107 @@
+module FSharp.Compiler.Service.Driver.Graph
+
+#nowarn "1182"
+#nowarn "40"
+
+open System.Collections.Generic
+open System.IO
+open Newtonsoft.Json
+open ParallelTypeCheckingTests.Utils
+
+/// <summary> DAG of files </summary>
+type Graph<'Node> = IReadOnlyDictionary<'Node, 'Node[]>
+
+module Graph =
+
+    let make (nodeDeps: ('Node * 'Node[]) seq) = nodeDeps |> readOnlyDict
+
+    let map (f: 'a -> 'b) (graph: Graph<'a>) : Graph<'b> =
+        graph
+        |> Seq.map (fun (KeyValue (node, deps)) -> f node, deps |> Array.map f)
+        |> make
+
+    let collectEdges<'Node when 'Node: equality> (graph: Graph<'Node>) : ('Node * 'Node)[] =
+        let graph: IReadOnlyDictionary<'Node, 'Node[]> = graph
+
+        graph
+        |> Seq.collect (fun (KeyValue (node, deps)) -> deps |> Array.map (fun dep -> node, dep))
+        |> Seq.toArray
+
+    let addIfMissing<'Node when 'Node: equality> (nodes: 'Node seq) (graph: Graph<'Node>) : Graph<'Node> =
+        nodes
+        |> Seq.except (graph.Keys |> Seq.toArray)
+        |> fun missing ->
+            let toAdd = missing |> Seq.map (fun n -> KeyValuePair(n, [||])) |> Seq.toArray
+
+            let x = Array.append (graph |> Seq.toArray) toAdd
+            x |> Dictionary<_, _> |> (fun x -> x :> IReadOnlyDictionary<_, _>)
+
+    /// Create entries for nodes that don't have any dependencies but are mentioned as dependencies themselves
+    let fillEmptyNodes<'Node when 'Node: equality> (graph: Graph<'Node>) : Graph<'Node> =
+        let missingNodes =
+            graph.Values |> Seq.toArray |> Array.concat |> Array.except graph.Keys
+
+        addIfMissing missingNodes graph
+
+    /// Create a transitive closure of the graph
+    let transitiveOpt<'Node when 'Node: equality> (graph: Graph<'Node>) : Graph<'Node> =
+        let go (node: 'Node) =
+            let visited = HashSet<'Node>()
+
+            let rec dfs (node: 'Node) =
+                graph[node] |> Array.filter visited.Add |> Array.iter dfs
+
+            dfs node
+            visited |> Seq.toArray
+
+        graph.Keys
+        |> Seq.toArray
+        |> Array.Parallel.map (fun node -> node, go node)
+        |> readOnlyDict
+
+    /// Create a transitive closure of the graph
+    let transitive<'Node when 'Node: equality> (graph: Graph<'Node>) : Graph<'Node> =
+        let rec calcTransitiveEdges =
+            fun (node: 'Node) ->
+                let edgeTargets =
+                    match graph.TryGetValue node with
+                    | true, x -> x
+                    | false, _ -> failwith "FOO"
+
+                edgeTargets
+                |> Array.collect calcTransitiveEdges
+                |> Array.append edgeTargets
+                |> Array.distinct
+            // Dispose of memoisation context
+            |> memoize
+
+        graph.Keys
+        |> Seq.map (fun node -> node, calcTransitiveEdges node)
+        |> readOnlyDict
+
+    /// Create a reverse of the graph
+    let reverse (originalGraph: Graph<'Node>) : Graph<'Node> =
+        originalGraph
+        // Collect all edges
+        |> Seq.collect (fun (KeyValue (idx, deps)) -> deps |> Array.map (fun dep -> idx, dep))
+        // Group dependants of the same dependencies together
+        |> Seq.groupBy (fun (_idx, dep) -> dep)
+        // Construct reversed graph
+        |> Seq.map (fun (dep, edges) -> dep, edges |> Seq.map fst |> Seq.toArray)
+        |> readOnlyDict
+        |> addIfMissing originalGraph.Keys
+
+    let printCustom (graph: Graph<'Node>) (printer: 'Node -> string) : unit =
+        printfn "Graph:"
+        let join (xs: string[]) = System.String.Join(", ", xs)
+
+        graph
+        |> Seq.iter (fun (KeyValue (file, deps)) -> printfn $"{file} -> {deps |> Array.map printer |> join}")
+
+    let print (graph: Graph<'Node>) : unit =
+        printCustom graph (fun node -> node.ToString())
+
+    let serialiseToJson (path: string) (graph: Graph<'Node>) : unit =
+        let json = JsonConvert.SerializeObject(graph, Formatting.Indented)
+        printfn $"Serialising graph as JSON in {path}"
+        File.WriteAllText(path, json)
diff --git a/src/Compiler/Driver/GraphProcessing.fs b/src/Compiler/Driver/GraphProcessing.fs
new file mode 100644
index 00000000000..d3489fe78ee
--- /dev/null
+++ b/src/Compiler/Driver/GraphProcessing.fs
@@ -0,0 +1,458 @@
+/// Parallel processing of graph of work items with dependencies
+module FSharp.Compiler.Service.Driver.GraphProcessing
+
+open System.Collections.Concurrent
+open System.Collections.Generic
+open System.Threading
+open FSharp.Compiler.Service.Driver.Graph
+
+/// Used for processing
+type NodeInfo<'Item> =
+    {
+        Item: 'Item
+        Deps: 'Item[]
+        TransitiveDeps: 'Item[]
+        Dependants: 'Item[]
+    }
+
+type StateMeta<'Item> =
+    {
+        Contributors: 'Item[]
+    }
+
+    static member Empty() = { Contributors = [||] }
+
+type StateWrapper<'Item, 'State> =
+    {
+        Meta: StateMeta<'Item>
+        State: 'State
+    }
+
+type ResultWrapper<'Item, 'Result> = { Item: 'Item; Result: 'Result }
+
+type Node<'Item, 'State, 'Result> =
+    {
+        Info: NodeInfo<'Item>
+        mutable ProcessedDepsCount: int
+        mutable Result: ('State * 'Result) option
+        mutable InputState: 'State option
+    }
+
+// TODO Do we need to suppress some error logging if we
+// TODO apply the same partial results multiple times?
+// TODO Maybe we can enable logging only for the final fold
+/// <summary>
+/// Combine results of dependencies needed to type-check a 'higher' node in the graph
+/// </summary>
+/// <param name="deps">Direct dependencies of a node</param>
+/// <param name="transitiveDeps">Transitive dependencies of a node</param>
+/// <param name="folder">A way to fold a single result into existing state</param>
+let combineResultsOld
+    (emptyState: 'State)
+    (deps: Node<'Item, 'State, 'Result>[])
+    (transitiveDeps: Node<'Item, 'State, 'Result>[])
+    (folder: 'State -> 'Result -> 'State)
+    : 'State =
+    match deps with
+    | [||] -> emptyState
+    | _ ->
+
+        let biggestDep =
+            let sizeMetric node =
+                // Could also use eg. total file size/AST size
+                node.Info.Item
+            // node.Info.TransitiveDeps.Length
+            deps
+            // TODO To workaround a problem with merging state in the wrong order,
+            // we temporarily effectively pick the child with the lowest index.
+            // This means children are folded fully in sequence
+            |> Array.minBy sizeMetric
+
+        let orFail value =
+            value |> Option.defaultWith (fun () -> failwith "Unexpected lack of result")
+
+        let firstState = biggestDep.Result |> orFail |> fst
+
+        // TODO Potential perf optimisation: Keep transDeps in a HashSet from the start,
+        // avoiding reconstructing the HashSet here
+
+        // Add single-file results of remaining transitive deps one-by-one using folder
+        // Note: Good to preserve order here so that folding happens in file order
+        let included =
+            let set = HashSet(biggestDep.Info.TransitiveDeps)
+            set.Add biggestDep.Info.Item |> ignore
+            set
+
+        let resultsToAdd =
+            transitiveDeps
+            |> Array.filter (fun dep -> included.Contains dep.Info.Item = false)
+            |> Array.distinctBy (fun dep -> dep.Info.Item)
+            |> Array.map (fun dep -> dep.Result |> orFail |> snd)
+
+        let state = Array.fold folder firstState resultsToAdd
+        state
+
+// TODO Do we need to suppress some error logging if we
+// TODO apply the same partial results multiple times?
+// TODO Maybe we can enable logging only for the final fold
+/// <summary>
+/// Combine results of dependencies needed to type-check a 'higher' node in the graph
+/// </summary>
+/// <param name="deps">Direct dependencies of a node</param>
+/// <param name="transitiveDeps">Transitive dependencies of a node</param>
+/// <param name="folder">A way to fold a single result into existing state</param>
+let combineResults
+    (emptyState: 'State)
+    (deps: Node<'Item, 'State, 'Result>[])
+    (transitiveDeps: Node<'Item, 'State, 'Result>[])
+    (folder: 'State -> 'Result -> 'State)
+    (_foldingOrderer: 'Item -> int)
+    : 'State =
+    match deps with
+    | [||] -> emptyState
+    | _ ->
+        let orFail value =
+            value |> Option.defaultWith (fun () -> failwith "Unexpected lack of result")
+
+        let firstState = emptyState
+        // TODO Potential perf optimisation: Keep transDeps in a HashSet from the start,
+        // avoiding reconstructing the HashSet here
+
+        // Add single-file results of remaining transitive deps one-by-one using folder
+        // Note: Good to preserve order here so that folding happens in file order
+        let included =
+            let set = HashSet()
+            //set.Add biggestDep.Info.Item |> ignore
+            set
+
+        let resultsToAdd =
+            transitiveDeps
+            // Sort it by effectively file index.
+            // For some reason this is needed, otherwise gives 'missing namespace' and other errors when using the resulting state.
+            // Does this make sense? Should the results be foldable in any order?
+            // TODO Use _foldingOrderer
+            |> Array.sortBy (fun node -> node.Info.Item)
+            |> Array.filter (fun dep -> included.Contains dep.Info.Item = false)
+            |> Array.distinctBy (fun dep -> dep.Info.Item)
+            |> Array.map (fun dep -> dep.Result |> orFail |> snd)
+
+        let state = Array.fold folder firstState resultsToAdd
+        state
+
+// TODO Could be replaced with a simpler recursive approach with memoised per-item results
+let processGraph<'Item, 'State, 'Result, 'FinalFileResult when 'Item: equality and 'Item: comparison>
+    (graph: Graph<'Item>)
+    (doWork: 'Item -> 'State -> 'Result)
+    (folder: 'State -> 'Result -> 'FinalFileResult * 'State)
+    (foldingOrderer: 'Item -> int)
+    (emptyState: 'State)
+    (includeInFinalState: 'Item -> bool)
+    (parallelism: int)
+    : 'FinalFileResult[] * 'State =
+    let transitiveDeps = graph |> Graph.transitiveOpt
+    let dependants = graph |> Graph.reverse
+
+    let makeNode (item: 'Item) : Node<'Item, StateWrapper<'Item, 'State>, ResultWrapper<'Item, 'Result>> =
+        let info =
+            let exists = graph.ContainsKey item
+
+            if
+                not exists
+                || not (transitiveDeps.ContainsKey item)
+                || not (dependants.ContainsKey item)
+            then
+                printfn $"WHAT {item}"
+
+            {
+                Item = item
+                Deps = graph[item]
+                TransitiveDeps = transitiveDeps[item]
+                Dependants = dependants[item]
+            }
+
+        {
+            Info = info
+            Result = None
+            ProcessedDepsCount = 0
+            InputState = None
+        }
+
+    let nodes = graph.Keys |> Seq.map (fun item -> item, makeNode item) |> readOnlyDict
+    let lookup item = nodes[item]
+    let lookupMany items = items |> Array.map lookup
+
+    let leaves =
+        nodes.Values |> Seq.filter (fun n -> n.Info.Deps.Length = 0) |> Seq.toArray
+
+    let emptyState =
+        {
+            Meta = StateMeta.Empty<'Item>()
+            State = emptyState
+        }
+
+    let folder { Meta = meta; State = state } { Item = item; Result = result } =
+        let finalFileResult, state = folder state result
+
+        let state =
+            {
+                Meta =
+                    {
+                        Contributors = Array.append meta.Contributors [| item |]
+                    }
+                State = state
+            }
+
+        finalFileResult, state
+
+    printfn $"Node count: {nodes.Count}"
+    // let mutable cnt = 1
+
+    let work
+        (node: Node<'Item, StateWrapper<'Item, 'State>, ResultWrapper<'Item, 'Result>>)
+        : Node<'Item, StateWrapper<'Item, 'State>, ResultWrapper<'Item, 'Result>>[] =
+        let folder x y = folder x y |> snd
+        let deps = lookupMany node.Info.Deps
+        let transitiveDeps = lookupMany node.Info.TransitiveDeps
+        let inputState = combineResults emptyState deps transitiveDeps folder foldingOrderer
+        node.InputState <- Some inputState
+        let singleRes = doWork node.Info.Item inputState.State
+
+        let singleRes =
+            {
+                Item = node.Info.Item
+                Result = singleRes
+            }
+
+        let state = folder inputState singleRes
+        //let state,  = folder inputState singleRes
+        node.Result <- Some(state, singleRes)
+        // Need to double-check that only one dependency schedules this dependant
+        let unblocked =
+            node.Info.Dependants
+            |> lookupMany
+            |> Array.filter (fun x ->
+                let pdc =
+                    // TODO Not ideal, better ways most likely exist
+                    lock x (fun () ->
+                        x.ProcessedDepsCount <- x.ProcessedDepsCount + 1
+                        x.ProcessedDepsCount)
+
+                pdc = x.Info.Deps.Length)
+        // printfn $"State after {node.Info.Item}"
+        // nodes
+        // |> Seq.map (fun (KeyValue(_, v)) ->
+        //     let x = v.Info.Deps.Length - v.ProcessedDepsCount
+        //     $"{v.Info.Item} - {x} deps left"
+        // )
+        // |> Seq.iter (fun x -> printfn $"{x}")
+        // let c = cnt
+        // cnt <- cnt+1
+        // printfn $"Finished processing node. {unblocked.Length} nodes unblocked"
+        unblocked
+
+    use cts = new CancellationTokenSource()
+
+    Parallel.processInParallel
+        leaves
+        work
+        parallelism
+        (fun processedCount -> processedCount = nodes.Count)
+        cts.Token
+        (fun x -> x.Info.Item.ToString())
+
+    let nodesArray = nodes.Values |> Seq.toArray
+
+    let finals, { State = state }: 'FinalFileResult[] * StateWrapper<'Item, 'State> =
+        nodesArray
+        |> Array.filter (fun node -> includeInFinalState node.Info.Item)
+        |> Array.sortBy (fun node -> node.Info.Item)
+        |> Array.fold
+            (fun (fileResults, state) node ->
+                let fileResult, state = folder state (node.Result.Value |> snd)
+                Array.append fileResults [| fileResult |], state)
+            ([||], emptyState)
+
+    finals, state
+
+type Node2<'Item, 'Result> =
+    {
+        Info: NodeInfo<'Item>
+        mutable ProcessedDepsCount: int
+        mutable Result: 'Result option
+    }
+
+// TODO Could be replaced with a simpler recursive approach with memoised per-item results
+let processGraphSimple<'Item, 'Result when 'Item: equality and 'Item: comparison>
+    (graph: Graph<'Item>)
+    // Accepts item and a list of item results. Handles combining results.
+    (doWork: 'Item -> ResultWrapper<'Item, 'Result>[] -> 'Result)
+    (parallelism: int)
+    : ResultWrapper<'Item, 'Result>[] =
+    let transitiveDeps = graph |> Graph.transitiveOpt
+    let dependants = graph |> Graph.reverse
+
+    let makeNode (item: 'Item) : Node2<'Item, ResultWrapper<'Item, 'Result>> =
+        let info =
+            let exists = graph.ContainsKey item
+            if
+                not exists
+                || not (transitiveDeps.ContainsKey item)
+                || not (dependants.ContainsKey item)
+            then
+                failwith $"WHAT {item}"
+
+            {
+                Item = item
+                Deps = graph[item]
+                TransitiveDeps = transitiveDeps[item]
+                Dependants = dependants[item]
+            }
+
+        {
+            Info = info
+            Result = None
+            ProcessedDepsCount = 0
+        }
+
+    let nodes = graph.Keys |> Seq.map (fun item -> item, makeNode item) |> readOnlyDict
+    let lookup item = nodes[item]
+    let lookupMany items = items |> Array.map lookup
+
+    let leaves =
+        nodes.Values
+        |> Seq.filter (fun n -> n.Info.Deps.Length = 0)
+        |> Seq.toArray
+
+    printfn $"Node count: {nodes.Count}"
+
+    let work
+        (node: Node2<'Item, ResultWrapper<'Item, 'Result>>)
+        : Node2<'Item, ResultWrapper<'Item, 'Result>>[] =
+        let _deps = lookupMany node.Info.Deps
+        let transitiveDeps = lookupMany node.Info.TransitiveDeps
+        let inputs =
+            transitiveDeps
+            |> Array.map (fun n -> n.Result |> Option.get)
+        let singleRes = doWork node.Info.Item inputs
+        let singleRes =
+            {
+                Item = node.Info.Item
+                Result = singleRes
+            }
+        node.Result <- Some singleRes
+        // Need to double-check that only one dependency schedules this dependant
+        let unblocked =
+            node.Info.Dependants
+            |> lookupMany
+            |> Array.filter (fun x ->
+                let pdc =
+                    // TODO Not ideal, better ways most likely exist
+                    lock x (fun () ->
+                        x.ProcessedDepsCount <- x.ProcessedDepsCount + 1
+                        x.ProcessedDepsCount)
+                pdc = x.Info.Deps.Length
+            )
+        unblocked
+
+    use cts = new CancellationTokenSource()
+
+    Parallel.processInParallel
+        leaves
+        work
+        parallelism
+        (fun processedCount -> processedCount = nodes.Count)
+        cts.Token
+        (fun x -> x.Info.Item.ToString())
+
+    let nodesArray = nodes.Values |> Seq.toArray
+
+    nodesArray
+    |> Array.map (fun n -> n.Result.Value)
+
+
+/// Used for processing
+type NodeInfo3<'Item> =
+    {
+        Item: 'Item
+        Deps: 'Item[]
+        Dependants: 'Item[]
+    }
+    
+type Node3<'Item> =
+    {
+        Info: NodeInfo3<'Item>
+        mutable ProcessedDepsCount: int
+    }
+
+/// Graph processing that doesn't handle results but just invokes the worker when dependencies are ready
+let processGraphSimpler<'Item when 'Item: equality and 'Item: comparison>
+    (graph: Graph<'Item>)
+    // Accepts item and a list of item results. Handles combining results.
+    (doWork: 'Item -> unit)
+    (parallelism: int)
+    : unit
+    =
+    let dependants = graph |> Graph.reverse
+
+    let makeNode (item: 'Item) : Node3<'Item> =
+        let info =
+            let exists = graph.ContainsKey item
+            if
+                not exists
+                || not (dependants.ContainsKey item)
+            then
+                failwith $"WHAT {item}"
+            {
+                Item = item
+                Deps = graph[item]
+                Dependants = dependants[item]
+            }
+
+        {
+            Info = info
+            ProcessedDepsCount = 0
+        }
+
+    let nodes = graph.Keys |> Seq.map (fun item -> item, makeNode item) |> readOnlyDict
+    let lookup item = nodes[item]
+    let lookupMany items = items |> Array.map lookup
+
+    let leaves =
+        nodes.Values
+        |> Seq.filter (fun n -> n.Info.Deps.Length = 0)
+        |> Seq.toArray
+
+    // printfn $"Node count: {nodes.Count}"
+
+    let work
+        (node: Node3<'Item>)
+        : Node3<'Item>[]
+        =
+        let _deps = lookupMany node.Info.Deps
+        // printfn $"{node.Info.Item} DoWork"
+        doWork node.Info.Item
+        // printfn $"{node.Info.Item} DoneWork"
+        // Need to double-check that only one dependency schedules this dependant
+        let unblocked =
+            node.Info.Dependants
+            |> lookupMany
+            |> Array.filter (fun x ->
+                let pdc =
+                    // TODO Not ideal, better ways most likely exist
+                    lock x (fun () ->
+                        x.ProcessedDepsCount <- x.ProcessedDepsCount + 1
+                        x.ProcessedDepsCount)
+                pdc = x.Info.Deps.Length
+            )
+        // printfn $"{node.Info.Item} unblocked gathered"
+        unblocked
+
+    use cts = new CancellationTokenSource()
+
+    Parallel.processInParallel
+        leaves
+        work
+        parallelism
+        (fun processedCount -> processedCount = nodes.Count)
+        cts.Token
+        (fun x -> x.Info.Item.ToString())
diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index 0696758780b..1af2d384cfb 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -2,7 +2,12 @@
 
 module internal FSharp.Compiler.OptimizeInputs
 
+open System.Collections.Generic
+open System.Diagnostics
 open System.IO
+open System.Threading
+open FSharp.Compiler.Service.Driver
+open FSharp.Compiler.Service.Driver.OptimizeTypes
 open Internal.Utilities.Library
 open FSharp.Compiler
 open FSharp.Compiler.AbstractIL.IL
@@ -48,6 +53,225 @@ let GetInitialOptimizationEnv (tcImports: TcImports, tcGlobals: TcGlobals) =
     let optEnv = List.fold (AddExternalCcuToOptimizationEnv tcGlobals) optEnv ccuinfos
     optEnv
 
+let collectResults (inputs: CollectorInputs) : CollectorOutputs =
+    let files =
+        inputs
+        |> Array.map (fun {Phase1 = phase1; Phase2 = _phase2; Phase3 = phase3} ->
+            let (_, _, implFileOptData, _), optimizeDuringCodeGen = phase1
+            let _, implFile = phase3
+            let implFile =
+                {
+                    ImplFile = implFile
+                    OptimizeDuringCodeGen = optimizeDuringCodeGen
+                }
+            implFile, implFileOptData
+        )
+        
+    let lastFilePhase1Env =
+        inputs
+        |> Array.last
+        |> fun {Phase1 = phase1} ->
+            let (optEnvPhase1, _, _, _), _ = phase1
+            optEnvPhase1
+            
+    files, lastFilePhase1Env
+
+type Phase =
+    | Phase1
+    | Phase2
+    | Phase3
+
+type FilePhaseFuncs = Phase1Fun * Phase2Fun * Phase3Fun   
+type FileResults =
+    {
+        mutable Phase1: Phase1Res option
+        mutable Phase2: Phase2Res option
+        mutable Phase3: Phase3Res option
+    }
+    with
+        member this.HasResult (phase: Phase) =
+            match phase with
+            | Phase.Phase1 -> this.Phase1 |> Option.isSome
+            | Phase.Phase2 -> this.Phase2 |> Option.isSome
+            | Phase.Phase3 -> this.Phase3 |> Option.isSome
+        static member Empty =
+            {
+                Phase1 = None
+                Phase2 = None
+                Phase3 = None
+            }
+
+type WorkItem =
+    | Phase1 of Phase1Inputs
+    | Phase2 of Phase2Inputs
+    | Phase3 of Phase3Inputs
+
+type Idx = int
+type Node =
+    {
+        Idx: Idx
+        Phase: Phase
+    }
+    with override this.ToString() = $"[{this.Idx}-{this.Phase}]"
+
+
+let getPhase1Res (p: FileResults) =
+    p.Phase1
+    |> Option.get
+    |> fun ((env, _, _, hidden), _) -> env, hidden
+
+let getPhase2Res (p: FileResults) =
+    p.Phase2
+    |> Option.get
+
+let getPhase3Res (p: FileResults) =
+    p.Phase3
+    |> Option.get
+    |> fun (env, _) -> env
+
+let go (env0: Optimizer.IncrementalOptimizationEnv) ((phase1, phase2, phase3): FilePhaseFuncs) (files: CheckedImplFile list) : CollectorOutputs =
+    let files = files |> List.toArray
+    // Schedule File1-Phase1
+    let firstNode = { Idx = 0; Phase = Phase.Phase1 }
+    
+    let results =
+        files
+        |> Array.map (fun _ -> FileResults.Empty)
+    
+    let _lock = obj()
+    let nodeCanBeProcessed {Idx = idx; Phase = phase} : bool =
+        lock (_lock) (fun () ->
+            let previousFileReady =
+                if idx = 0 then true else results[idx-1].HasResult phase
+            let previousPhase =
+                match phase with
+                | Phase.Phase1 -> None
+                | Phase.Phase2 -> Some Phase.Phase1
+                | Phase.Phase3 -> Some Phase.Phase2
+            let previousPhaseReady =
+                match previousPhase with
+                | Some previousPhase -> results[idx].HasResult previousPhase
+                | None -> true
+            previousFileReady && previousPhaseReady
+        )        
+    
+    let visited = HashSet<Node>()
+    
+    let worker ({Idx = idx; Phase = phase} as node : Node) : Node[] =
+        let notPreviouslyVisited =
+            lock (_lock) (fun () ->
+                visited.Add node
+            )
+        if notPreviouslyVisited = false then [||]
+        else
+        let res = results[idx]
+        let file = files[idx]
+        let previous = if idx > 0 then Some results[idx-1] else None
+        let hidingInfo0 = SignatureHidingInfo.Empty        
+        
+        let getPhase1Res (p: FileResults) =
+            p.Phase1
+            |> Option.get
+            |> fun ((env, file, info, hidden), _) -> env, file, info, hidden
+                
+        match phase with
+        | Phase.Phase1 ->
+            // take env from previous file
+            let env, hidingInfo =
+                previous
+                |> Option.map getPhase1Res
+                |> Option.map (fun (a, _b, _c, d) -> a, d)
+                |> Option.defaultValue (env0, hidingInfo0)
+            let inputs = env, hidingInfo, file
+            let phase1Res = phase1 inputs
+            res.Phase1 <- Some phase1Res
+            
+            // Schedule Phase2
+            let phase2Node = { Idx = idx; Phase = Phase.Phase2 }
+            seq {
+                yield phase2Node
+                if idx < files.Length-1 then yield { Idx = idx + 1; Phase = Phase.Phase1 }
+            }
+            |> Seq.toArray
+            
+        | Phase.Phase2 ->
+            // take env from previous file
+            let env =
+                previous
+                |> Option.map getPhase2Res
+                |> Option.map fst
+                |> Option.defaultValue env0
+            let file, info, hidingInfo =
+                res
+                |> getPhase1Res
+                |> fun (_a, b, c, d) -> b, c, d
+            let inputs = env, hidingInfo, info, file
+            let phase2Res = phase2 inputs
+            res.Phase2 <- Some phase2Res
+            
+            seq {
+                // Schedule Phase3
+                let phase3Node = { Idx = idx; Phase = Phase.Phase3 }
+                yield phase3Node
+                // Schedule Phase2 for the next file if it exists
+                if idx < files.Length-1 then yield { Idx = idx + 1; Phase = Phase.Phase2 }
+            }
+            |> Seq.toArray
+            
+        | Phase.Phase3 ->
+            // take env from previous file
+            let env =
+                previous
+                |> Option.map getPhase3Res
+                |> Option.defaultValue env0
+            // impl file
+            let _, file =
+                res
+                |> getPhase2Res
+            let hidingInfo =
+                res
+                |> getPhase1Res
+                |> fun (_a,_b,_c,d) -> d
+            let inputs = env, hidingInfo, file
+            let phase3Res = phase3 inputs
+            res.Phase3 <- Some phase3Res
+            
+            seq {
+                // Schedule Phase3 for the next file if it exists
+                if idx < files.Length-1 then yield { Idx = idx + 1; Phase = Phase.Phase3 }
+            }
+            |> Seq.toArray
+        |> fun nodes ->
+            nodes
+            |> Array.filter nodeCanBeProcessed
+    
+    Parallel.processInParallel
+        [|firstNode|]
+        worker
+        10
+        (fun _ -> visited.Count >= files.Length * 3)
+        (CancellationToken.None)
+        (fun node -> node.ToString())
+        
+    Debug.Assert(visited.Count = files.Length * 3)
+    
+    let results =
+        results
+        |> Array.mapi (fun i {Phase1 = phase1; Phase2 = phase2; Phase3 = phase3} ->
+            match phase1, phase2, phase3 with
+            | Some phase1, Some phase2, Some phase3 -> {FileResultsComplete.Phase1 = phase1; Phase2 = phase2; Phase3 = phase3}
+            | _ -> failwith $"Unexpected lack of results for file [{i}]"
+        )
+    let collected = results |> collectResults
+    collected
+
+[<RequireQualifiedAccess>]
+type OptimizerMode =
+    | Sequential
+    | PartiallyParallel
+
+let mutable optimizerMode: OptimizerMode = OptimizerMode.Sequential
+
 let ApplyAllOptimizations
     (
         tcConfig: TcConfig,
@@ -90,20 +314,52 @@ let ApplyAllOptimizations
             reportingPhase = true
         }
 
-    let results, (optEnvFirstLoop, _, _, _) =
-        ((optEnv0, optEnv0, optEnv0, SignatureHidingInfo.Empty), implFiles)
+    
+    let env0 = optEnv0
+    
+    let phase1 (env: Optimizer.IncrementalOptimizationEnv, hidden: SignatureHidingInfo, implFile: CheckedImplFile) : Phase1Res =
+        //ReportTime tcConfig ("Initial simplify")
+        Optimizer.OptimizeImplFile(
+            optSettings,
+            ccu,
+            tcGlobals,
+            tcVal,
+            importMap,
+            env,
+            isIncrementalFragment,
+            tcConfig.fsiMultiAssemblyEmit,
+            tcConfig.emitTailcalls,
+            hidden,
+            implFile
+        )
+    
+    let phase2 (env: Optimizer.IncrementalOptimizationEnv, hidden: SignatureHidingInfo, implFileOptData: Optimizer.ImplFileOptimizationInfo, implFile: CheckedImplFile) : Phase2Res =
+        let implFile = LowerLocalMutables.TransformImplFile tcGlobals importMap implFile
+
+        // Only do this on the first pass!
+        let optSettings =
+            { optSettings with
+                abstractBigTargets = false
+                reportingPhase = false
+            }
+#if DEBUG
+        if tcConfig.showOptimizationData then
+            dprintf
+                "Optimization implFileOptData:\n%s\n"
+                (LayoutRender.showL (Display.squashTo 192 (Optimizer.moduleInfoL tcGlobals implFileOptData)))
+#endif
 
-        ||> List.mapFold (fun (optEnvFirstLoop, optEnvExtraLoop, optEnvFinalSimplify, hidden) implFile ->
+        if tcConfig.extraOptimizationIterations > 0 then
 
-            //ReportTime tcConfig ("Initial simplify")
-            let (optEnvFirstLoop, implFile, implFileOptData, hidden), optimizeDuringCodeGen =
+            //ReportTime tcConfig ("Extra simplification loop")
+            let (optEnvExtraLoop, implFile, _, _), _ =
                 Optimizer.OptimizeImplFile(
                     optSettings,
                     ccu,
                     tcGlobals,
                     tcVal,
                     importMap,
-                    optEnvFirstLoop,
+                    env,
                     isIncrementalFragment,
                     tcConfig.fsiMultiAssemblyEmit,
                     tcConfig.emitTailcalls,
@@ -111,94 +367,89 @@ let ApplyAllOptimizations
                     implFile
                 )
 
-            let implFile = LowerLocalMutables.TransformImplFile tcGlobals importMap implFile
-
-            // Only do this on the first pass!
-            let optSettings =
-                { optSettings with
-                    abstractBigTargets = false
-                    reportingPhase = false
-                }
-#if DEBUG
-            if tcConfig.showOptimizationData then
-                dprintf
-                    "Optimization implFileOptData:\n%s\n"
-                    (LayoutRender.showL (Display.squashTo 192 (Optimizer.moduleInfoL tcGlobals implFileOptData)))
-#endif
-
-            let implFile, optEnvExtraLoop =
-                if tcConfig.extraOptimizationIterations > 0 then
-
-                    //ReportTime tcConfig ("Extra simplification loop")
-                    let (optEnvExtraLoop, implFile, _, _), _ =
-                        Optimizer.OptimizeImplFile(
-                            optSettings,
-                            ccu,
-                            tcGlobals,
-                            tcVal,
-                            importMap,
-                            optEnvExtraLoop,
-                            isIncrementalFragment,
-                            tcConfig.fsiMultiAssemblyEmit,
-                            tcConfig.emitTailcalls,
-                            hidden,
-                            implFile
-                        )
-
-                    //PrintWholeAssemblyImplementation tcConfig outfile (sprintf "extra-loop-%d" n) implFile
-                    implFile, optEnvExtraLoop
-                else
-                    implFile, optEnvExtraLoop
-
-            let implFile =
-                if tcConfig.doDetuple then
-                    //ReportTime tcConfig ("Detupled optimization")
-                    let implFile = implFile |> Detuple.DetupleImplFile ccu tcGlobals
-                    //PrintWholeAssemblyImplementation tcConfig outfile "post-detuple" implFile
-                    implFile
-                else
-                    implFile
-
-            let implFile =
-                if tcConfig.doTLR then
-                    implFile
-                    |> InnerLambdasToTopLevelFuncs.MakeTopLevelRepresentationDecisions ccu tcGlobals
-                else
+            //PrintWholeAssemblyImplementation tcConfig outfile (sprintf "extra-loop-%d" n) implFile
+            optEnvExtraLoop, implFile
+        else
+            env, implFile
+        
+    let phase3 (env: Optimizer.IncrementalOptimizationEnv, hidden: SignatureHidingInfo, implFile: CheckedImplFile) : Phase3Res =
+        // Only do this on the first pass!
+        let optSettings =
+            { optSettings with
+                abstractBigTargets = false
+                reportingPhase = false
+            }
+
+        let implFile =
+            if tcConfig.doDetuple then
+                //ReportTime tcConfig ("Detupled optimization")
+                let implFile = implFile |> Detuple.DetupleImplFile ccu tcGlobals
+                //PrintWholeAssemblyImplementation tcConfig outfile "post-detuple" implFile
+                implFile
+            else
+                implFile
+
+        let implFile =
+            if tcConfig.doTLR then
+                implFile
+                |> InnerLambdasToTopLevelFuncs.MakeTopLevelRepresentationDecisions ccu tcGlobals
+            else
+                implFile
+
+        let implFile = LowerCalls.LowerImplFile tcGlobals implFile
+
+        if tcConfig.doFinalSimplify then
+
+            //ReportTime tcConfig ("Final simplify pass")
+            let (optEnvFinalSimplify, implFile, _, _), _ =
+                Optimizer.OptimizeImplFile(
+                    optSettings,
+                    ccu,
+                    tcGlobals,
+                    tcVal,
+                    importMap,
+                    env,
+                    isIncrementalFragment,
+                    tcConfig.fsiMultiAssemblyEmit,
+                    tcConfig.emitTailcalls,
+                    hidden,
                     implFile
+                )
 
-            let implFile = LowerCalls.LowerImplFile tcGlobals implFile
-
-            let implFile, optEnvFinalSimplify =
-                if tcConfig.doFinalSimplify then
-
-                    //ReportTime tcConfig ("Final simplify pass")
-                    let (optEnvFinalSimplify, implFile, _, _), _ =
-                        Optimizer.OptimizeImplFile(
-                            optSettings,
-                            ccu,
-                            tcGlobals,
-                            tcVal,
-                            importMap,
-                            optEnvFinalSimplify,
-                            isIncrementalFragment,
-                            tcConfig.fsiMultiAssemblyEmit,
-                            tcConfig.emitTailcalls,
-                            hidden,
-                            implFile
-                        )
-
-                    //PrintWholeAssemblyImplementation tcConfig outfile "post-rec-opt" implFile
-                    implFile, optEnvFinalSimplify
-                else
-                    implFile, optEnvFinalSimplify
-
-            let implFile =
-                {
-                    ImplFile = implFile
-                    OptimizeDuringCodeGen = optimizeDuringCodeGen
-                }
-
-            (implFile, implFileOptData), (optEnvFirstLoop, optEnvExtraLoop, optEnvFinalSimplify, hidden))
+            //PrintWholeAssemblyImplementation tcConfig outfile "post-rec-opt" implFile
+            optEnvFinalSimplify, implFile
+        else
+            env, implFile
+    
+    let results, optEnvFirstLoop =
+        match optimizerMode with
+        | OptimizerMode.PartiallyParallel ->
+            let a, b =
+                go env0 (phase1, phase2, phase3) implFiles
+            a |> Array.toList, b
+        | OptimizerMode.Sequential ->
+            let results, (optEnvFirstLoop, _, _, _) =
+                ((optEnv0, optEnv0, optEnv0, SignatureHidingInfo.Empty), implFiles)
+
+                ||> List.mapFold (fun (optEnvFirstLoop, optEnvExtraLoop, optEnvFinalSimplify, hidden) implFile ->
+                    // Phase 1
+                    //ReportTime tcConfig ("Initial simplify")
+                    let (optEnvFirstLoop, implFile, implFileOptData, hidden), optimizeDuringCodeGen = phase1 (optEnvFirstLoop, hidden, implFile)
+
+                    // Phase 2
+                    let optEnvExtraLoop, implFile = phase2 (optEnvExtraLoop, hidden, implFileOptData, implFile)
+
+                    // Phase 3
+                    let optEnvFinalSimplify, implFile = phase3 (optEnvFinalSimplify, hidden, implFile)
+                    
+                    let implFile =
+                        {
+                            ImplFile = implFile
+                            OptimizeDuringCodeGen = optimizeDuringCodeGen
+                        }
+
+                    (implFile, implFileOptData), (optEnvFirstLoop, optEnvExtraLoop, optEnvFinalSimplify, hidden))
+            results, optEnvFirstLoop
 
     let implFiles, implFileOptDatas = List.unzip results
     let assemblyOptData = Optimizer.UnionOptimizationInfos implFileOptDatas
diff --git a/src/Compiler/Driver/OptimizeInputs.fsi b/src/Compiler/Driver/OptimizeInputs.fsi
index d5c731ba05d..3ac6f9fe408 100644
--- a/src/Compiler/Driver/OptimizeInputs.fsi
+++ b/src/Compiler/Driver/OptimizeInputs.fsi
@@ -12,6 +12,8 @@ open FSharp.Compiler.Import
 open FSharp.Compiler.Optimizer
 open FSharp.Compiler.TcGlobals
 open FSharp.Compiler.TypedTree
+open System.Collections.Generic
+open FSharp.Compiler.Service.Driver.OptimizeTypes
 
 val GetGeneratedILModuleName: CompilerTarget -> string -> string
 
@@ -49,3 +51,9 @@ val GenerateIlxCode:
 val NormalizeAssemblyRefs: CompilationThreadToken * ILGlobals * TcImports -> (ILScopeRef -> ILScopeRef)
 
 val GetGeneratedILModuleName: CompilerTarget -> string -> string
+
+type OptimizerMode =
+    | Sequential
+    | PartiallyParallel
+
+val mutable optimizerMode: OptimizerMode
\ No newline at end of file
diff --git a/src/Compiler/Driver/OptimizeTypes.fs b/src/Compiler/Driver/OptimizeTypes.fs
new file mode 100644
index 00000000000..40f33752dcd
--- /dev/null
+++ b/src/Compiler/Driver/OptimizeTypes.fs
@@ -0,0 +1,86 @@
+module internal FSharp.Compiler.Service.Driver.OptimizeTypes
+
+open FSharp.Compiler
+open FSharp.Compiler.Optimizer
+open FSharp.Compiler.TcGlobals
+open FSharp.Compiler.TypedTree
+open FSharp.Compiler.TypedTreeOps
+
+type OptimizeDuringCodeGen = bool -> Expr -> Expr
+type OptimizeRes =
+    (IncrementalOptimizationEnv * CheckedImplFile * ImplFileOptimizationInfo * SignatureHidingInfo) * OptimizeDuringCodeGen
+
+type Optimize =
+    OptimizationSettings *
+    CcuThunk *
+    TcGlobals *
+    ConstraintSolver.TcValF *
+    Import.ImportMap *
+    IncrementalOptimizationEnv *
+    bool *
+    bool *
+    bool *
+    SignatureHidingInfo *
+    CheckedImplFile ->
+        OptimizeRes
+
+type PhaseInputs = IncrementalOptimizationEnv * SignatureHidingInfo * CheckedImplFile
+
+type Phase1Inputs = PhaseInputs
+type Phase1Res = OptimizeRes
+type Phase1Fun = Phase1Inputs -> Phase1Res
+
+type Phase2Inputs = IncrementalOptimizationEnv * SignatureHidingInfo * ImplFileOptimizationInfo * CheckedImplFile
+type Phase2Res = IncrementalOptimizationEnv * CheckedImplFile
+type Phase2Fun = Phase2Inputs -> Phase2Res
+
+type Phase3Inputs = PhaseInputs
+type Phase3Res = IncrementalOptimizationEnv * CheckedImplFile
+type Phase3Fun = Phase3Inputs -> Phase3Res
+
+type Phase =
+    | Phase1
+    | Phase2
+    | Phase3
+module Phase =
+    let all = [|Phase1; Phase2; Phase3|]
+    let prev (phase: Phase) =
+        match phase with
+        | Phase1 -> None
+        | Phase2 -> Some Phase1
+        | Phase3 -> Some Phase2
+    let next (phase: Phase) =
+        match phase with
+        | Phase1 -> Some Phase2
+        | Phase2 -> Some Phase3
+        | Phase3 -> None
+
+type PhaseRes =
+    | Phase1 of Phase1Res
+    | Phase2 of Phase2Res
+    | Phase3 of Phase3Res
+    with
+        member x.Which =
+            match x with
+            | Phase1 _ -> Phase.Phase1
+            | Phase2 _ -> Phase.Phase2
+            | Phase3 _ -> Phase.Phase3
+        member x.Get1() =
+            match x with
+            | Phase1 x -> x
+            | Phase2 _
+            | Phase3 _ -> failwith $"Called {nameof(x.Get1)} but this is {x.Which}"
+        member x.Get2() =
+            match x with
+            | Phase2 x -> x
+            | Phase1 _
+            | Phase3 _ -> failwith $"Called {nameof(x.Get2)} but this is {x.Which}"
+
+type FileResultsComplete =
+    {
+        Phase1: Phase1Res
+        Phase2: Phase2Res
+        Phase3: Phase3Res
+    }
+type CollectorInputs = FileResultsComplete[]
+type CollectorOutputs = (CheckedImplFileAfterOptimization * ImplFileOptimizationInfo)[] * IncrementalOptimizationEnv
diff --git a/src/Compiler/Driver/Parallel.fs b/src/Compiler/Driver/Parallel.fs
new file mode 100644
index 00000000000..3e566dd97a8
--- /dev/null
+++ b/src/Compiler/Driver/Parallel.fs
@@ -0,0 +1,54 @@
+module FSharp.Compiler.Service.Driver.Parallel
+
+#nowarn "1182"
+
+open System
+open System.Collections.Concurrent
+open System.Threading
+
+// TODO Could replace with MailboxProcessor+Tasks/Asyncs instead of BlockingCollection + Threads
+// See http://www.fssnip.net/nX/title/Limit-degree-of-parallelism-using-an-agent
+/// Process items in parallel, allow more work to be scheduled as a result of finished work,
+/// limit parallelisation to 'parallelism' threads
+let processInParallel
+    (firstItems: 'Item[])
+    (work: 'Item -> 'Item[])
+    (parallelism: int)
+    (shouldStop: int -> bool)
+    (ct: CancellationToken)
+    (_itemToString: 'Item -> string)
+    : unit =
+    let bc = new BlockingCollection<'Item>()
+    firstItems |> Array.iter bc.Add
+    let processedCountLock = Object()
+    let mutable processedCount = 0
+
+    let processItem item =
+        printfn $"[{Thread.CurrentThread.ManagedThreadId}] Processing {_itemToString item}"
+        let toSchedule = work item
+        printfn $"[{Thread.CurrentThread.ManagedThreadId}] Finished {_itemToString item}"
+
+        let processedCount =
+            lock processedCountLock (fun () ->
+                processedCount <- processedCount + 1
+                processedCount)
+
+        let toScheduleString =
+            toSchedule |> Array.map _itemToString |> (fun names -> String.Join(", ", names))
+
+        printfn $"[{Thread.CurrentThread.ManagedThreadId}] Scheduling {toSchedule.Length} items: {toScheduleString}"
+        toSchedule |> Array.iter bc.Add
+        processedCount
+
+    // TODO Could avoid workers with some semaphores
+    let workerWork () : unit =
+        for node in bc.GetConsumingEnumerable(ct) do
+            if not ct.IsCancellationRequested then // improve
+                let processedCount = processItem node
+
+                if shouldStop processedCount then
+                    bc.CompleteAdding()
+
+    // TODO Do we need to handle cancellation given that workers do it already?
+    Array.Parallel.map workerWork (Array.init parallelism (fun _ -> ())) |> ignore
+
diff --git a/src/Compiler/FSharp.Compiler.Service.fsproj b/src/Compiler/FSharp.Compiler.Service.fsproj
index 950f72b24b9..8be13652447 100644
--- a/src/Compiler/FSharp.Compiler.Service.fsproj
+++ b/src/Compiler/FSharp.Compiler.Service.fsproj
@@ -386,6 +386,10 @@
     <Compile Include="Driver\ScriptClosure.fs" />
     <Compile Include="Driver\CompilerOptions.fsi" />
     <Compile Include="Driver\CompilerOptions.fs" />
+    <Compile Include="Driver\Parallel.fs" />
+    <Compile Include="Driver\Graph.fs" />
+    <Compile Include="Driver\GraphProcessing.fs" />
+    <Compile Include="Driver\OptimizeTypes.fs" />
     <Compile Include="Driver\OptimizeInputs.fsi" />
     <Compile Include="Driver\OptimizeInputs.fs" />
     <Compile Include="Driver\XmlDocFileWriter.fsi" />

From a74c0165894f368c6bc1791b579d00787e68b4ac Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Thu, 24 Nov 2022 21:08:45 +0000
Subject: [PATCH 02/42] Make it compile, wire up a test option

---
 src/Compiler/Driver/CompilerOptions.fs |  6 ++++++
 src/Compiler/Driver/Graph.fs           | 28 ++++++++++++++------------
 src/Compiler/Driver/GraphProcessing.fs |  7 -------
 src/Compiler/Driver/OptimizeInputs.fs  | 14 ++++---------
 src/Compiler/Driver/OptimizeInputs.fsi |  6 ------
 src/Compiler/Optimize/Optimizer.fs     | 13 +++++++++++-
 src/Compiler/Optimize/Optimizer.fsi    |  7 +++++++
 7 files changed, 44 insertions(+), 37 deletions(-)

diff --git a/src/Compiler/Driver/CompilerOptions.fs b/src/Compiler/Driver/CompilerOptions.fs
index 02c3306b2d9..885e74fa2e5 100644
--- a/src/Compiler/Driver/CompilerOptions.fs
+++ b/src/Compiler/Driver/CompilerOptions.fs
@@ -7,6 +7,7 @@ module internal FSharp.Compiler.CompilerOptions
 open System
 open System.Diagnostics
 open System.IO
+open FSharp.Compiler.Optimizer
 open Internal.Utilities.Library
 open Internal.Utilities.Library.Extras
 open FSharp.Compiler.AbstractIL.IL
@@ -1388,6 +1389,11 @@ let testFlag tcConfigB =
             | "ContinueAfterParseFailure" -> tcConfigB.continueAfterParseFailure <- true
             | "ParallelOff" -> tcConfigB.concurrentBuild <- false
             | "ParallelCheckingWithSignatureFilesOn" -> tcConfigB.parallelCheckingWithSignatureFiles <- true
+            | "PartiallyParallelOptimization" ->
+                tcConfigB.optSettings <-
+                    { tcConfigB.optSettings with
+                        processingMode = OptimizerMode.PartiallyParallel
+                    }
 #if DEBUG
             | "ShowParserStackOnParseError" -> showParserStackOnParseError <- true
 #endif
diff --git a/src/Compiler/Driver/Graph.fs b/src/Compiler/Driver/Graph.fs
index 622d1ec2d2f..18beb186f5b 100644
--- a/src/Compiler/Driver/Graph.fs
+++ b/src/Compiler/Driver/Graph.fs
@@ -4,9 +4,6 @@
 #nowarn "40"
 
 open System.Collections.Generic
-open System.IO
-open Newtonsoft.Json
-open ParallelTypeCheckingTests.Utils
 
 /// <summary> DAG of files </summary>
 type Graph<'Node> = IReadOnlyDictionary<'Node, 'Node[]>
@@ -33,8 +30,9 @@ module Graph =
         |> fun missing ->
             let toAdd = missing |> Seq.map (fun n -> KeyValuePair(n, [||])) |> Seq.toArray
 
-            let x = Array.append (graph |> Seq.toArray) toAdd
-            x |> Dictionary<_, _> |> (fun x -> x :> IReadOnlyDictionary<_, _>)
+            Array.append (graph |> Seq.toArray) toAdd
+            |> Array.map (fun (KeyValue(k, v)) -> k, v)
+            |> readOnlyDict
 
     /// Create entries for nodes that don't have any dependencies but are mentioned as dependencies themselves
     let fillEmptyNodes<'Node when 'Node: equality> (graph: Graph<'Node>) : Graph<'Node> =
@@ -59,20 +57,29 @@ module Graph =
         |> Array.Parallel.map (fun node -> node, go node)
         |> readOnlyDict
 
-    /// Create a transitive closure of the graph
+    let private memoize<'a,'b when 'a : equality> (f : 'a -> 'b) : 'a -> 'b =
+        let cache = Dictionary<'a,'b>()
+        fun a ->
+            match cache.TryGetValue a with
+            | true, b -> b
+            | false, _ ->
+                let b = f a
+                cache[a] <- b
+                b
+    
+    /// Create a transitive closure of the graph.
     let transitive<'Node when 'Node: equality> (graph: Graph<'Node>) : Graph<'Node> =
         let rec calcTransitiveEdges =
             fun (node: 'Node) ->
                 let edgeTargets =
                     match graph.TryGetValue node with
                     | true, x -> x
-                    | false, _ -> failwith "FOO"
+                    | false, _ -> [||]
 
                 edgeTargets
                 |> Array.collect calcTransitiveEdges
                 |> Array.append edgeTargets
                 |> Array.distinct
-            // Dispose of memoisation context
             |> memoize
 
         graph.Keys
@@ -100,8 +107,3 @@ module Graph =
 
     let print (graph: Graph<'Node>) : unit =
         printCustom graph (fun node -> node.ToString())
-
-    let serialiseToJson (path: string) (graph: Graph<'Node>) : unit =
-        let json = JsonConvert.SerializeObject(graph, Formatting.Indented)
-        printfn $"Serialising graph as JSON in {path}"
-        File.WriteAllText(path, json)
diff --git a/src/Compiler/Driver/GraphProcessing.fs b/src/Compiler/Driver/GraphProcessing.fs
index d3489fe78ee..84228cf40f5 100644
--- a/src/Compiler/Driver/GraphProcessing.fs
+++ b/src/Compiler/Driver/GraphProcessing.fs
@@ -1,7 +1,6 @@
 /// Parallel processing of graph of work items with dependencies
 module FSharp.Compiler.Service.Driver.GraphProcessing
 
-open System.Collections.Concurrent
 open System.Collections.Generic
 open System.Threading
 open FSharp.Compiler.Service.Driver.Graph
@@ -44,9 +43,6 @@ type Node<'Item, 'State, 'Result> =
 /// <summary>
 /// Combine results of dependencies needed to type-check a 'higher' node in the graph
 /// </summary>
-/// <param name="deps">Direct dependencies of a node</param>
-/// <param name="transitiveDeps">Transitive dependencies of a node</param>
-/// <param name="folder">A way to fold a single result into existing state</param>
 let combineResultsOld
     (emptyState: 'State)
     (deps: Node<'Item, 'State, 'Result>[])
@@ -98,9 +94,6 @@ let combineResultsOld
 /// <summary>
 /// Combine results of dependencies needed to type-check a 'higher' node in the graph
 /// </summary>
-/// <param name="deps">Direct dependencies of a node</param>
-/// <param name="transitiveDeps">Transitive dependencies of a node</param>
-/// <param name="folder">A way to fold a single result into existing state</param>
 let combineResults
     (emptyState: 'State)
     (deps: Node<'Item, 'State, 'Result>[])
diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index 1af2d384cfb..382fa07b10e 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -6,6 +6,7 @@ open System.Collections.Generic
 open System.Diagnostics
 open System.IO
 open System.Threading
+open FSharp.Compiler.Optimizer
 open FSharp.Compiler.Service.Driver
 open FSharp.Compiler.Service.Driver.OptimizeTypes
 open Internal.Utilities.Library
@@ -129,7 +130,7 @@ let getPhase3Res (p: FileResults) =
     |> Option.get
     |> fun (env, _) -> env
 
-let go (env0: Optimizer.IncrementalOptimizationEnv) ((phase1, phase2, phase3): FilePhaseFuncs) (files: CheckedImplFile list) : CollectorOutputs =
+let optimizeFilesInParallel (env0: Optimizer.IncrementalOptimizationEnv) ((phase1, phase2, phase3): FilePhaseFuncs) (files: CheckedImplFile list) : CollectorOutputs =
     let files = files |> List.toArray
     // Schedule File1-Phase1
     let firstNode = { Idx = 0; Phase = Phase.Phase1 }
@@ -265,13 +266,6 @@ let go (env0: Optimizer.IncrementalOptimizationEnv) ((phase1, phase2, phase3): F
     let collected = results |> collectResults
     collected
 
-[<RequireQualifiedAccess>]
-type OptimizerMode =
-    | Sequential
-    | PartiallyParallel
-
-let mutable optimizerMode: OptimizerMode = OptimizerMode.Sequential
-
 let ApplyAllOptimizations
     (
         tcConfig: TcConfig,
@@ -422,10 +416,10 @@ let ApplyAllOptimizations
             env, implFile
     
     let results, optEnvFirstLoop =
-        match optimizerMode with
+        match optSettings.processingMode with
         | OptimizerMode.PartiallyParallel ->
             let a, b =
-                go env0 (phase1, phase2, phase3) implFiles
+                optimizeFilesInParallel env0 (phase1, phase2, phase3) implFiles
             a |> Array.toList, b
         | OptimizerMode.Sequential ->
             let results, (optEnvFirstLoop, _, _, _) =
diff --git a/src/Compiler/Driver/OptimizeInputs.fsi b/src/Compiler/Driver/OptimizeInputs.fsi
index 3ac6f9fe408..6876e1ce68e 100644
--- a/src/Compiler/Driver/OptimizeInputs.fsi
+++ b/src/Compiler/Driver/OptimizeInputs.fsi
@@ -51,9 +51,3 @@ val GenerateIlxCode:
 val NormalizeAssemblyRefs: CompilationThreadToken * ILGlobals * TcImports -> (ILScopeRef -> ILScopeRef)
 
 val GetGeneratedILModuleName: CompilerTarget -> string -> string
-
-type OptimizerMode =
-    | Sequential
-    | PartiallyParallel
-
-val mutable optimizerMode: OptimizerMode
\ No newline at end of file
diff --git a/src/Compiler/Optimize/Optimizer.fs b/src/Compiler/Optimize/Optimizer.fs
index 54665570cc5..e0adb4befec 100644
--- a/src/Compiler/Optimize/Optimizer.fs
+++ b/src/Compiler/Optimize/Optimizer.fs
@@ -300,6 +300,11 @@ let [<Literal>] crossAssemblyOptimizationDefault = true
 
 let [<Literal>] debugPointsForPipeRightDefault = true
 
+[<RequireQualifiedAccess>]
+type OptimizerMode =
+    | Sequential
+    | PartiallyParallel
+
 type OptimizationSettings = 
     { 
       abstractBigTargets : bool
@@ -331,6 +336,8 @@ type OptimizationSettings =
       reportHasEffect : bool 
       
       reportTotalSizes : bool
+      
+      processingMode : OptimizerMode
     }
 
     static member Defaults = 
@@ -347,6 +354,7 @@ type OptimizationSettings =
           reportFunctionSizes = false
           reportHasEffect = false
           reportTotalSizes = false
+          processingMode = OptimizerMode.Sequential
         }
 
     /// Determines if JIT optimizations are enabled
@@ -407,7 +415,10 @@ type OptimizationSettings =
 
     /// Determines if we should expand "let x = (exp1, exp2, ...)" bindings as prior tmps 
     /// Also if we should expand "let x = Some exp1" bindings as prior tmps 
-    member x.ExpandStructuralValues() = x.LocalOptimizationsEnabled 
+    member x.ExpandStructuralValues() = x.LocalOptimizationsEnabled
+    
+    /// Determines how to process optimization of multiple files
+    member x.ProcessingMode() = x.processingMode
 
 type cenv =
     { g: TcGlobals
diff --git a/src/Compiler/Optimize/Optimizer.fsi b/src/Compiler/Optimize/Optimizer.fsi
index 76b7881f487..20368b34814 100644
--- a/src/Compiler/Optimize/Optimizer.fsi
+++ b/src/Compiler/Optimize/Optimizer.fsi
@@ -9,6 +9,11 @@ open FSharp.Compiler.TypedTree
 open FSharp.Compiler.TypedTreeOps
 open FSharp.Compiler.TypedTreePickle
 
+[<RequireQualifiedAccess>]
+type OptimizerMode =
+    | Sequential
+    | PartiallyParallel
+
 type OptimizationSettings =
     {
         abstractBigTargets: bool
@@ -40,6 +45,8 @@ type OptimizationSettings =
         reportHasEffect: bool
 
         reportTotalSizes: bool
+        
+        processingMode : OptimizerMode
     }
 
     member JitOptimizationsEnabled: bool

From 315e2146a47af174825402fe9a8f6297b278c0f7 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Thu, 24 Nov 2022 23:34:35 +0000
Subject: [PATCH 03/42] Run two opt phases in parallel

---
 src/Compiler/Driver/Graph.fs           |   9 +-
 src/Compiler/Driver/GraphProcessing.fs |  54 ++--
 src/Compiler/Driver/OptimizeInputs.fs  | 339 +++++++++++++------------
 src/Compiler/Driver/OptimizeTypes.fs   |  56 ++--
 src/Compiler/Driver/Parallel.fs        |  11 +-
 src/Compiler/Driver/fsc.fs             |  83 +++---
 src/Compiler/Optimize/Optimizer.fsi    |   4 +-
 7 files changed, 287 insertions(+), 269 deletions(-)

diff --git a/src/Compiler/Driver/Graph.fs b/src/Compiler/Driver/Graph.fs
index 18beb186f5b..16434ccfd48 100644
--- a/src/Compiler/Driver/Graph.fs
+++ b/src/Compiler/Driver/Graph.fs
@@ -31,7 +31,7 @@ module Graph =
             let toAdd = missing |> Seq.map (fun n -> KeyValuePair(n, [||])) |> Seq.toArray
 
             Array.append (graph |> Seq.toArray) toAdd
-            |> Array.map (fun (KeyValue(k, v)) -> k, v)
+            |> Array.map (fun (KeyValue (k, v)) -> k, v)
             |> readOnlyDict
 
     /// Create entries for nodes that don't have any dependencies but are mentioned as dependencies themselves
@@ -57,8 +57,9 @@ module Graph =
         |> Array.Parallel.map (fun node -> node, go node)
         |> readOnlyDict
 
-    let private memoize<'a,'b when 'a : equality> (f : 'a -> 'b) : 'a -> 'b =
-        let cache = Dictionary<'a,'b>()
+    let private memoize<'a, 'b when 'a: equality> (f: 'a -> 'b) : 'a -> 'b =
+        let cache = Dictionary<'a, 'b>()
+
         fun a ->
             match cache.TryGetValue a with
             | true, b -> b
@@ -66,7 +67,7 @@ module Graph =
                 let b = f a
                 cache[a] <- b
                 b
-    
+
     /// Create a transitive closure of the graph.
     let transitive<'Node when 'Node: equality> (graph: Graph<'Node>) : Graph<'Node> =
         let rec calcTransitiveEdges =
diff --git a/src/Compiler/Driver/GraphProcessing.fs b/src/Compiler/Driver/GraphProcessing.fs
index 84228cf40f5..8ec763b2f7c 100644
--- a/src/Compiler/Driver/GraphProcessing.fs
+++ b/src/Compiler/Driver/GraphProcessing.fs
@@ -287,6 +287,7 @@ let processGraphSimple<'Item, 'Result when 'Item: equality and 'Item: comparison
     let makeNode (item: 'Item) : Node2<'Item, ResultWrapper<'Item, 'Result>> =
         let info =
             let exists = graph.ContainsKey item
+
             if
                 not exists
                 || not (transitiveDeps.ContainsKey item)
@@ -312,26 +313,22 @@ let processGraphSimple<'Item, 'Result when 'Item: equality and 'Item: comparison
     let lookupMany items = items |> Array.map lookup
 
     let leaves =
-        nodes.Values
-        |> Seq.filter (fun n -> n.Info.Deps.Length = 0)
-        |> Seq.toArray
+        nodes.Values |> Seq.filter (fun n -> n.Info.Deps.Length = 0) |> Seq.toArray
 
     printfn $"Node count: {nodes.Count}"
 
-    let work
-        (node: Node2<'Item, ResultWrapper<'Item, 'Result>>)
-        : Node2<'Item, ResultWrapper<'Item, 'Result>>[] =
+    let work (node: Node2<'Item, ResultWrapper<'Item, 'Result>>) : Node2<'Item, ResultWrapper<'Item, 'Result>>[] =
         let _deps = lookupMany node.Info.Deps
         let transitiveDeps = lookupMany node.Info.TransitiveDeps
-        let inputs =
-            transitiveDeps
-            |> Array.map (fun n -> n.Result |> Option.get)
+        let inputs = transitiveDeps |> Array.map (fun n -> n.Result |> Option.get)
         let singleRes = doWork node.Info.Item inputs
+
         let singleRes =
             {
                 Item = node.Info.Item
                 Result = singleRes
             }
+
         node.Result <- Some singleRes
         // Need to double-check that only one dependency schedules this dependant
         let unblocked =
@@ -343,8 +340,9 @@ let processGraphSimple<'Item, 'Result when 'Item: equality and 'Item: comparison
                     lock x (fun () ->
                         x.ProcessedDepsCount <- x.ProcessedDepsCount + 1
                         x.ProcessedDepsCount)
-                pdc = x.Info.Deps.Length
-            )
+
+                pdc = x.Info.Deps.Length)
+
         unblocked
 
     use cts = new CancellationTokenSource()
@@ -359,9 +357,7 @@ let processGraphSimple<'Item, 'Result when 'Item: equality and 'Item: comparison
 
     let nodesArray = nodes.Values |> Seq.toArray
 
-    nodesArray
-    |> Array.map (fun n -> n.Result.Value)
-
+    nodesArray |> Array.map (fun n -> n.Result.Value)
 
 /// Used for processing
 type NodeInfo3<'Item> =
@@ -370,7 +366,7 @@ type NodeInfo3<'Item> =
         Deps: 'Item[]
         Dependants: 'Item[]
     }
-    
+
 type Node3<'Item> =
     {
         Info: NodeInfo3<'Item>
@@ -383,44 +379,34 @@ let processGraphSimpler<'Item when 'Item: equality and 'Item: comparison>
     // Accepts item and a list of item results. Handles combining results.
     (doWork: 'Item -> unit)
     (parallelism: int)
-    : unit
-    =
+    : unit =
     let dependants = graph |> Graph.reverse
 
     let makeNode (item: 'Item) : Node3<'Item> =
         let info =
             let exists = graph.ContainsKey item
-            if
-                not exists
-                || not (dependants.ContainsKey item)
-            then
+
+            if not exists || not (dependants.ContainsKey item) then
                 failwith $"WHAT {item}"
+
             {
                 Item = item
                 Deps = graph[item]
                 Dependants = dependants[item]
             }
 
-        {
-            Info = info
-            ProcessedDepsCount = 0
-        }
+        { Info = info; ProcessedDepsCount = 0 }
 
     let nodes = graph.Keys |> Seq.map (fun item -> item, makeNode item) |> readOnlyDict
     let lookup item = nodes[item]
     let lookupMany items = items |> Array.map lookup
 
     let leaves =
-        nodes.Values
-        |> Seq.filter (fun n -> n.Info.Deps.Length = 0)
-        |> Seq.toArray
+        nodes.Values |> Seq.filter (fun n -> n.Info.Deps.Length = 0) |> Seq.toArray
 
     // printfn $"Node count: {nodes.Count}"
 
-    let work
-        (node: Node3<'Item>)
-        : Node3<'Item>[]
-        =
+    let work (node: Node3<'Item>) : Node3<'Item>[] =
         let _deps = lookupMany node.Info.Deps
         // printfn $"{node.Info.Item} DoWork"
         doWork node.Info.Item
@@ -435,8 +421,8 @@ let processGraphSimpler<'Item when 'Item: equality and 'Item: comparison>
                     lock x (fun () ->
                         x.ProcessedDepsCount <- x.ProcessedDepsCount + 1
                         x.ProcessedDepsCount)
-                pdc = x.Info.Deps.Length
-            )
+
+                pdc = x.Info.Deps.Length)
         // printfn $"{node.Info.Item} unblocked gathered"
         unblocked
 
diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index 382fa07b10e..3caf45ff8e2 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -6,7 +6,6 @@ open System.Collections.Generic
 open System.Diagnostics
 open System.IO
 open System.Threading
-open FSharp.Compiler.Optimizer
 open FSharp.Compiler.Service.Driver
 open FSharp.Compiler.Service.Driver.OptimizeTypes
 open Internal.Utilities.Library
@@ -57,24 +56,30 @@ let GetInitialOptimizationEnv (tcImports: TcImports, tcGlobals: TcGlobals) =
 let collectResults (inputs: CollectorInputs) : CollectorOutputs =
     let files =
         inputs
-        |> Array.map (fun {Phase1 = phase1; Phase2 = _phase2; Phase3 = phase3} ->
-            let (_, _, implFileOptData, _), optimizeDuringCodeGen = phase1
-            let _, implFile = phase3
-            let implFile =
-                {
-                    ImplFile = implFile
-                    OptimizeDuringCodeGen = optimizeDuringCodeGen
-                }
-            implFile, implFileOptData
-        )
-        
+        |> Array.map
+            (fun {
+                     Phase1 = phase1
+                     Phase2 = _phase2
+                     Phase3 = phase3
+                 } ->
+                let (_, _, implFileOptData, _), optimizeDuringCodeGen = phase1
+                let _, implFile = phase3
+
+                let implFile =
+                    {
+                        ImplFile = implFile
+                        OptimizeDuringCodeGen = optimizeDuringCodeGen
+                    }
+
+                implFile, implFileOptData)
+
     let lastFilePhase1Env =
         inputs
         |> Array.last
-        |> fun {Phase1 = phase1} ->
+        |> fun { Phase1 = phase1 } ->
             let (optEnvPhase1, _, _, _), _ = phase1
             optEnvPhase1
-            
+
     files, lastFilePhase1Env
 
 type Phase =
@@ -82,25 +87,27 @@ type Phase =
     | Phase2
     | Phase3
 
-type FilePhaseFuncs = Phase1Fun * Phase2Fun * Phase3Fun   
+type FilePhaseFuncs = Phase1Fun * Phase2Fun * Phase3Fun
+
 type FileResults =
     {
         mutable Phase1: Phase1Res option
         mutable Phase2: Phase2Res option
         mutable Phase3: Phase3Res option
     }
-    with
-        member this.HasResult (phase: Phase) =
-            match phase with
-            | Phase.Phase1 -> this.Phase1 |> Option.isSome
-            | Phase.Phase2 -> this.Phase2 |> Option.isSome
-            | Phase.Phase3 -> this.Phase3 |> Option.isSome
-        static member Empty =
-            {
-                Phase1 = None
-                Phase2 = None
-                Phase3 = None
-            }
+
+    member this.HasResult(phase: Phase) =
+        match phase with
+        | Phase.Phase1 -> this.Phase1 |> Option.isSome
+        | Phase.Phase2 -> this.Phase2 |> Option.isSome
+        | Phase.Phase3 -> this.Phase3 |> Option.isSome
+
+    static member Empty =
+        {
+            Phase1 = None
+            Phase2 = None
+            Phase3 = None
+        }
 
 type WorkItem =
     | Phase1 of Phase1Inputs
@@ -108,161 +115,163 @@ type WorkItem =
     | Phase3 of Phase3Inputs
 
 type Idx = int
+
 type Node =
     {
         Idx: Idx
         Phase: Phase
     }
-    with override this.ToString() = $"[{this.Idx}-{this.Phase}]"
 
+    override this.ToString() = $"[{this.Idx}-{this.Phase}]"
 
 let getPhase1Res (p: FileResults) =
-    p.Phase1
-    |> Option.get
-    |> fun ((env, _, _, hidden), _) -> env, hidden
+    p.Phase1 |> Option.get |> (fun ((env, _, _, hidden), _) -> env, hidden)
 
-let getPhase2Res (p: FileResults) =
-    p.Phase2
-    |> Option.get
+let getPhase2Res (p: FileResults) = p.Phase2 |> Option.get
 
 let getPhase3Res (p: FileResults) =
-    p.Phase3
-    |> Option.get
-    |> fun (env, _) -> env
+    p.Phase3 |> Option.get |> (fun (env, _) -> env)
 
-let optimizeFilesInParallel (env0: Optimizer.IncrementalOptimizationEnv) ((phase1, phase2, phase3): FilePhaseFuncs) (files: CheckedImplFile list) : CollectorOutputs =
+let optimizeFilesInParallel
+    (env0: Optimizer.IncrementalOptimizationEnv)
+    ((phase1, phase2, phase3): FilePhaseFuncs)
+    (files: CheckedImplFile list)
+    : CollectorOutputs =
     let files = files |> List.toArray
     // Schedule File1-Phase1
     let firstNode = { Idx = 0; Phase = Phase.Phase1 }
-    
-    let results =
-        files
-        |> Array.map (fun _ -> FileResults.Empty)
-    
-    let _lock = obj()
-    let nodeCanBeProcessed {Idx = idx; Phase = phase} : bool =
+
+    let results = files |> Array.map (fun _ -> FileResults.Empty)
+
+    let _lock = obj ()
+
+    let nodeCanBeProcessed { Idx = idx; Phase = phase } : bool =
         lock (_lock) (fun () ->
-            let previousFileReady =
-                if idx = 0 then true else results[idx-1].HasResult phase
+            let previousFileReady = if idx = 0 then true else results[ idx - 1 ].HasResult phase
+
             let previousPhase =
                 match phase with
                 | Phase.Phase1 -> None
                 | Phase.Phase2 -> Some Phase.Phase1
                 | Phase.Phase3 -> Some Phase.Phase2
+
             let previousPhaseReady =
                 match previousPhase with
-                | Some previousPhase -> results[idx].HasResult previousPhase
+                | Some previousPhase -> results[ idx ].HasResult previousPhase
                 | None -> true
-            previousFileReady && previousPhaseReady
-        )        
-    
+
+            previousFileReady && previousPhaseReady)
+
     let visited = HashSet<Node>()
-    
-    let worker ({Idx = idx; Phase = phase} as node : Node) : Node[] =
-        let notPreviouslyVisited =
-            lock (_lock) (fun () ->
-                visited.Add node
-            )
-        if notPreviouslyVisited = false then [||]
+
+    let worker ({ Idx = idx; Phase = phase } as node: Node) : Node[] =
+        let notPreviouslyVisited = lock (_lock) (fun () -> visited.Add node)
+
+        if notPreviouslyVisited = false then
+            [||]
         else
-        let res = results[idx]
-        let file = files[idx]
-        let previous = if idx > 0 then Some results[idx-1] else None
-        let hidingInfo0 = SignatureHidingInfo.Empty        
-        
-        let getPhase1Res (p: FileResults) =
-            p.Phase1
-            |> Option.get
-            |> fun ((env, file, info, hidden), _) -> env, file, info, hidden
-                
-        match phase with
-        | Phase.Phase1 ->
-            // take env from previous file
-            let env, hidingInfo =
-                previous
-                |> Option.map getPhase1Res
-                |> Option.map (fun (a, _b, _c, d) -> a, d)
-                |> Option.defaultValue (env0, hidingInfo0)
-            let inputs = env, hidingInfo, file
-            let phase1Res = phase1 inputs
-            res.Phase1 <- Some phase1Res
-            
-            // Schedule Phase2
-            let phase2Node = { Idx = idx; Phase = Phase.Phase2 }
-            seq {
-                yield phase2Node
-                if idx < files.Length-1 then yield { Idx = idx + 1; Phase = Phase.Phase1 }
-            }
-            |> Seq.toArray
-            
-        | Phase.Phase2 ->
-            // take env from previous file
-            let env =
-                previous
-                |> Option.map getPhase2Res
-                |> Option.map fst
-                |> Option.defaultValue env0
-            let file, info, hidingInfo =
-                res
-                |> getPhase1Res
-                |> fun (_a, b, c, d) -> b, c, d
-            let inputs = env, hidingInfo, info, file
-            let phase2Res = phase2 inputs
-            res.Phase2 <- Some phase2Res
-            
-            seq {
-                // Schedule Phase3
-                let phase3Node = { Idx = idx; Phase = Phase.Phase3 }
-                yield phase3Node
-                // Schedule Phase2 for the next file if it exists
-                if idx < files.Length-1 then yield { Idx = idx + 1; Phase = Phase.Phase2 }
-            }
-            |> Seq.toArray
-            
-        | Phase.Phase3 ->
-            // take env from previous file
-            let env =
-                previous
-                |> Option.map getPhase3Res
-                |> Option.defaultValue env0
-            // impl file
-            let _, file =
-                res
-                |> getPhase2Res
-            let hidingInfo =
-                res
-                |> getPhase1Res
-                |> fun (_a,_b,_c,d) -> d
-            let inputs = env, hidingInfo, file
-            let phase3Res = phase3 inputs
-            res.Phase3 <- Some phase3Res
-            
-            seq {
-                // Schedule Phase3 for the next file if it exists
-                if idx < files.Length-1 then yield { Idx = idx + 1; Phase = Phase.Phase3 }
-            }
-            |> Seq.toArray
-        |> fun nodes ->
-            nodes
-            |> Array.filter nodeCanBeProcessed
-    
+            let res = results[idx]
+            let file = files[idx]
+            let previous = if idx > 0 then Some results[idx - 1] else None
+            let hidingInfo0 = SignatureHidingInfo.Empty
+
+            let getPhase1Res (p: FileResults) =
+                p.Phase1
+                |> Option.get
+                |> fun ((env, file, info, hidden), _) -> env, file, info, hidden
+
+            match phase with
+            | Phase.Phase1 ->
+                // take env from previous file
+                let env, hidingInfo =
+                    previous
+                    |> Option.map getPhase1Res
+                    |> Option.map (fun (a, _b, _c, d) -> a, d)
+                    |> Option.defaultValue (env0, hidingInfo0)
+
+                let inputs = env, hidingInfo, file
+                let phase1Res = phase1 inputs
+                res.Phase1 <- Some phase1Res
+
+                // Schedule Phase2
+                let phase2Node = { Idx = idx; Phase = Phase.Phase2 }
+
+                seq {
+                    yield phase2Node
+
+                    if idx < files.Length - 1 then
+                        yield { Idx = idx + 1; Phase = Phase.Phase1 }
+                }
+                |> Seq.toArray
+
+            | Phase.Phase2 ->
+                // take env from previous file
+                let env =
+                    previous
+                    |> Option.map getPhase2Res
+                    |> Option.map fst
+                    |> Option.defaultValue env0
+
+                let file, info, hidingInfo = res |> getPhase1Res |> (fun (_a, b, c, d) -> b, c, d)
+                let inputs = env, hidingInfo, info, file
+                let phase2Res = phase2 inputs
+                res.Phase2 <- Some phase2Res
+
+                seq {
+                    // Schedule Phase3
+                    let phase3Node = { Idx = idx; Phase = Phase.Phase3 }
+                    yield phase3Node
+                    // Schedule Phase2 for the next file if it exists
+                    if idx < files.Length - 1 then
+                        yield { Idx = idx + 1; Phase = Phase.Phase2 }
+                }
+                |> Seq.toArray
+
+            | Phase.Phase3 ->
+                // take env from previous file
+                let env = previous |> Option.map getPhase3Res |> Option.defaultValue env0
+                // impl file
+                let _, file = res |> getPhase2Res
+                let hidingInfo = res |> getPhase1Res |> (fun (_a, _b, _c, d) -> d)
+                let inputs = env, hidingInfo, file
+                let phase3Res = phase3 inputs
+                res.Phase3 <- Some phase3Res
+
+                seq {
+                    // Schedule Phase3 for the next file if it exists
+                    if idx < files.Length - 1 then
+                        yield { Idx = idx + 1; Phase = Phase.Phase3 }
+                }
+                |> Seq.toArray
+            |> fun nodes -> nodes |> Array.filter nodeCanBeProcessed
+
     Parallel.processInParallel
-        [|firstNode|]
+        [| firstNode |]
         worker
         10
         (fun _ -> visited.Count >= files.Length * 3)
         (CancellationToken.None)
         (fun node -> node.ToString())
-        
+
     Debug.Assert(visited.Count = files.Length * 3)
-    
+
     let results =
         results
-        |> Array.mapi (fun i {Phase1 = phase1; Phase2 = phase2; Phase3 = phase3} ->
-            match phase1, phase2, phase3 with
-            | Some phase1, Some phase2, Some phase3 -> {FileResultsComplete.Phase1 = phase1; Phase2 = phase2; Phase3 = phase3}
-            | _ -> failwith $"Unexpected lack of results for file [{i}]"
-        )
+        |> Array.mapi
+            (fun i {
+                       Phase1 = phase1
+                       Phase2 = phase2
+                       Phase3 = phase3
+                   } ->
+                match phase1, phase2, phase3 with
+                | Some phase1, Some phase2, Some phase3 ->
+                    {
+                        FileResultsComplete.Phase1 = phase1
+                        Phase2 = phase2
+                        Phase3 = phase3
+                    }
+                | _ -> failwith $"Unexpected lack of results for file [{i}]")
+
     let collected = results |> collectResults
     collected
 
@@ -308,9 +317,8 @@ let ApplyAllOptimizations
             reportingPhase = true
         }
 
-    
     let env0 = optEnv0
-    
+
     let phase1 (env: Optimizer.IncrementalOptimizationEnv, hidden: SignatureHidingInfo, implFile: CheckedImplFile) : Phase1Res =
         //ReportTime tcConfig ("Initial simplify")
         Optimizer.OptimizeImplFile(
@@ -326,8 +334,14 @@ let ApplyAllOptimizations
             hidden,
             implFile
         )
-    
-    let phase2 (env: Optimizer.IncrementalOptimizationEnv, hidden: SignatureHidingInfo, implFileOptData: Optimizer.ImplFileOptimizationInfo, implFile: CheckedImplFile) : Phase2Res =
+
+    let phase2
+        (
+            env: Optimizer.IncrementalOptimizationEnv,
+            hidden: SignatureHidingInfo,
+            implFileOptData: Optimizer.ImplFileOptimizationInfo,
+            implFile: CheckedImplFile
+        ) : Phase2Res =
         let implFile = LowerLocalMutables.TransformImplFile tcGlobals importMap implFile
 
         // Only do this on the first pass!
@@ -341,6 +355,9 @@ let ApplyAllOptimizations
             dprintf
                 "Optimization implFileOptData:\n%s\n"
                 (LayoutRender.showL (Display.squashTo 192 (Optimizer.moduleInfoL tcGlobals implFileOptData)))
+#else
+        // Satisfy the compiler
+        implFileOptData |> ignore
 #endif
 
         if tcConfig.extraOptimizationIterations > 0 then
@@ -365,7 +382,7 @@ let ApplyAllOptimizations
             optEnvExtraLoop, implFile
         else
             env, implFile
-        
+
     let phase3 (env: Optimizer.IncrementalOptimizationEnv, hidden: SignatureHidingInfo, implFile: CheckedImplFile) : Phase3Res =
         // Only do this on the first pass!
         let optSettings =
@@ -414,28 +431,29 @@ let ApplyAllOptimizations
             optEnvFinalSimplify, implFile
         else
             env, implFile
-    
+
     let results, optEnvFirstLoop =
         match optSettings.processingMode with
-        | OptimizerMode.PartiallyParallel ->
-            let a, b =
-                optimizeFilesInParallel env0 (phase1, phase2, phase3) implFiles
+        | Optimizer.OptimizerMode.PartiallyParallel ->
+            let a, b = optimizeFilesInParallel env0 (phase1, phase2, phase3) implFiles
             a |> Array.toList, b
-        | OptimizerMode.Sequential ->
+        | Optimizer.OptimizerMode.Sequential ->
             let results, (optEnvFirstLoop, _, _, _) =
                 ((optEnv0, optEnv0, optEnv0, SignatureHidingInfo.Empty), implFiles)
 
                 ||> List.mapFold (fun (optEnvFirstLoop, optEnvExtraLoop, optEnvFinalSimplify, hidden) implFile ->
                     // Phase 1
                     //ReportTime tcConfig ("Initial simplify")
-                    let (optEnvFirstLoop, implFile, implFileOptData, hidden), optimizeDuringCodeGen = phase1 (optEnvFirstLoop, hidden, implFile)
+                    let (optEnvFirstLoop, implFile, implFileOptData, hidden), optimizeDuringCodeGen =
+                        phase1 (optEnvFirstLoop, hidden, implFile)
 
                     // Phase 2
-                    let optEnvExtraLoop, implFile = phase2 (optEnvExtraLoop, hidden, implFileOptData, implFile)
+                    let optEnvExtraLoop, implFile =
+                        phase2 (optEnvExtraLoop, hidden, implFileOptData, implFile)
 
                     // Phase 3
                     let optEnvFinalSimplify, implFile = phase3 (optEnvFinalSimplify, hidden, implFile)
-                    
+
                     let implFile =
                         {
                             ImplFile = implFile
@@ -443,6 +461,7 @@ let ApplyAllOptimizations
                         }
 
                     (implFile, implFileOptData), (optEnvFirstLoop, optEnvExtraLoop, optEnvFinalSimplify, hidden))
+
             results, optEnvFirstLoop
 
     let implFiles, implFileOptDatas = List.unzip results
diff --git a/src/Compiler/Driver/OptimizeTypes.fs b/src/Compiler/Driver/OptimizeTypes.fs
index 40f33752dcd..2b56baa0c48 100644
--- a/src/Compiler/Driver/OptimizeTypes.fs
+++ b/src/Compiler/Driver/OptimizeTypes.fs
@@ -7,22 +7,10 @@ open FSharp.Compiler.TypedTree
 open FSharp.Compiler.TypedTreeOps
 
 type OptimizeDuringCodeGen = bool -> Expr -> Expr
-type OptimizeRes =
-    (IncrementalOptimizationEnv * CheckedImplFile * ImplFileOptimizationInfo * SignatureHidingInfo) * OptimizeDuringCodeGen
+type OptimizeRes = (IncrementalOptimizationEnv * CheckedImplFile * ImplFileOptimizationInfo * SignatureHidingInfo) * OptimizeDuringCodeGen
 
 type Optimize =
-    OptimizationSettings *
-    CcuThunk *
-    TcGlobals *
-    ConstraintSolver.TcValF *
-    Import.ImportMap *
-    IncrementalOptimizationEnv *
-    bool *
-    bool *
-    bool *
-    SignatureHidingInfo *
-    CheckedImplFile ->
-        OptimizeRes
+    OptimizationSettings * CcuThunk * TcGlobals * ConstraintSolver.TcValF * Import.ImportMap * IncrementalOptimizationEnv * bool * bool * bool * SignatureHidingInfo * CheckedImplFile -> OptimizeRes
 
 type PhaseInputs = IncrementalOptimizationEnv * SignatureHidingInfo * CheckedImplFile
 
@@ -42,13 +30,16 @@ type Phase =
     | Phase1
     | Phase2
     | Phase3
+
 module Phase =
-    let all = [|Phase1; Phase2; Phase3|]
+    let all = [| Phase1; Phase2; Phase3 |]
+
     let prev (phase: Phase) =
         match phase with
         | Phase1 -> None
         | Phase2 -> Some Phase1
         | Phase3 -> Some Phase2
+
     let next (phase: Phase) =
         match phase with
         | Phase1 -> Some Phase2
@@ -59,22 +50,24 @@ type PhaseRes =
     | Phase1 of Phase1Res
     | Phase2 of Phase2Res
     | Phase3 of Phase3Res
-    with
-        member x.Which =
-            match x with
-            | Phase1 _ -> Phase.Phase1
-            | Phase2 _ -> Phase.Phase2
-            | Phase3 _ -> Phase.Phase3
-        member x.Get1() =
-            match x with
-            | Phase1 x -> x
-            | Phase2 _
-            | Phase3 _ -> failwith $"Called {nameof(x.Get1)} but this is {x.Which}"
-        member x.Get2() =
-            match x with
-            | Phase2 x -> x
-            | Phase1 _
-            | Phase3 _ -> failwith $"Called {nameof(x.Get2)} but this is {x.Which}"
+
+    member x.Which =
+        match x with
+        | Phase1 _ -> Phase.Phase1
+        | Phase2 _ -> Phase.Phase2
+        | Phase3 _ -> Phase.Phase3
+
+    member x.Get1() =
+        match x with
+        | Phase1 x -> x
+        | Phase2 _
+        | Phase3 _ -> failwith $"Called {nameof (x.Get1)} but this is {x.Which}"
+
+    member x.Get2() =
+        match x with
+        | Phase2 x -> x
+        | Phase1 _
+        | Phase3 _ -> failwith $"Called {nameof (x.Get2)} but this is {x.Which}"
 
 type FileResultsComplete =
     {
@@ -82,5 +75,6 @@ type FileResultsComplete =
         Phase2: Phase2Res
         Phase3: Phase3Res
     }
+
 type CollectorInputs = FileResultsComplete[]
 type CollectorOutputs = (CheckedImplFileAfterOptimization * ImplFileOptimizationInfo)[] * IncrementalOptimizationEnv
diff --git a/src/Compiler/Driver/Parallel.fs b/src/Compiler/Driver/Parallel.fs
index 3e566dd97a8..df19bd434d6 100644
--- a/src/Compiler/Driver/Parallel.fs
+++ b/src/Compiler/Driver/Parallel.fs
@@ -24,19 +24,19 @@ let processInParallel
     let mutable processedCount = 0
 
     let processItem item =
-        printfn $"[{Thread.CurrentThread.ManagedThreadId}] Processing {_itemToString item}"
+        // printfn $"[{Thread.CurrentThread.ManagedThreadId}] Processing {_itemToString item}"
         let toSchedule = work item
-        printfn $"[{Thread.CurrentThread.ManagedThreadId}] Finished {_itemToString item}"
+        // printfn $"[{Thread.CurrentThread.ManagedThreadId}] Finished {_itemToString item}"
 
         let processedCount =
             lock processedCountLock (fun () ->
                 processedCount <- processedCount + 1
                 processedCount)
 
-        let toScheduleString =
-            toSchedule |> Array.map _itemToString |> (fun names -> String.Join(", ", names))
+        // let toScheduleString =
+            // toSchedule |> Array.map _itemToString |> (fun names -> String.Join(", ", names))
 
-        printfn $"[{Thread.CurrentThread.ManagedThreadId}] Scheduling {toSchedule.Length} items: {toScheduleString}"
+        // printfn $"[{Thread.CurrentThread.ManagedThreadId}] Scheduling {toSchedule.Length} items: {toScheduleString}"
         toSchedule |> Array.iter bc.Add
         processedCount
 
@@ -51,4 +51,3 @@ let processInParallel
 
     // TODO Do we need to handle cancellation given that workers do it already?
     Array.Parallel.map workerWork (Array.init parallelism (fun _ -> ())) |> ignore
-
diff --git a/src/Compiler/Driver/fsc.fs b/src/Compiler/Driver/fsc.fs
index e8ec56fa5a5..c50db076254 100644
--- a/src/Compiler/Driver/fsc.fs
+++ b/src/Compiler/Driver/fsc.fs
@@ -820,13 +820,6 @@ let main3
     ReportTime tcConfig "Encode Interface Data"
     let exportRemapping = MakeExportRemapping generatedCcu generatedCcu.Contents
 
-    let sigDataAttributes, sigDataResources =
-        try
-            EncodeSignatureData(tcConfig, tcGlobals, exportRemapping, generatedCcu, outfile, false)
-        with e ->
-            errorRecoveryNoRange e
-            exiter.Exit 1
-
     let metadataVersion =
         match tcConfig.metadataVersion with
         | Some v -> v
@@ -834,35 +827,61 @@ let main3
             match frameworkTcImports.DllTable.TryFind tcConfig.primaryAssembly.Name with
             | Some ib -> ib.RawMetadata.TryGetILModuleDef().Value.MetadataVersion
             | _ -> ""
+            
+    // TODO Use proper async code
+    let (sigDataAttributes, sigDataResources), optimizedImpls, optDataResources =
+        let mutable sigDataAttributes: ILAttribute list = []
+        let mutable sigDataResources : ILResource list = []
+        let a1 =
+            async {
+                try
+                    let sigDataAttributes2, sigDataResources2 = EncodeSignatureData(tcConfig, tcGlobals, exportRemapping, generatedCcu, outfile, false)
+                    sigDataAttributes <- sigDataAttributes2
+                    sigDataResources <- sigDataResources2
+                with e ->
+                    errorRecoveryNoRange e
+                    exiter.Exit 1
+            }
 
-    let optimizedImpls, optDataResources =
-        // Perform optimization
-        use _ = UseBuildPhase BuildPhase.Optimize
-
-        let optEnv0 = GetInitialOptimizationEnv(tcImports, tcGlobals)
-
-        let importMap = tcImports.GetImportMap()
-
-        let optimizedImpls, optimizationData, _ =
-            ApplyAllOptimizations(
-                tcConfig,
-                tcGlobals,
-                (LightweightTcValForUsingInBuildMethodCall tcGlobals),
-                outfile,
-                importMap,
-                false,
-                optEnv0,
-                generatedCcu,
-                typedImplFiles
-            )
-
-        AbortOnError(diagnosticsLogger, exiter)
+        let mutable optimizedImpls2 : CheckedAssemblyAfterOptimization option = None
+        let mutable optDataResources : ILResource list = []
+        let a2 =
+            async {
+                // Perform optimization
+                use _ = UseBuildPhase BuildPhase.Optimize
+
+                let optEnv0 = GetInitialOptimizationEnv(tcImports, tcGlobals)
+
+                let importMap = tcImports.GetImportMap()
+
+                let optimizedImpls, optimizationData, _ =
+                    ApplyAllOptimizations(
+                        tcConfig,
+                        tcGlobals,
+                        (LightweightTcValForUsingInBuildMethodCall tcGlobals),
+                        outfile,
+                        importMap,
+                        false,
+                        optEnv0,
+                        generatedCcu,
+                        typedImplFiles
+                    )
 
-        // Encode the optimization data
-        ReportTime tcConfig ("Encoding OptData")
+                AbortOnError(diagnosticsLogger, exiter)
 
-        optimizedImpls, EncodeOptimizationData(tcGlobals, tcConfig, outfile, exportRemapping, (generatedCcu, optimizationData), false)
+                // Encode the optimization data
+                ReportTime tcConfig ("Encoding OptData")
 
+                optimizedImpls2 <- Some optimizedImpls
+                optDataResources <- EncodeOptimizationData(tcGlobals, tcConfig, outfile, exportRemapping, (generatedCcu, optimizationData), false)
+            }
+        
+        let t1 = a1 |> Async.StartAsTask
+        let t2 = a2 |> Async.StartAsTask
+        t1.Wait()
+        t2.Wait()
+        (sigDataAttributes, sigDataResources), optimizedImpls2.Value, optDataResources
+        
     // Pass on only the minimum information required for the next phase
     Args(
         ctok,
diff --git a/src/Compiler/Optimize/Optimizer.fsi b/src/Compiler/Optimize/Optimizer.fsi
index 20368b34814..50bc200881c 100644
--- a/src/Compiler/Optimize/Optimizer.fsi
+++ b/src/Compiler/Optimize/Optimizer.fsi
@@ -45,8 +45,8 @@ type OptimizationSettings =
         reportHasEffect: bool
 
         reportTotalSizes: bool
-        
-        processingMode : OptimizerMode
+
+        processingMode: OptimizerMode
     }
 
     member JitOptimizationsEnabled: bool

From cf2bb2669c217d1b0c63fadf57894339ae5e1d6b Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Wed, 23 Nov 2022 21:10:57 +0000
Subject: [PATCH 04/42] WIP - partially parallel release optimization

---
 src/Compiler/Driver/Graph.fs                | 107 +++++
 src/Compiler/Driver/GraphProcessing.fs      | 458 ++++++++++++++++++++
 src/Compiler/Driver/OptimizeInputs.fs       | 435 +++++++++++++++----
 src/Compiler/Driver/OptimizeInputs.fsi      |   8 +
 src/Compiler/Driver/OptimizeTypes.fs        |  86 ++++
 src/Compiler/Driver/Parallel.fs             |  54 +++
 src/Compiler/FSharp.Compiler.Service.fsproj |   4 +
 7 files changed, 1060 insertions(+), 92 deletions(-)
 create mode 100644 src/Compiler/Driver/Graph.fs
 create mode 100644 src/Compiler/Driver/GraphProcessing.fs
 create mode 100644 src/Compiler/Driver/OptimizeTypes.fs
 create mode 100644 src/Compiler/Driver/Parallel.fs

diff --git a/src/Compiler/Driver/Graph.fs b/src/Compiler/Driver/Graph.fs
new file mode 100644
index 00000000000..622d1ec2d2f
--- /dev/null
+++ b/src/Compiler/Driver/Graph.fs
@@ -0,0 +1,107 @@
+module FSharp.Compiler.Service.Driver.Graph
+
+#nowarn "1182"
+#nowarn "40"
+
+open System.Collections.Generic
+open System.IO
+open Newtonsoft.Json
+open ParallelTypeCheckingTests.Utils
+
+/// <summary> DAG of files </summary>
+type Graph<'Node> = IReadOnlyDictionary<'Node, 'Node[]>
+
+module Graph =
+
+    let make (nodeDeps: ('Node * 'Node[]) seq) = nodeDeps |> readOnlyDict
+
+    let map (f: 'a -> 'b) (graph: Graph<'a>) : Graph<'b> =
+        graph
+        |> Seq.map (fun (KeyValue (node, deps)) -> f node, deps |> Array.map f)
+        |> make
+
+    let collectEdges<'Node when 'Node: equality> (graph: Graph<'Node>) : ('Node * 'Node)[] =
+        let graph: IReadOnlyDictionary<'Node, 'Node[]> = graph
+
+        graph
+        |> Seq.collect (fun (KeyValue (node, deps)) -> deps |> Array.map (fun dep -> node, dep))
+        |> Seq.toArray
+
+    let addIfMissing<'Node when 'Node: equality> (nodes: 'Node seq) (graph: Graph<'Node>) : Graph<'Node> =
+        nodes
+        |> Seq.except (graph.Keys |> Seq.toArray)
+        |> fun missing ->
+            let toAdd = missing |> Seq.map (fun n -> KeyValuePair(n, [||])) |> Seq.toArray
+
+            let x = Array.append (graph |> Seq.toArray) toAdd
+            x |> Dictionary<_, _> |> (fun x -> x :> IReadOnlyDictionary<_, _>)
+
+    /// Create entries for nodes that don't have any dependencies but are mentioned as dependencies themselves
+    let fillEmptyNodes<'Node when 'Node: equality> (graph: Graph<'Node>) : Graph<'Node> =
+        let missingNodes =
+            graph.Values |> Seq.toArray |> Array.concat |> Array.except graph.Keys
+
+        addIfMissing missingNodes graph
+
+    /// Create a transitive closure of the graph
+    let transitiveOpt<'Node when 'Node: equality> (graph: Graph<'Node>) : Graph<'Node> =
+        let go (node: 'Node) =
+            let visited = HashSet<'Node>()
+
+            let rec dfs (node: 'Node) =
+                graph[node] |> Array.filter visited.Add |> Array.iter dfs
+
+            dfs node
+            visited |> Seq.toArray
+
+        graph.Keys
+        |> Seq.toArray
+        |> Array.Parallel.map (fun node -> node, go node)
+        |> readOnlyDict
+
+    /// Create a transitive closure of the graph
+    let transitive<'Node when 'Node: equality> (graph: Graph<'Node>) : Graph<'Node> =
+        let rec calcTransitiveEdges =
+            fun (node: 'Node) ->
+                let edgeTargets =
+                    match graph.TryGetValue node with
+                    | true, x -> x
+                    | false, _ -> failwith "FOO"
+
+                edgeTargets
+                |> Array.collect calcTransitiveEdges
+                |> Array.append edgeTargets
+                |> Array.distinct
+            // Dispose of memoisation context
+            |> memoize
+
+        graph.Keys
+        |> Seq.map (fun node -> node, calcTransitiveEdges node)
+        |> readOnlyDict
+
+    /// Create a reverse of the graph
+    let reverse (originalGraph: Graph<'Node>) : Graph<'Node> =
+        originalGraph
+        // Collect all edges
+        |> Seq.collect (fun (KeyValue (idx, deps)) -> deps |> Array.map (fun dep -> idx, dep))
+        // Group dependants of the same dependencies together
+        |> Seq.groupBy (fun (_idx, dep) -> dep)
+        // Construct reversed graph
+        |> Seq.map (fun (dep, edges) -> dep, edges |> Seq.map fst |> Seq.toArray)
+        |> readOnlyDict
+        |> addIfMissing originalGraph.Keys
+
+    let printCustom (graph: Graph<'Node>) (printer: 'Node -> string) : unit =
+        printfn "Graph:"
+        let join (xs: string[]) = System.String.Join(", ", xs)
+
+        graph
+        |> Seq.iter (fun (KeyValue (file, deps)) -> printfn $"{file} -> {deps |> Array.map printer |> join}")
+
+    let print (graph: Graph<'Node>) : unit =
+        printCustom graph (fun node -> node.ToString())
+
+    let serialiseToJson (path: string) (graph: Graph<'Node>) : unit =
+        let json = JsonConvert.SerializeObject(graph, Formatting.Indented)
+        printfn $"Serialising graph as JSON in {path}"
+        File.WriteAllText(path, json)
diff --git a/src/Compiler/Driver/GraphProcessing.fs b/src/Compiler/Driver/GraphProcessing.fs
new file mode 100644
index 00000000000..d3489fe78ee
--- /dev/null
+++ b/src/Compiler/Driver/GraphProcessing.fs
@@ -0,0 +1,458 @@
+/// Parallel processing of graph of work items with dependencies
+module FSharp.Compiler.Service.Driver.GraphProcessing
+
+open System.Collections.Concurrent
+open System.Collections.Generic
+open System.Threading
+open FSharp.Compiler.Service.Driver.Graph
+
+/// Used for processing
+type NodeInfo<'Item> =
+    {
+        Item: 'Item
+        Deps: 'Item[]
+        TransitiveDeps: 'Item[]
+        Dependants: 'Item[]
+    }
+
+type StateMeta<'Item> =
+    {
+        Contributors: 'Item[]
+    }
+
+    static member Empty() = { Contributors = [||] }
+
+type StateWrapper<'Item, 'State> =
+    {
+        Meta: StateMeta<'Item>
+        State: 'State
+    }
+
+type ResultWrapper<'Item, 'Result> = { Item: 'Item; Result: 'Result }
+
+type Node<'Item, 'State, 'Result> =
+    {
+        Info: NodeInfo<'Item>
+        mutable ProcessedDepsCount: int
+        mutable Result: ('State * 'Result) option
+        mutable InputState: 'State option
+    }
+
+// TODO Do we need to suppress some error logging if we
+// TODO apply the same partial results multiple times?
+// TODO Maybe we can enable logging only for the final fold
+/// <summary>
+/// Combine results of dependencies needed to type-check a 'higher' node in the graph
+/// </summary>
+/// <param name="deps">Direct dependencies of a node</param>
+/// <param name="transitiveDeps">Transitive dependencies of a node</param>
+/// <param name="folder">A way to fold a single result into existing state</param>
+let combineResultsOld
+    (emptyState: 'State)
+    (deps: Node<'Item, 'State, 'Result>[])
+    (transitiveDeps: Node<'Item, 'State, 'Result>[])
+    (folder: 'State -> 'Result -> 'State)
+    : 'State =
+    match deps with
+    | [||] -> emptyState
+    | _ ->
+
+        let biggestDep =
+            let sizeMetric node =
+                // Could also use eg. total file size/AST size
+                node.Info.Item
+            // node.Info.TransitiveDeps.Length
+            deps
+            // TODO To workaround a problem with merging state in the wrong order,
+            // we temporarily effectively pick the child with the lowest index.
+            // This means children are folded fully in sequence
+            |> Array.minBy sizeMetric
+
+        let orFail value =
+            value |> Option.defaultWith (fun () -> failwith "Unexpected lack of result")
+
+        let firstState = biggestDep.Result |> orFail |> fst
+
+        // TODO Potential perf optimisation: Keep transDeps in a HashSet from the start,
+        // avoiding reconstructing the HashSet here
+
+        // Add single-file results of remaining transitive deps one-by-one using folder
+        // Note: Good to preserve order here so that folding happens in file order
+        let included =
+            let set = HashSet(biggestDep.Info.TransitiveDeps)
+            set.Add biggestDep.Info.Item |> ignore
+            set
+
+        let resultsToAdd =
+            transitiveDeps
+            |> Array.filter (fun dep -> included.Contains dep.Info.Item = false)
+            |> Array.distinctBy (fun dep -> dep.Info.Item)
+            |> Array.map (fun dep -> dep.Result |> orFail |> snd)
+
+        let state = Array.fold folder firstState resultsToAdd
+        state
+
+// TODO Do we need to suppress some error logging if we
+// TODO apply the same partial results multiple times?
+// TODO Maybe we can enable logging only for the final fold
+/// <summary>
+/// Combine results of dependencies needed to type-check a 'higher' node in the graph
+/// </summary>
+/// <param name="deps">Direct dependencies of a node</param>
+/// <param name="transitiveDeps">Transitive dependencies of a node</param>
+/// <param name="folder">A way to fold a single result into existing state</param>
+let combineResults
+    (emptyState: 'State)
+    (deps: Node<'Item, 'State, 'Result>[])
+    (transitiveDeps: Node<'Item, 'State, 'Result>[])
+    (folder: 'State -> 'Result -> 'State)
+    (_foldingOrderer: 'Item -> int)
+    : 'State =
+    match deps with
+    | [||] -> emptyState
+    | _ ->
+        let orFail value =
+            value |> Option.defaultWith (fun () -> failwith "Unexpected lack of result")
+
+        let firstState = emptyState
+        // TODO Potential perf optimisation: Keep transDeps in a HashSet from the start,
+        // avoiding reconstructing the HashSet here
+
+        // Add single-file results of remaining transitive deps one-by-one using folder
+        // Note: Good to preserve order here so that folding happens in file order
+        let included =
+            let set = HashSet()
+            //set.Add biggestDep.Info.Item |> ignore
+            set
+
+        let resultsToAdd =
+            transitiveDeps
+            // Sort it by effectively file index.
+            // For some reason this is needed, otherwise gives 'missing namespace' and other errors when using the resulting state.
+            // Does this make sense? Should the results be foldable in any order?
+            // TODO Use _foldingOrderer
+            |> Array.sortBy (fun node -> node.Info.Item)
+            |> Array.filter (fun dep -> included.Contains dep.Info.Item = false)
+            |> Array.distinctBy (fun dep -> dep.Info.Item)
+            |> Array.map (fun dep -> dep.Result |> orFail |> snd)
+
+        let state = Array.fold folder firstState resultsToAdd
+        state
+
+// TODO Could be replaced with a simpler recursive approach with memoised per-item results
+let processGraph<'Item, 'State, 'Result, 'FinalFileResult when 'Item: equality and 'Item: comparison>
+    (graph: Graph<'Item>)
+    (doWork: 'Item -> 'State -> 'Result)
+    (folder: 'State -> 'Result -> 'FinalFileResult * 'State)
+    (foldingOrderer: 'Item -> int)
+    (emptyState: 'State)
+    (includeInFinalState: 'Item -> bool)
+    (parallelism: int)
+    : 'FinalFileResult[] * 'State =
+    let transitiveDeps = graph |> Graph.transitiveOpt
+    let dependants = graph |> Graph.reverse
+
+    let makeNode (item: 'Item) : Node<'Item, StateWrapper<'Item, 'State>, ResultWrapper<'Item, 'Result>> =
+        let info =
+            let exists = graph.ContainsKey item
+
+            if
+                not exists
+                || not (transitiveDeps.ContainsKey item)
+                || not (dependants.ContainsKey item)
+            then
+                printfn $"WHAT {item}"
+
+            {
+                Item = item
+                Deps = graph[item]
+                TransitiveDeps = transitiveDeps[item]
+                Dependants = dependants[item]
+            }
+
+        {
+            Info = info
+            Result = None
+            ProcessedDepsCount = 0
+            InputState = None
+        }
+
+    let nodes = graph.Keys |> Seq.map (fun item -> item, makeNode item) |> readOnlyDict
+    let lookup item = nodes[item]
+    let lookupMany items = items |> Array.map lookup
+
+    let leaves =
+        nodes.Values |> Seq.filter (fun n -> n.Info.Deps.Length = 0) |> Seq.toArray
+
+    let emptyState =
+        {
+            Meta = StateMeta.Empty<'Item>()
+            State = emptyState
+        }
+
+    let folder { Meta = meta; State = state } { Item = item; Result = result } =
+        let finalFileResult, state = folder state result
+
+        let state =
+            {
+                Meta =
+                    {
+                        Contributors = Array.append meta.Contributors [| item |]
+                    }
+                State = state
+            }
+
+        finalFileResult, state
+
+    printfn $"Node count: {nodes.Count}"
+    // let mutable cnt = 1
+
+    let work
+        (node: Node<'Item, StateWrapper<'Item, 'State>, ResultWrapper<'Item, 'Result>>)
+        : Node<'Item, StateWrapper<'Item, 'State>, ResultWrapper<'Item, 'Result>>[] =
+        let folder x y = folder x y |> snd
+        let deps = lookupMany node.Info.Deps
+        let transitiveDeps = lookupMany node.Info.TransitiveDeps
+        let inputState = combineResults emptyState deps transitiveDeps folder foldingOrderer
+        node.InputState <- Some inputState
+        let singleRes = doWork node.Info.Item inputState.State
+
+        let singleRes =
+            {
+                Item = node.Info.Item
+                Result = singleRes
+            }
+
+        let state = folder inputState singleRes
+        //let state,  = folder inputState singleRes
+        node.Result <- Some(state, singleRes)
+        // Need to double-check that only one dependency schedules this dependant
+        let unblocked =
+            node.Info.Dependants
+            |> lookupMany
+            |> Array.filter (fun x ->
+                let pdc =
+                    // TODO Not ideal, better ways most likely exist
+                    lock x (fun () ->
+                        x.ProcessedDepsCount <- x.ProcessedDepsCount + 1
+                        x.ProcessedDepsCount)
+
+                pdc = x.Info.Deps.Length)
+        // printfn $"State after {node.Info.Item}"
+        // nodes
+        // |> Seq.map (fun (KeyValue(_, v)) ->
+        //     let x = v.Info.Deps.Length - v.ProcessedDepsCount
+        //     $"{v.Info.Item} - {x} deps left"
+        // )
+        // |> Seq.iter (fun x -> printfn $"{x}")
+        // let c = cnt
+        // cnt <- cnt+1
+        // printfn $"Finished processing node. {unblocked.Length} nodes unblocked"
+        unblocked
+
+    use cts = new CancellationTokenSource()
+
+    Parallel.processInParallel
+        leaves
+        work
+        parallelism
+        (fun processedCount -> processedCount = nodes.Count)
+        cts.Token
+        (fun x -> x.Info.Item.ToString())
+
+    let nodesArray = nodes.Values |> Seq.toArray
+
+    let finals, { State = state }: 'FinalFileResult[] * StateWrapper<'Item, 'State> =
+        nodesArray
+        |> Array.filter (fun node -> includeInFinalState node.Info.Item)
+        |> Array.sortBy (fun node -> node.Info.Item)
+        |> Array.fold
+            (fun (fileResults, state) node ->
+                let fileResult, state = folder state (node.Result.Value |> snd)
+                Array.append fileResults [| fileResult |], state)
+            ([||], emptyState)
+
+    finals, state
+
+type Node2<'Item, 'Result> =
+    {
+        Info: NodeInfo<'Item>
+        mutable ProcessedDepsCount: int
+        mutable Result: 'Result option
+    }
+
+// TODO Could be replaced with a simpler recursive approach with memoised per-item results
+let processGraphSimple<'Item, 'Result when 'Item: equality and 'Item: comparison>
+    (graph: Graph<'Item>)
+    // Accepts item and a list of item results. Handles combining results.
+    (doWork: 'Item -> ResultWrapper<'Item, 'Result>[] -> 'Result)
+    (parallelism: int)
+    : ResultWrapper<'Item, 'Result>[] =
+    let transitiveDeps = graph |> Graph.transitiveOpt
+    let dependants = graph |> Graph.reverse
+
+    let makeNode (item: 'Item) : Node2<'Item, ResultWrapper<'Item, 'Result>> =
+        let info =
+            let exists = graph.ContainsKey item
+            if
+                not exists
+                || not (transitiveDeps.ContainsKey item)
+                || not (dependants.ContainsKey item)
+            then
+                failwith $"WHAT {item}"
+
+            {
+                Item = item
+                Deps = graph[item]
+                TransitiveDeps = transitiveDeps[item]
+                Dependants = dependants[item]
+            }
+
+        {
+            Info = info
+            Result = None
+            ProcessedDepsCount = 0
+        }
+
+    let nodes = graph.Keys |> Seq.map (fun item -> item, makeNode item) |> readOnlyDict
+    let lookup item = nodes[item]
+    let lookupMany items = items |> Array.map lookup
+
+    let leaves =
+        nodes.Values
+        |> Seq.filter (fun n -> n.Info.Deps.Length = 0)
+        |> Seq.toArray
+
+    printfn $"Node count: {nodes.Count}"
+
+    let work
+        (node: Node2<'Item, ResultWrapper<'Item, 'Result>>)
+        : Node2<'Item, ResultWrapper<'Item, 'Result>>[] =
+        let _deps = lookupMany node.Info.Deps
+        let transitiveDeps = lookupMany node.Info.TransitiveDeps
+        let inputs =
+            transitiveDeps
+            |> Array.map (fun n -> n.Result |> Option.get)
+        let singleRes = doWork node.Info.Item inputs
+        let singleRes =
+            {
+                Item = node.Info.Item
+                Result = singleRes
+            }
+        node.Result <- Some singleRes
+        // Need to double-check that only one dependency schedules this dependant
+        let unblocked =
+            node.Info.Dependants
+            |> lookupMany
+            |> Array.filter (fun x ->
+                let pdc =
+                    // TODO Not ideal, better ways most likely exist
+                    lock x (fun () ->
+                        x.ProcessedDepsCount <- x.ProcessedDepsCount + 1
+                        x.ProcessedDepsCount)
+                pdc = x.Info.Deps.Length
+            )
+        unblocked
+
+    use cts = new CancellationTokenSource()
+
+    Parallel.processInParallel
+        leaves
+        work
+        parallelism
+        (fun processedCount -> processedCount = nodes.Count)
+        cts.Token
+        (fun x -> x.Info.Item.ToString())
+
+    let nodesArray = nodes.Values |> Seq.toArray
+
+    nodesArray
+    |> Array.map (fun n -> n.Result.Value)
+
+
+/// Used for processing
+type NodeInfo3<'Item> =
+    {
+        Item: 'Item
+        Deps: 'Item[]
+        Dependants: 'Item[]
+    }
+    
+type Node3<'Item> =
+    {
+        Info: NodeInfo3<'Item>
+        mutable ProcessedDepsCount: int
+    }
+
+/// Graph processing that doesn't handle results but just invokes the worker when dependencies are ready
+let processGraphSimpler<'Item when 'Item: equality and 'Item: comparison>
+    (graph: Graph<'Item>)
+    // Accepts item and a list of item results. Handles combining results.
+    (doWork: 'Item -> unit)
+    (parallelism: int)
+    : unit
+    =
+    let dependants = graph |> Graph.reverse
+
+    let makeNode (item: 'Item) : Node3<'Item> =
+        let info =
+            let exists = graph.ContainsKey item
+            if
+                not exists
+                || not (dependants.ContainsKey item)
+            then
+                failwith $"WHAT {item}"
+            {
+                Item = item
+                Deps = graph[item]
+                Dependants = dependants[item]
+            }
+
+        {
+            Info = info
+            ProcessedDepsCount = 0
+        }
+
+    let nodes = graph.Keys |> Seq.map (fun item -> item, makeNode item) |> readOnlyDict
+    let lookup item = nodes[item]
+    let lookupMany items = items |> Array.map lookup
+
+    let leaves =
+        nodes.Values
+        |> Seq.filter (fun n -> n.Info.Deps.Length = 0)
+        |> Seq.toArray
+
+    // printfn $"Node count: {nodes.Count}"
+
+    let work
+        (node: Node3<'Item>)
+        : Node3<'Item>[]
+        =
+        let _deps = lookupMany node.Info.Deps
+        // printfn $"{node.Info.Item} DoWork"
+        doWork node.Info.Item
+        // printfn $"{node.Info.Item} DoneWork"
+        // Need to double-check that only one dependency schedules this dependant
+        let unblocked =
+            node.Info.Dependants
+            |> lookupMany
+            |> Array.filter (fun x ->
+                let pdc =
+                    // TODO Not ideal, better ways most likely exist
+                    lock x (fun () ->
+                        x.ProcessedDepsCount <- x.ProcessedDepsCount + 1
+                        x.ProcessedDepsCount)
+                pdc = x.Info.Deps.Length
+            )
+        // printfn $"{node.Info.Item} unblocked gathered"
+        unblocked
+
+    use cts = new CancellationTokenSource()
+
+    Parallel.processInParallel
+        leaves
+        work
+        parallelism
+        (fun processedCount -> processedCount = nodes.Count)
+        cts.Token
+        (fun x -> x.Info.Item.ToString())
diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index 0696758780b..1af2d384cfb 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -2,7 +2,12 @@
 
 module internal FSharp.Compiler.OptimizeInputs
 
+open System.Collections.Generic
+open System.Diagnostics
 open System.IO
+open System.Threading
+open FSharp.Compiler.Service.Driver
+open FSharp.Compiler.Service.Driver.OptimizeTypes
 open Internal.Utilities.Library
 open FSharp.Compiler
 open FSharp.Compiler.AbstractIL.IL
@@ -48,6 +53,225 @@ let GetInitialOptimizationEnv (tcImports: TcImports, tcGlobals: TcGlobals) =
     let optEnv = List.fold (AddExternalCcuToOptimizationEnv tcGlobals) optEnv ccuinfos
     optEnv
 
+let collectResults (inputs: CollectorInputs) : CollectorOutputs =
+    let files =
+        inputs
+        |> Array.map (fun {Phase1 = phase1; Phase2 = _phase2; Phase3 = phase3} ->
+            let (_, _, implFileOptData, _), optimizeDuringCodeGen = phase1
+            let _, implFile = phase3
+            let implFile =
+                {
+                    ImplFile = implFile
+                    OptimizeDuringCodeGen = optimizeDuringCodeGen
+                }
+            implFile, implFileOptData
+        )
+        
+    let lastFilePhase1Env =
+        inputs
+        |> Array.last
+        |> fun {Phase1 = phase1} ->
+            let (optEnvPhase1, _, _, _), _ = phase1
+            optEnvPhase1
+            
+    files, lastFilePhase1Env
+
+type Phase =
+    | Phase1
+    | Phase2
+    | Phase3
+
+type FilePhaseFuncs = Phase1Fun * Phase2Fun * Phase3Fun   
+type FileResults =
+    {
+        mutable Phase1: Phase1Res option
+        mutable Phase2: Phase2Res option
+        mutable Phase3: Phase3Res option
+    }
+    with
+        member this.HasResult (phase: Phase) =
+            match phase with
+            | Phase.Phase1 -> this.Phase1 |> Option.isSome
+            | Phase.Phase2 -> this.Phase2 |> Option.isSome
+            | Phase.Phase3 -> this.Phase3 |> Option.isSome
+        static member Empty =
+            {
+                Phase1 = None
+                Phase2 = None
+                Phase3 = None
+            }
+
+type WorkItem =
+    | Phase1 of Phase1Inputs
+    | Phase2 of Phase2Inputs
+    | Phase3 of Phase3Inputs
+
+type Idx = int
+type Node =
+    {
+        Idx: Idx
+        Phase: Phase
+    }
+    with override this.ToString() = $"[{this.Idx}-{this.Phase}]"
+
+
+let getPhase1Res (p: FileResults) =
+    p.Phase1
+    |> Option.get
+    |> fun ((env, _, _, hidden), _) -> env, hidden
+
+let getPhase2Res (p: FileResults) =
+    p.Phase2
+    |> Option.get
+
+let getPhase3Res (p: FileResults) =
+    p.Phase3
+    |> Option.get
+    |> fun (env, _) -> env
+
+let go (env0: Optimizer.IncrementalOptimizationEnv) ((phase1, phase2, phase3): FilePhaseFuncs) (files: CheckedImplFile list) : CollectorOutputs =
+    let files = files |> List.toArray
+    // Schedule File1-Phase1
+    let firstNode = { Idx = 0; Phase = Phase.Phase1 }
+    
+    let results =
+        files
+        |> Array.map (fun _ -> FileResults.Empty)
+    
+    let _lock = obj()
+    let nodeCanBeProcessed {Idx = idx; Phase = phase} : bool =
+        lock (_lock) (fun () ->
+            let previousFileReady =
+                if idx = 0 then true else results[idx-1].HasResult phase
+            let previousPhase =
+                match phase with
+                | Phase.Phase1 -> None
+                | Phase.Phase2 -> Some Phase.Phase1
+                | Phase.Phase3 -> Some Phase.Phase2
+            let previousPhaseReady =
+                match previousPhase with
+                | Some previousPhase -> results[idx].HasResult previousPhase
+                | None -> true
+            previousFileReady && previousPhaseReady
+        )        
+    
+    let visited = HashSet<Node>()
+    
+    let worker ({Idx = idx; Phase = phase} as node : Node) : Node[] =
+        let notPreviouslyVisited =
+            lock (_lock) (fun () ->
+                visited.Add node
+            )
+        if notPreviouslyVisited = false then [||]
+        else
+        let res = results[idx]
+        let file = files[idx]
+        let previous = if idx > 0 then Some results[idx-1] else None
+        let hidingInfo0 = SignatureHidingInfo.Empty        
+        
+        let getPhase1Res (p: FileResults) =
+            p.Phase1
+            |> Option.get
+            |> fun ((env, file, info, hidden), _) -> env, file, info, hidden
+                
+        match phase with
+        | Phase.Phase1 ->
+            // take env from previous file
+            let env, hidingInfo =
+                previous
+                |> Option.map getPhase1Res
+                |> Option.map (fun (a, _b, _c, d) -> a, d)
+                |> Option.defaultValue (env0, hidingInfo0)
+            let inputs = env, hidingInfo, file
+            let phase1Res = phase1 inputs
+            res.Phase1 <- Some phase1Res
+            
+            // Schedule Phase2
+            let phase2Node = { Idx = idx; Phase = Phase.Phase2 }
+            seq {
+                yield phase2Node
+                if idx < files.Length-1 then yield { Idx = idx + 1; Phase = Phase.Phase1 }
+            }
+            |> Seq.toArray
+            
+        | Phase.Phase2 ->
+            // take env from previous file
+            let env =
+                previous
+                |> Option.map getPhase2Res
+                |> Option.map fst
+                |> Option.defaultValue env0
+            let file, info, hidingInfo =
+                res
+                |> getPhase1Res
+                |> fun (_a, b, c, d) -> b, c, d
+            let inputs = env, hidingInfo, info, file
+            let phase2Res = phase2 inputs
+            res.Phase2 <- Some phase2Res
+            
+            seq {
+                // Schedule Phase3
+                let phase3Node = { Idx = idx; Phase = Phase.Phase3 }
+                yield phase3Node
+                // Schedule Phase2 for the next file if it exists
+                if idx < files.Length-1 then yield { Idx = idx + 1; Phase = Phase.Phase2 }
+            }
+            |> Seq.toArray
+            
+        | Phase.Phase3 ->
+            // take env from previous file
+            let env =
+                previous
+                |> Option.map getPhase3Res
+                |> Option.defaultValue env0
+            // impl file
+            let _, file =
+                res
+                |> getPhase2Res
+            let hidingInfo =
+                res
+                |> getPhase1Res
+                |> fun (_a,_b,_c,d) -> d
+            let inputs = env, hidingInfo, file
+            let phase3Res = phase3 inputs
+            res.Phase3 <- Some phase3Res
+            
+            seq {
+                // Schedule Phase3 for the next file if it exists
+                if idx < files.Length-1 then yield { Idx = idx + 1; Phase = Phase.Phase3 }
+            }
+            |> Seq.toArray
+        |> fun nodes ->
+            nodes
+            |> Array.filter nodeCanBeProcessed
+    
+    Parallel.processInParallel
+        [|firstNode|]
+        worker
+        10
+        (fun _ -> visited.Count >= files.Length * 3)
+        (CancellationToken.None)
+        (fun node -> node.ToString())
+        
+    Debug.Assert(visited.Count = files.Length * 3)
+    
+    let results =
+        results
+        |> Array.mapi (fun i {Phase1 = phase1; Phase2 = phase2; Phase3 = phase3} ->
+            match phase1, phase2, phase3 with
+            | Some phase1, Some phase2, Some phase3 -> {FileResultsComplete.Phase1 = phase1; Phase2 = phase2; Phase3 = phase3}
+            | _ -> failwith $"Unexpected lack of results for file [{i}]"
+        )
+    let collected = results |> collectResults
+    collected
+
+[<RequireQualifiedAccess>]
+type OptimizerMode =
+    | Sequential
+    | PartiallyParallel
+
+let mutable optimizerMode: OptimizerMode = OptimizerMode.Sequential
+
 let ApplyAllOptimizations
     (
         tcConfig: TcConfig,
@@ -90,20 +314,52 @@ let ApplyAllOptimizations
             reportingPhase = true
         }
 
-    let results, (optEnvFirstLoop, _, _, _) =
-        ((optEnv0, optEnv0, optEnv0, SignatureHidingInfo.Empty), implFiles)
+    
+    let env0 = optEnv0
+    
+    let phase1 (env: Optimizer.IncrementalOptimizationEnv, hidden: SignatureHidingInfo, implFile: CheckedImplFile) : Phase1Res =
+        //ReportTime tcConfig ("Initial simplify")
+        Optimizer.OptimizeImplFile(
+            optSettings,
+            ccu,
+            tcGlobals,
+            tcVal,
+            importMap,
+            env,
+            isIncrementalFragment,
+            tcConfig.fsiMultiAssemblyEmit,
+            tcConfig.emitTailcalls,
+            hidden,
+            implFile
+        )
+    
+    let phase2 (env: Optimizer.IncrementalOptimizationEnv, hidden: SignatureHidingInfo, implFileOptData: Optimizer.ImplFileOptimizationInfo, implFile: CheckedImplFile) : Phase2Res =
+        let implFile = LowerLocalMutables.TransformImplFile tcGlobals importMap implFile
+
+        // Only do this on the first pass!
+        let optSettings =
+            { optSettings with
+                abstractBigTargets = false
+                reportingPhase = false
+            }
+#if DEBUG
+        if tcConfig.showOptimizationData then
+            dprintf
+                "Optimization implFileOptData:\n%s\n"
+                (LayoutRender.showL (Display.squashTo 192 (Optimizer.moduleInfoL tcGlobals implFileOptData)))
+#endif
 
-        ||> List.mapFold (fun (optEnvFirstLoop, optEnvExtraLoop, optEnvFinalSimplify, hidden) implFile ->
+        if tcConfig.extraOptimizationIterations > 0 then
 
-            //ReportTime tcConfig ("Initial simplify")
-            let (optEnvFirstLoop, implFile, implFileOptData, hidden), optimizeDuringCodeGen =
+            //ReportTime tcConfig ("Extra simplification loop")
+            let (optEnvExtraLoop, implFile, _, _), _ =
                 Optimizer.OptimizeImplFile(
                     optSettings,
                     ccu,
                     tcGlobals,
                     tcVal,
                     importMap,
-                    optEnvFirstLoop,
+                    env,
                     isIncrementalFragment,
                     tcConfig.fsiMultiAssemblyEmit,
                     tcConfig.emitTailcalls,
@@ -111,94 +367,89 @@ let ApplyAllOptimizations
                     implFile
                 )
 
-            let implFile = LowerLocalMutables.TransformImplFile tcGlobals importMap implFile
-
-            // Only do this on the first pass!
-            let optSettings =
-                { optSettings with
-                    abstractBigTargets = false
-                    reportingPhase = false
-                }
-#if DEBUG
-            if tcConfig.showOptimizationData then
-                dprintf
-                    "Optimization implFileOptData:\n%s\n"
-                    (LayoutRender.showL (Display.squashTo 192 (Optimizer.moduleInfoL tcGlobals implFileOptData)))
-#endif
-
-            let implFile, optEnvExtraLoop =
-                if tcConfig.extraOptimizationIterations > 0 then
-
-                    //ReportTime tcConfig ("Extra simplification loop")
-                    let (optEnvExtraLoop, implFile, _, _), _ =
-                        Optimizer.OptimizeImplFile(
-                            optSettings,
-                            ccu,
-                            tcGlobals,
-                            tcVal,
-                            importMap,
-                            optEnvExtraLoop,
-                            isIncrementalFragment,
-                            tcConfig.fsiMultiAssemblyEmit,
-                            tcConfig.emitTailcalls,
-                            hidden,
-                            implFile
-                        )
-
-                    //PrintWholeAssemblyImplementation tcConfig outfile (sprintf "extra-loop-%d" n) implFile
-                    implFile, optEnvExtraLoop
-                else
-                    implFile, optEnvExtraLoop
-
-            let implFile =
-                if tcConfig.doDetuple then
-                    //ReportTime tcConfig ("Detupled optimization")
-                    let implFile = implFile |> Detuple.DetupleImplFile ccu tcGlobals
-                    //PrintWholeAssemblyImplementation tcConfig outfile "post-detuple" implFile
-                    implFile
-                else
-                    implFile
-
-            let implFile =
-                if tcConfig.doTLR then
-                    implFile
-                    |> InnerLambdasToTopLevelFuncs.MakeTopLevelRepresentationDecisions ccu tcGlobals
-                else
+            //PrintWholeAssemblyImplementation tcConfig outfile (sprintf "extra-loop-%d" n) implFile
+            optEnvExtraLoop, implFile
+        else
+            env, implFile
+        
+    let phase3 (env: Optimizer.IncrementalOptimizationEnv, hidden: SignatureHidingInfo, implFile: CheckedImplFile) : Phase3Res =
+        // Only do this on the first pass!
+        let optSettings =
+            { optSettings with
+                abstractBigTargets = false
+                reportingPhase = false
+            }
+
+        let implFile =
+            if tcConfig.doDetuple then
+                //ReportTime tcConfig ("Detupled optimization")
+                let implFile = implFile |> Detuple.DetupleImplFile ccu tcGlobals
+                //PrintWholeAssemblyImplementation tcConfig outfile "post-detuple" implFile
+                implFile
+            else
+                implFile
+
+        let implFile =
+            if tcConfig.doTLR then
+                implFile
+                |> InnerLambdasToTopLevelFuncs.MakeTopLevelRepresentationDecisions ccu tcGlobals
+            else
+                implFile
+
+        let implFile = LowerCalls.LowerImplFile tcGlobals implFile
+
+        if tcConfig.doFinalSimplify then
+
+            //ReportTime tcConfig ("Final simplify pass")
+            let (optEnvFinalSimplify, implFile, _, _), _ =
+                Optimizer.OptimizeImplFile(
+                    optSettings,
+                    ccu,
+                    tcGlobals,
+                    tcVal,
+                    importMap,
+                    env,
+                    isIncrementalFragment,
+                    tcConfig.fsiMultiAssemblyEmit,
+                    tcConfig.emitTailcalls,
+                    hidden,
                     implFile
+                )
 
-            let implFile = LowerCalls.LowerImplFile tcGlobals implFile
-
-            let implFile, optEnvFinalSimplify =
-                if tcConfig.doFinalSimplify then
-
-                    //ReportTime tcConfig ("Final simplify pass")
-                    let (optEnvFinalSimplify, implFile, _, _), _ =
-                        Optimizer.OptimizeImplFile(
-                            optSettings,
-                            ccu,
-                            tcGlobals,
-                            tcVal,
-                            importMap,
-                            optEnvFinalSimplify,
-                            isIncrementalFragment,
-                            tcConfig.fsiMultiAssemblyEmit,
-                            tcConfig.emitTailcalls,
-                            hidden,
-                            implFile
-                        )
-
-                    //PrintWholeAssemblyImplementation tcConfig outfile "post-rec-opt" implFile
-                    implFile, optEnvFinalSimplify
-                else
-                    implFile, optEnvFinalSimplify
-
-            let implFile =
-                {
-                    ImplFile = implFile
-                    OptimizeDuringCodeGen = optimizeDuringCodeGen
-                }
-
-            (implFile, implFileOptData), (optEnvFirstLoop, optEnvExtraLoop, optEnvFinalSimplify, hidden))
+            //PrintWholeAssemblyImplementation tcConfig outfile "post-rec-opt" implFile
+            optEnvFinalSimplify, implFile
+        else
+            env, implFile
+    
+    let results, optEnvFirstLoop =
+        match optimizerMode with
+        | OptimizerMode.PartiallyParallel ->
+            let a, b =
+                go env0 (phase1, phase2, phase3) implFiles
+            a |> Array.toList, b
+        | OptimizerMode.Sequential ->
+            let results, (optEnvFirstLoop, _, _, _) =
+                ((optEnv0, optEnv0, optEnv0, SignatureHidingInfo.Empty), implFiles)
+
+                ||> List.mapFold (fun (optEnvFirstLoop, optEnvExtraLoop, optEnvFinalSimplify, hidden) implFile ->
+                    // Phase 1
+                    //ReportTime tcConfig ("Initial simplify")
+                    let (optEnvFirstLoop, implFile, implFileOptData, hidden), optimizeDuringCodeGen = phase1 (optEnvFirstLoop, hidden, implFile)
+
+                    // Phase 2
+                    let optEnvExtraLoop, implFile = phase2 (optEnvExtraLoop, hidden, implFileOptData, implFile)
+
+                    // Phase 3
+                    let optEnvFinalSimplify, implFile = phase3 (optEnvFinalSimplify, hidden, implFile)
+                    
+                    let implFile =
+                        {
+                            ImplFile = implFile
+                            OptimizeDuringCodeGen = optimizeDuringCodeGen
+                        }
+
+                    (implFile, implFileOptData), (optEnvFirstLoop, optEnvExtraLoop, optEnvFinalSimplify, hidden))
+            results, optEnvFirstLoop
 
     let implFiles, implFileOptDatas = List.unzip results
     let assemblyOptData = Optimizer.UnionOptimizationInfos implFileOptDatas
diff --git a/src/Compiler/Driver/OptimizeInputs.fsi b/src/Compiler/Driver/OptimizeInputs.fsi
index d5c731ba05d..3ac6f9fe408 100644
--- a/src/Compiler/Driver/OptimizeInputs.fsi
+++ b/src/Compiler/Driver/OptimizeInputs.fsi
@@ -12,6 +12,8 @@ open FSharp.Compiler.Import
 open FSharp.Compiler.Optimizer
 open FSharp.Compiler.TcGlobals
 open FSharp.Compiler.TypedTree
+open System.Collections.Generic
+open FSharp.Compiler.Service.Driver.OptimizeTypes
 
 val GetGeneratedILModuleName: CompilerTarget -> string -> string
 
@@ -49,3 +51,9 @@ val GenerateIlxCode:
 val NormalizeAssemblyRefs: CompilationThreadToken * ILGlobals * TcImports -> (ILScopeRef -> ILScopeRef)
 
 val GetGeneratedILModuleName: CompilerTarget -> string -> string
+
+type OptimizerMode =
+    | Sequential
+    | PartiallyParallel
+
+val mutable optimizerMode: OptimizerMode
\ No newline at end of file
diff --git a/src/Compiler/Driver/OptimizeTypes.fs b/src/Compiler/Driver/OptimizeTypes.fs
new file mode 100644
index 00000000000..40f33752dcd
--- /dev/null
+++ b/src/Compiler/Driver/OptimizeTypes.fs
@@ -0,0 +1,86 @@
+module internal FSharp.Compiler.Service.Driver.OptimizeTypes
+
+open FSharp.Compiler
+open FSharp.Compiler.Optimizer
+open FSharp.Compiler.TcGlobals
+open FSharp.Compiler.TypedTree
+open FSharp.Compiler.TypedTreeOps
+
+type OptimizeDuringCodeGen = bool -> Expr -> Expr
+type OptimizeRes =
+    (IncrementalOptimizationEnv * CheckedImplFile * ImplFileOptimizationInfo * SignatureHidingInfo) * OptimizeDuringCodeGen
+
+type Optimize =
+    OptimizationSettings *
+    CcuThunk *
+    TcGlobals *
+    ConstraintSolver.TcValF *
+    Import.ImportMap *
+    IncrementalOptimizationEnv *
+    bool *
+    bool *
+    bool *
+    SignatureHidingInfo *
+    CheckedImplFile ->
+        OptimizeRes
+
+type PhaseInputs = IncrementalOptimizationEnv * SignatureHidingInfo * CheckedImplFile
+
+type Phase1Inputs = PhaseInputs
+type Phase1Res = OptimizeRes
+type Phase1Fun = Phase1Inputs -> Phase1Res
+
+type Phase2Inputs = IncrementalOptimizationEnv * SignatureHidingInfo * ImplFileOptimizationInfo * CheckedImplFile
+type Phase2Res = IncrementalOptimizationEnv * CheckedImplFile
+type Phase2Fun = Phase2Inputs -> Phase2Res
+
+type Phase3Inputs = PhaseInputs
+type Phase3Res = IncrementalOptimizationEnv * CheckedImplFile
+type Phase3Fun = Phase3Inputs -> Phase3Res
+
+type Phase =
+    | Phase1
+    | Phase2
+    | Phase3
+module Phase =
+    let all = [|Phase1; Phase2; Phase3|]
+    let prev (phase: Phase) =
+        match phase with
+        | Phase1 -> None
+        | Phase2 -> Some Phase1
+        | Phase3 -> Some Phase2
+    let next (phase: Phase) =
+        match phase with
+        | Phase1 -> Some Phase2
+        | Phase2 -> Some Phase3
+        | Phase3 -> None
+
+type PhaseRes =
+    | Phase1 of Phase1Res
+    | Phase2 of Phase2Res
+    | Phase3 of Phase3Res
+    with
+        member x.Which =
+            match x with
+            | Phase1 _ -> Phase.Phase1
+            | Phase2 _ -> Phase.Phase2
+            | Phase3 _ -> Phase.Phase3
+        member x.Get1() =
+            match x with
+            | Phase1 x -> x
+            | Phase2 _
+            | Phase3 _ -> failwith $"Called {nameof(x.Get1)} but this is {x.Which}"
+        member x.Get2() =
+            match x with
+            | Phase2 x -> x
+            | Phase1 _
+            | Phase3 _ -> failwith $"Called {nameof(x.Get2)} but this is {x.Which}"
+
+type FileResultsComplete =
+    {
+        Phase1: Phase1Res
+        Phase2: Phase2Res
+        Phase3: Phase3Res
+    }
+type CollectorInputs = FileResultsComplete[]
+type CollectorOutputs = (CheckedImplFileAfterOptimization * ImplFileOptimizationInfo)[] * IncrementalOptimizationEnv
diff --git a/src/Compiler/Driver/Parallel.fs b/src/Compiler/Driver/Parallel.fs
new file mode 100644
index 00000000000..3e566dd97a8
--- /dev/null
+++ b/src/Compiler/Driver/Parallel.fs
@@ -0,0 +1,54 @@
+module FSharp.Compiler.Service.Driver.Parallel
+
+#nowarn "1182"
+
+open System
+open System.Collections.Concurrent
+open System.Threading
+
+// TODO Could replace with MailboxProcessor+Tasks/Asyncs instead of BlockingCollection + Threads
+// See http://www.fssnip.net/nX/title/Limit-degree-of-parallelism-using-an-agent
+/// Process items in parallel, allow more work to be scheduled as a result of finished work,
+/// limit parallelisation to 'parallelism' threads
+let processInParallel
+    (firstItems: 'Item[])
+    (work: 'Item -> 'Item[])
+    (parallelism: int)
+    (shouldStop: int -> bool)
+    (ct: CancellationToken)
+    (_itemToString: 'Item -> string)
+    : unit =
+    let bc = new BlockingCollection<'Item>()
+    firstItems |> Array.iter bc.Add
+    let processedCountLock = Object()
+    let mutable processedCount = 0
+
+    let processItem item =
+        printfn $"[{Thread.CurrentThread.ManagedThreadId}] Processing {_itemToString item}"
+        let toSchedule = work item
+        printfn $"[{Thread.CurrentThread.ManagedThreadId}] Finished {_itemToString item}"
+
+        let processedCount =
+            lock processedCountLock (fun () ->
+                processedCount <- processedCount + 1
+                processedCount)
+
+        let toScheduleString =
+            toSchedule |> Array.map _itemToString |> (fun names -> String.Join(", ", names))
+
+        printfn $"[{Thread.CurrentThread.ManagedThreadId}] Scheduling {toSchedule.Length} items: {toScheduleString}"
+        toSchedule |> Array.iter bc.Add
+        processedCount
+
+    // TODO Could avoid workers with some semaphores
+    let workerWork () : unit =
+        for node in bc.GetConsumingEnumerable(ct) do
+            if not ct.IsCancellationRequested then // improve
+                let processedCount = processItem node
+
+                if shouldStop processedCount then
+                    bc.CompleteAdding()
+
+    // TODO Do we need to handle cancellation given that workers do it already?
+    Array.Parallel.map workerWork (Array.init parallelism (fun _ -> ())) |> ignore
+
diff --git a/src/Compiler/FSharp.Compiler.Service.fsproj b/src/Compiler/FSharp.Compiler.Service.fsproj
index 950f72b24b9..8be13652447 100644
--- a/src/Compiler/FSharp.Compiler.Service.fsproj
+++ b/src/Compiler/FSharp.Compiler.Service.fsproj
@@ -386,6 +386,10 @@
     <Compile Include="Driver\ScriptClosure.fs" />
     <Compile Include="Driver\CompilerOptions.fsi" />
     <Compile Include="Driver\CompilerOptions.fs" />
+    <Compile Include="Driver\Parallel.fs" />
+    <Compile Include="Driver\Graph.fs" />
+    <Compile Include="Driver\GraphProcessing.fs" />
+    <Compile Include="Driver\OptimizeTypes.fs" />
     <Compile Include="Driver\OptimizeInputs.fsi" />
     <Compile Include="Driver\OptimizeInputs.fs" />
     <Compile Include="Driver\XmlDocFileWriter.fsi" />

From 947e4b5fcbcdb865173e7aa676ad70a827a28483 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Thu, 24 Nov 2022 21:08:45 +0000
Subject: [PATCH 05/42] Make it compile, wire up a test option

---
 src/Compiler/Driver/CompilerOptions.fs |  6 ++++++
 src/Compiler/Driver/Graph.fs           | 28 ++++++++++++++------------
 src/Compiler/Driver/GraphProcessing.fs |  7 -------
 src/Compiler/Driver/OptimizeInputs.fs  | 14 ++++---------
 src/Compiler/Driver/OptimizeInputs.fsi |  6 ------
 src/Compiler/Optimize/Optimizer.fs     | 13 +++++++++++-
 src/Compiler/Optimize/Optimizer.fsi    |  7 +++++++
 7 files changed, 44 insertions(+), 37 deletions(-)

diff --git a/src/Compiler/Driver/CompilerOptions.fs b/src/Compiler/Driver/CompilerOptions.fs
index 02c3306b2d9..885e74fa2e5 100644
--- a/src/Compiler/Driver/CompilerOptions.fs
+++ b/src/Compiler/Driver/CompilerOptions.fs
@@ -7,6 +7,7 @@ module internal FSharp.Compiler.CompilerOptions
 open System
 open System.Diagnostics
 open System.IO
+open FSharp.Compiler.Optimizer
 open Internal.Utilities.Library
 open Internal.Utilities.Library.Extras
 open FSharp.Compiler.AbstractIL.IL
@@ -1388,6 +1389,11 @@ let testFlag tcConfigB =
             | "ContinueAfterParseFailure" -> tcConfigB.continueAfterParseFailure <- true
             | "ParallelOff" -> tcConfigB.concurrentBuild <- false
             | "ParallelCheckingWithSignatureFilesOn" -> tcConfigB.parallelCheckingWithSignatureFiles <- true
+            | "PartiallyParallelOptimization" ->
+                tcConfigB.optSettings <-
+                    { tcConfigB.optSettings with
+                        processingMode = OptimizerMode.PartiallyParallel
+                    }
 #if DEBUG
             | "ShowParserStackOnParseError" -> showParserStackOnParseError <- true
 #endif
diff --git a/src/Compiler/Driver/Graph.fs b/src/Compiler/Driver/Graph.fs
index 622d1ec2d2f..18beb186f5b 100644
--- a/src/Compiler/Driver/Graph.fs
+++ b/src/Compiler/Driver/Graph.fs
@@ -4,9 +4,6 @@
 #nowarn "40"
 
 open System.Collections.Generic
-open System.IO
-open Newtonsoft.Json
-open ParallelTypeCheckingTests.Utils
 
 /// <summary> DAG of files </summary>
 type Graph<'Node> = IReadOnlyDictionary<'Node, 'Node[]>
@@ -33,8 +30,9 @@ module Graph =
         |> fun missing ->
             let toAdd = missing |> Seq.map (fun n -> KeyValuePair(n, [||])) |> Seq.toArray
 
-            let x = Array.append (graph |> Seq.toArray) toAdd
-            x |> Dictionary<_, _> |> (fun x -> x :> IReadOnlyDictionary<_, _>)
+            Array.append (graph |> Seq.toArray) toAdd
+            |> Array.map (fun (KeyValue(k, v)) -> k, v)
+            |> readOnlyDict
 
     /// Create entries for nodes that don't have any dependencies but are mentioned as dependencies themselves
     let fillEmptyNodes<'Node when 'Node: equality> (graph: Graph<'Node>) : Graph<'Node> =
@@ -59,20 +57,29 @@ module Graph =
         |> Array.Parallel.map (fun node -> node, go node)
         |> readOnlyDict
 
-    /// Create a transitive closure of the graph
+    let private memoize<'a,'b when 'a : equality> (f : 'a -> 'b) : 'a -> 'b =
+        let cache = Dictionary<'a,'b>()
+        fun a ->
+            match cache.TryGetValue a with
+            | true, b -> b
+            | false, _ ->
+                let b = f a
+                cache[a] <- b
+                b
+    
+    /// Create a transitive closure of the graph.
     let transitive<'Node when 'Node: equality> (graph: Graph<'Node>) : Graph<'Node> =
         let rec calcTransitiveEdges =
             fun (node: 'Node) ->
                 let edgeTargets =
                     match graph.TryGetValue node with
                     | true, x -> x
-                    | false, _ -> failwith "FOO"
+                    | false, _ -> [||]
 
                 edgeTargets
                 |> Array.collect calcTransitiveEdges
                 |> Array.append edgeTargets
                 |> Array.distinct
-            // Dispose of memoisation context
             |> memoize
 
         graph.Keys
@@ -100,8 +107,3 @@ module Graph =
 
     let print (graph: Graph<'Node>) : unit =
         printCustom graph (fun node -> node.ToString())
-
-    let serialiseToJson (path: string) (graph: Graph<'Node>) : unit =
-        let json = JsonConvert.SerializeObject(graph, Formatting.Indented)
-        printfn $"Serialising graph as JSON in {path}"
-        File.WriteAllText(path, json)
diff --git a/src/Compiler/Driver/GraphProcessing.fs b/src/Compiler/Driver/GraphProcessing.fs
index d3489fe78ee..84228cf40f5 100644
--- a/src/Compiler/Driver/GraphProcessing.fs
+++ b/src/Compiler/Driver/GraphProcessing.fs
@@ -1,7 +1,6 @@
 /// Parallel processing of graph of work items with dependencies
 module FSharp.Compiler.Service.Driver.GraphProcessing
 
-open System.Collections.Concurrent
 open System.Collections.Generic
 open System.Threading
 open FSharp.Compiler.Service.Driver.Graph
@@ -44,9 +43,6 @@ type Node<'Item, 'State, 'Result> =
 /// <summary>
 /// Combine results of dependencies needed to type-check a 'higher' node in the graph
 /// </summary>
-/// <param name="deps">Direct dependencies of a node</param>
-/// <param name="transitiveDeps">Transitive dependencies of a node</param>
-/// <param name="folder">A way to fold a single result into existing state</param>
 let combineResultsOld
     (emptyState: 'State)
     (deps: Node<'Item, 'State, 'Result>[])
@@ -98,9 +94,6 @@ let combineResultsOld
 /// <summary>
 /// Combine results of dependencies needed to type-check a 'higher' node in the graph
 /// </summary>
-/// <param name="deps">Direct dependencies of a node</param>
-/// <param name="transitiveDeps">Transitive dependencies of a node</param>
-/// <param name="folder">A way to fold a single result into existing state</param>
 let combineResults
     (emptyState: 'State)
     (deps: Node<'Item, 'State, 'Result>[])
diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index 1af2d384cfb..382fa07b10e 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -6,6 +6,7 @@ open System.Collections.Generic
 open System.Diagnostics
 open System.IO
 open System.Threading
+open FSharp.Compiler.Optimizer
 open FSharp.Compiler.Service.Driver
 open FSharp.Compiler.Service.Driver.OptimizeTypes
 open Internal.Utilities.Library
@@ -129,7 +130,7 @@ let getPhase3Res (p: FileResults) =
     |> Option.get
     |> fun (env, _) -> env
 
-let go (env0: Optimizer.IncrementalOptimizationEnv) ((phase1, phase2, phase3): FilePhaseFuncs) (files: CheckedImplFile list) : CollectorOutputs =
+let optimizeFilesInParallel (env0: Optimizer.IncrementalOptimizationEnv) ((phase1, phase2, phase3): FilePhaseFuncs) (files: CheckedImplFile list) : CollectorOutputs =
     let files = files |> List.toArray
     // Schedule File1-Phase1
     let firstNode = { Idx = 0; Phase = Phase.Phase1 }
@@ -265,13 +266,6 @@ let go (env0: Optimizer.IncrementalOptimizationEnv) ((phase1, phase2, phase3): F
     let collected = results |> collectResults
     collected
 
-[<RequireQualifiedAccess>]
-type OptimizerMode =
-    | Sequential
-    | PartiallyParallel
-
-let mutable optimizerMode: OptimizerMode = OptimizerMode.Sequential
-
 let ApplyAllOptimizations
     (
         tcConfig: TcConfig,
@@ -422,10 +416,10 @@ let ApplyAllOptimizations
             env, implFile
     
     let results, optEnvFirstLoop =
-        match optimizerMode with
+        match optSettings.processingMode with
         | OptimizerMode.PartiallyParallel ->
             let a, b =
-                go env0 (phase1, phase2, phase3) implFiles
+                optimizeFilesInParallel env0 (phase1, phase2, phase3) implFiles
             a |> Array.toList, b
         | OptimizerMode.Sequential ->
             let results, (optEnvFirstLoop, _, _, _) =
diff --git a/src/Compiler/Driver/OptimizeInputs.fsi b/src/Compiler/Driver/OptimizeInputs.fsi
index 3ac6f9fe408..6876e1ce68e 100644
--- a/src/Compiler/Driver/OptimizeInputs.fsi
+++ b/src/Compiler/Driver/OptimizeInputs.fsi
@@ -51,9 +51,3 @@ val GenerateIlxCode:
 val NormalizeAssemblyRefs: CompilationThreadToken * ILGlobals * TcImports -> (ILScopeRef -> ILScopeRef)
 
 val GetGeneratedILModuleName: CompilerTarget -> string -> string
-
-type OptimizerMode =
-    | Sequential
-    | PartiallyParallel
-
-val mutable optimizerMode: OptimizerMode
\ No newline at end of file
diff --git a/src/Compiler/Optimize/Optimizer.fs b/src/Compiler/Optimize/Optimizer.fs
index 54665570cc5..e0adb4befec 100644
--- a/src/Compiler/Optimize/Optimizer.fs
+++ b/src/Compiler/Optimize/Optimizer.fs
@@ -300,6 +300,11 @@ let [<Literal>] crossAssemblyOptimizationDefault = true
 
 let [<Literal>] debugPointsForPipeRightDefault = true
 
+[<RequireQualifiedAccess>]
+type OptimizerMode =
+    | Sequential
+    | PartiallyParallel
+
 type OptimizationSettings = 
     { 
       abstractBigTargets : bool
@@ -331,6 +336,8 @@ type OptimizationSettings =
       reportHasEffect : bool 
       
       reportTotalSizes : bool
+      
+      processingMode : OptimizerMode
     }
 
     static member Defaults = 
@@ -347,6 +354,7 @@ type OptimizationSettings =
           reportFunctionSizes = false
           reportHasEffect = false
           reportTotalSizes = false
+          processingMode = OptimizerMode.Sequential
         }
 
     /// Determines if JIT optimizations are enabled
@@ -407,7 +415,10 @@ type OptimizationSettings =
 
     /// Determines if we should expand "let x = (exp1, exp2, ...)" bindings as prior tmps 
     /// Also if we should expand "let x = Some exp1" bindings as prior tmps 
-    member x.ExpandStructuralValues() = x.LocalOptimizationsEnabled 
+    member x.ExpandStructuralValues() = x.LocalOptimizationsEnabled
+    
+    /// Determines how to process optimization of multiple files
+    member x.ProcessingMode() = x.processingMode
 
 type cenv =
     { g: TcGlobals
diff --git a/src/Compiler/Optimize/Optimizer.fsi b/src/Compiler/Optimize/Optimizer.fsi
index 76b7881f487..20368b34814 100644
--- a/src/Compiler/Optimize/Optimizer.fsi
+++ b/src/Compiler/Optimize/Optimizer.fsi
@@ -9,6 +9,11 @@ open FSharp.Compiler.TypedTree
 open FSharp.Compiler.TypedTreeOps
 open FSharp.Compiler.TypedTreePickle
 
+[<RequireQualifiedAccess>]
+type OptimizerMode =
+    | Sequential
+    | PartiallyParallel
+
 type OptimizationSettings =
     {
         abstractBigTargets: bool
@@ -40,6 +45,8 @@ type OptimizationSettings =
         reportHasEffect: bool
 
         reportTotalSizes: bool
+        
+        processingMode : OptimizerMode
     }
 
     member JitOptimizationsEnabled: bool

From 227aa3216e71f630d6c38d38244854b404f2b2b5 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Thu, 24 Nov 2022 23:34:35 +0000
Subject: [PATCH 06/42] Run two opt phases in parallel

---
 src/Compiler/Driver/Graph.fs           |   9 +-
 src/Compiler/Driver/GraphProcessing.fs |  54 ++--
 src/Compiler/Driver/OptimizeInputs.fs  | 339 +++++++++++++------------
 src/Compiler/Driver/OptimizeTypes.fs   |  56 ++--
 src/Compiler/Driver/Parallel.fs        |  11 +-
 src/Compiler/Driver/fsc.fs             |  83 +++---
 src/Compiler/Optimize/Optimizer.fsi    |   4 +-
 7 files changed, 287 insertions(+), 269 deletions(-)

diff --git a/src/Compiler/Driver/Graph.fs b/src/Compiler/Driver/Graph.fs
index 18beb186f5b..16434ccfd48 100644
--- a/src/Compiler/Driver/Graph.fs
+++ b/src/Compiler/Driver/Graph.fs
@@ -31,7 +31,7 @@ module Graph =
             let toAdd = missing |> Seq.map (fun n -> KeyValuePair(n, [||])) |> Seq.toArray
 
             Array.append (graph |> Seq.toArray) toAdd
-            |> Array.map (fun (KeyValue(k, v)) -> k, v)
+            |> Array.map (fun (KeyValue (k, v)) -> k, v)
             |> readOnlyDict
 
     /// Create entries for nodes that don't have any dependencies but are mentioned as dependencies themselves
@@ -57,8 +57,9 @@ module Graph =
         |> Array.Parallel.map (fun node -> node, go node)
         |> readOnlyDict
 
-    let private memoize<'a,'b when 'a : equality> (f : 'a -> 'b) : 'a -> 'b =
-        let cache = Dictionary<'a,'b>()
+    let private memoize<'a, 'b when 'a: equality> (f: 'a -> 'b) : 'a -> 'b =
+        let cache = Dictionary<'a, 'b>()
+
         fun a ->
             match cache.TryGetValue a with
             | true, b -> b
@@ -66,7 +67,7 @@ module Graph =
                 let b = f a
                 cache[a] <- b
                 b
-    
+
     /// Create a transitive closure of the graph.
     let transitive<'Node when 'Node: equality> (graph: Graph<'Node>) : Graph<'Node> =
         let rec calcTransitiveEdges =
diff --git a/src/Compiler/Driver/GraphProcessing.fs b/src/Compiler/Driver/GraphProcessing.fs
index 84228cf40f5..8ec763b2f7c 100644
--- a/src/Compiler/Driver/GraphProcessing.fs
+++ b/src/Compiler/Driver/GraphProcessing.fs
@@ -287,6 +287,7 @@ let processGraphSimple<'Item, 'Result when 'Item: equality and 'Item: comparison
     let makeNode (item: 'Item) : Node2<'Item, ResultWrapper<'Item, 'Result>> =
         let info =
             let exists = graph.ContainsKey item
+
             if
                 not exists
                 || not (transitiveDeps.ContainsKey item)
@@ -312,26 +313,22 @@ let processGraphSimple<'Item, 'Result when 'Item: equality and 'Item: comparison
     let lookupMany items = items |> Array.map lookup
 
     let leaves =
-        nodes.Values
-        |> Seq.filter (fun n -> n.Info.Deps.Length = 0)
-        |> Seq.toArray
+        nodes.Values |> Seq.filter (fun n -> n.Info.Deps.Length = 0) |> Seq.toArray
 
     printfn $"Node count: {nodes.Count}"
 
-    let work
-        (node: Node2<'Item, ResultWrapper<'Item, 'Result>>)
-        : Node2<'Item, ResultWrapper<'Item, 'Result>>[] =
+    let work (node: Node2<'Item, ResultWrapper<'Item, 'Result>>) : Node2<'Item, ResultWrapper<'Item, 'Result>>[] =
         let _deps = lookupMany node.Info.Deps
         let transitiveDeps = lookupMany node.Info.TransitiveDeps
-        let inputs =
-            transitiveDeps
-            |> Array.map (fun n -> n.Result |> Option.get)
+        let inputs = transitiveDeps |> Array.map (fun n -> n.Result |> Option.get)
         let singleRes = doWork node.Info.Item inputs
+
         let singleRes =
             {
                 Item = node.Info.Item
                 Result = singleRes
             }
+
         node.Result <- Some singleRes
         // Need to double-check that only one dependency schedules this dependant
         let unblocked =
@@ -343,8 +340,9 @@ let processGraphSimple<'Item, 'Result when 'Item: equality and 'Item: comparison
                     lock x (fun () ->
                         x.ProcessedDepsCount <- x.ProcessedDepsCount + 1
                         x.ProcessedDepsCount)
-                pdc = x.Info.Deps.Length
-            )
+
+                pdc = x.Info.Deps.Length)
+
         unblocked
 
     use cts = new CancellationTokenSource()
@@ -359,9 +357,7 @@ let processGraphSimple<'Item, 'Result when 'Item: equality and 'Item: comparison
 
     let nodesArray = nodes.Values |> Seq.toArray
 
-    nodesArray
-    |> Array.map (fun n -> n.Result.Value)
-
+    nodesArray |> Array.map (fun n -> n.Result.Value)
 
 /// Used for processing
 type NodeInfo3<'Item> =
@@ -370,7 +366,7 @@ type NodeInfo3<'Item> =
         Deps: 'Item[]
         Dependants: 'Item[]
     }
-    
+
 type Node3<'Item> =
     {
         Info: NodeInfo3<'Item>
@@ -383,44 +379,34 @@ let processGraphSimpler<'Item when 'Item: equality and 'Item: comparison>
     // Accepts item and a list of item results. Handles combining results.
     (doWork: 'Item -> unit)
     (parallelism: int)
-    : unit
-    =
+    : unit =
     let dependants = graph |> Graph.reverse
 
     let makeNode (item: 'Item) : Node3<'Item> =
         let info =
             let exists = graph.ContainsKey item
-            if
-                not exists
-                || not (dependants.ContainsKey item)
-            then
+
+            if not exists || not (dependants.ContainsKey item) then
                 failwith $"WHAT {item}"
+
             {
                 Item = item
                 Deps = graph[item]
                 Dependants = dependants[item]
             }
 
-        {
-            Info = info
-            ProcessedDepsCount = 0
-        }
+        { Info = info; ProcessedDepsCount = 0 }
 
     let nodes = graph.Keys |> Seq.map (fun item -> item, makeNode item) |> readOnlyDict
     let lookup item = nodes[item]
     let lookupMany items = items |> Array.map lookup
 
     let leaves =
-        nodes.Values
-        |> Seq.filter (fun n -> n.Info.Deps.Length = 0)
-        |> Seq.toArray
+        nodes.Values |> Seq.filter (fun n -> n.Info.Deps.Length = 0) |> Seq.toArray
 
     // printfn $"Node count: {nodes.Count}"
 
-    let work
-        (node: Node3<'Item>)
-        : Node3<'Item>[]
-        =
+    let work (node: Node3<'Item>) : Node3<'Item>[] =
         let _deps = lookupMany node.Info.Deps
         // printfn $"{node.Info.Item} DoWork"
         doWork node.Info.Item
@@ -435,8 +421,8 @@ let processGraphSimpler<'Item when 'Item: equality and 'Item: comparison>
                     lock x (fun () ->
                         x.ProcessedDepsCount <- x.ProcessedDepsCount + 1
                         x.ProcessedDepsCount)
-                pdc = x.Info.Deps.Length
-            )
+
+                pdc = x.Info.Deps.Length)
         // printfn $"{node.Info.Item} unblocked gathered"
         unblocked
 
diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index 382fa07b10e..3caf45ff8e2 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -6,7 +6,6 @@ open System.Collections.Generic
 open System.Diagnostics
 open System.IO
 open System.Threading
-open FSharp.Compiler.Optimizer
 open FSharp.Compiler.Service.Driver
 open FSharp.Compiler.Service.Driver.OptimizeTypes
 open Internal.Utilities.Library
@@ -57,24 +56,30 @@ let GetInitialOptimizationEnv (tcImports: TcImports, tcGlobals: TcGlobals) =
 let collectResults (inputs: CollectorInputs) : CollectorOutputs =
     let files =
         inputs
-        |> Array.map (fun {Phase1 = phase1; Phase2 = _phase2; Phase3 = phase3} ->
-            let (_, _, implFileOptData, _), optimizeDuringCodeGen = phase1
-            let _, implFile = phase3
-            let implFile =
-                {
-                    ImplFile = implFile
-                    OptimizeDuringCodeGen = optimizeDuringCodeGen
-                }
-            implFile, implFileOptData
-        )
-        
+        |> Array.map
+            (fun {
+                     Phase1 = phase1
+                     Phase2 = _phase2
+                     Phase3 = phase3
+                 } ->
+                let (_, _, implFileOptData, _), optimizeDuringCodeGen = phase1
+                let _, implFile = phase3
+
+                let implFile =
+                    {
+                        ImplFile = implFile
+                        OptimizeDuringCodeGen = optimizeDuringCodeGen
+                    }
+
+                implFile, implFileOptData)
+
     let lastFilePhase1Env =
         inputs
         |> Array.last
-        |> fun {Phase1 = phase1} ->
+        |> fun { Phase1 = phase1 } ->
             let (optEnvPhase1, _, _, _), _ = phase1
             optEnvPhase1
-            
+
     files, lastFilePhase1Env
 
 type Phase =
@@ -82,25 +87,27 @@ type Phase =
     | Phase2
     | Phase3
 
-type FilePhaseFuncs = Phase1Fun * Phase2Fun * Phase3Fun   
+type FilePhaseFuncs = Phase1Fun * Phase2Fun * Phase3Fun
+
 type FileResults =
     {
         mutable Phase1: Phase1Res option
         mutable Phase2: Phase2Res option
         mutable Phase3: Phase3Res option
     }
-    with
-        member this.HasResult (phase: Phase) =
-            match phase with
-            | Phase.Phase1 -> this.Phase1 |> Option.isSome
-            | Phase.Phase2 -> this.Phase2 |> Option.isSome
-            | Phase.Phase3 -> this.Phase3 |> Option.isSome
-        static member Empty =
-            {
-                Phase1 = None
-                Phase2 = None
-                Phase3 = None
-            }
+
+    member this.HasResult(phase: Phase) =
+        match phase with
+        | Phase.Phase1 -> this.Phase1 |> Option.isSome
+        | Phase.Phase2 -> this.Phase2 |> Option.isSome
+        | Phase.Phase3 -> this.Phase3 |> Option.isSome
+
+    static member Empty =
+        {
+            Phase1 = None
+            Phase2 = None
+            Phase3 = None
+        }
 
 type WorkItem =
     | Phase1 of Phase1Inputs
@@ -108,161 +115,163 @@ type WorkItem =
     | Phase3 of Phase3Inputs
 
 type Idx = int
+
 type Node =
     {
         Idx: Idx
         Phase: Phase
     }
-    with override this.ToString() = $"[{this.Idx}-{this.Phase}]"
 
+    override this.ToString() = $"[{this.Idx}-{this.Phase}]"
 
 let getPhase1Res (p: FileResults) =
-    p.Phase1
-    |> Option.get
-    |> fun ((env, _, _, hidden), _) -> env, hidden
+    p.Phase1 |> Option.get |> (fun ((env, _, _, hidden), _) -> env, hidden)
 
-let getPhase2Res (p: FileResults) =
-    p.Phase2
-    |> Option.get
+let getPhase2Res (p: FileResults) = p.Phase2 |> Option.get
 
 let getPhase3Res (p: FileResults) =
-    p.Phase3
-    |> Option.get
-    |> fun (env, _) -> env
+    p.Phase3 |> Option.get |> (fun (env, _) -> env)
 
-let optimizeFilesInParallel (env0: Optimizer.IncrementalOptimizationEnv) ((phase1, phase2, phase3): FilePhaseFuncs) (files: CheckedImplFile list) : CollectorOutputs =
+let optimizeFilesInParallel
+    (env0: Optimizer.IncrementalOptimizationEnv)
+    ((phase1, phase2, phase3): FilePhaseFuncs)
+    (files: CheckedImplFile list)
+    : CollectorOutputs =
     let files = files |> List.toArray
     // Schedule File1-Phase1
     let firstNode = { Idx = 0; Phase = Phase.Phase1 }
-    
-    let results =
-        files
-        |> Array.map (fun _ -> FileResults.Empty)
-    
-    let _lock = obj()
-    let nodeCanBeProcessed {Idx = idx; Phase = phase} : bool =
+
+    let results = files |> Array.map (fun _ -> FileResults.Empty)
+
+    let _lock = obj ()
+
+    let nodeCanBeProcessed { Idx = idx; Phase = phase } : bool =
         lock (_lock) (fun () ->
-            let previousFileReady =
-                if idx = 0 then true else results[idx-1].HasResult phase
+            let previousFileReady = if idx = 0 then true else results[ idx - 1 ].HasResult phase
+
             let previousPhase =
                 match phase with
                 | Phase.Phase1 -> None
                 | Phase.Phase2 -> Some Phase.Phase1
                 | Phase.Phase3 -> Some Phase.Phase2
+
             let previousPhaseReady =
                 match previousPhase with
-                | Some previousPhase -> results[idx].HasResult previousPhase
+                | Some previousPhase -> results[ idx ].HasResult previousPhase
                 | None -> true
-            previousFileReady && previousPhaseReady
-        )        
-    
+
+            previousFileReady && previousPhaseReady)
+
     let visited = HashSet<Node>()
-    
-    let worker ({Idx = idx; Phase = phase} as node : Node) : Node[] =
-        let notPreviouslyVisited =
-            lock (_lock) (fun () ->
-                visited.Add node
-            )
-        if notPreviouslyVisited = false then [||]
+
+    let worker ({ Idx = idx; Phase = phase } as node: Node) : Node[] =
+        let notPreviouslyVisited = lock (_lock) (fun () -> visited.Add node)
+
+        if notPreviouslyVisited = false then
+            [||]
         else
-        let res = results[idx]
-        let file = files[idx]
-        let previous = if idx > 0 then Some results[idx-1] else None
-        let hidingInfo0 = SignatureHidingInfo.Empty        
-        
-        let getPhase1Res (p: FileResults) =
-            p.Phase1
-            |> Option.get
-            |> fun ((env, file, info, hidden), _) -> env, file, info, hidden
-                
-        match phase with
-        | Phase.Phase1 ->
-            // take env from previous file
-            let env, hidingInfo =
-                previous
-                |> Option.map getPhase1Res
-                |> Option.map (fun (a, _b, _c, d) -> a, d)
-                |> Option.defaultValue (env0, hidingInfo0)
-            let inputs = env, hidingInfo, file
-            let phase1Res = phase1 inputs
-            res.Phase1 <- Some phase1Res
-            
-            // Schedule Phase2
-            let phase2Node = { Idx = idx; Phase = Phase.Phase2 }
-            seq {
-                yield phase2Node
-                if idx < files.Length-1 then yield { Idx = idx + 1; Phase = Phase.Phase1 }
-            }
-            |> Seq.toArray
-            
-        | Phase.Phase2 ->
-            // take env from previous file
-            let env =
-                previous
-                |> Option.map getPhase2Res
-                |> Option.map fst
-                |> Option.defaultValue env0
-            let file, info, hidingInfo =
-                res
-                |> getPhase1Res
-                |> fun (_a, b, c, d) -> b, c, d
-            let inputs = env, hidingInfo, info, file
-            let phase2Res = phase2 inputs
-            res.Phase2 <- Some phase2Res
-            
-            seq {
-                // Schedule Phase3
-                let phase3Node = { Idx = idx; Phase = Phase.Phase3 }
-                yield phase3Node
-                // Schedule Phase2 for the next file if it exists
-                if idx < files.Length-1 then yield { Idx = idx + 1; Phase = Phase.Phase2 }
-            }
-            |> Seq.toArray
-            
-        | Phase.Phase3 ->
-            // take env from previous file
-            let env =
-                previous
-                |> Option.map getPhase3Res
-                |> Option.defaultValue env0
-            // impl file
-            let _, file =
-                res
-                |> getPhase2Res
-            let hidingInfo =
-                res
-                |> getPhase1Res
-                |> fun (_a,_b,_c,d) -> d
-            let inputs = env, hidingInfo, file
-            let phase3Res = phase3 inputs
-            res.Phase3 <- Some phase3Res
-            
-            seq {
-                // Schedule Phase3 for the next file if it exists
-                if idx < files.Length-1 then yield { Idx = idx + 1; Phase = Phase.Phase3 }
-            }
-            |> Seq.toArray
-        |> fun nodes ->
-            nodes
-            |> Array.filter nodeCanBeProcessed
-    
+            let res = results[idx]
+            let file = files[idx]
+            let previous = if idx > 0 then Some results[idx - 1] else None
+            let hidingInfo0 = SignatureHidingInfo.Empty
+
+            let getPhase1Res (p: FileResults) =
+                p.Phase1
+                |> Option.get
+                |> fun ((env, file, info, hidden), _) -> env, file, info, hidden
+
+            match phase with
+            | Phase.Phase1 ->
+                // take env from previous file
+                let env, hidingInfo =
+                    previous
+                    |> Option.map getPhase1Res
+                    |> Option.map (fun (a, _b, _c, d) -> a, d)
+                    |> Option.defaultValue (env0, hidingInfo0)
+
+                let inputs = env, hidingInfo, file
+                let phase1Res = phase1 inputs
+                res.Phase1 <- Some phase1Res
+
+                // Schedule Phase2
+                let phase2Node = { Idx = idx; Phase = Phase.Phase2 }
+
+                seq {
+                    yield phase2Node
+
+                    if idx < files.Length - 1 then
+                        yield { Idx = idx + 1; Phase = Phase.Phase1 }
+                }
+                |> Seq.toArray
+
+            | Phase.Phase2 ->
+                // take env from previous file
+                let env =
+                    previous
+                    |> Option.map getPhase2Res
+                    |> Option.map fst
+                    |> Option.defaultValue env0
+
+                let file, info, hidingInfo = res |> getPhase1Res |> (fun (_a, b, c, d) -> b, c, d)
+                let inputs = env, hidingInfo, info, file
+                let phase2Res = phase2 inputs
+                res.Phase2 <- Some phase2Res
+
+                seq {
+                    // Schedule Phase3
+                    let phase3Node = { Idx = idx; Phase = Phase.Phase3 }
+                    yield phase3Node
+                    // Schedule Phase2 for the next file if it exists
+                    if idx < files.Length - 1 then
+                        yield { Idx = idx + 1; Phase = Phase.Phase2 }
+                }
+                |> Seq.toArray
+
+            | Phase.Phase3 ->
+                // take env from previous file
+                let env = previous |> Option.map getPhase3Res |> Option.defaultValue env0
+                // impl file
+                let _, file = res |> getPhase2Res
+                let hidingInfo = res |> getPhase1Res |> (fun (_a, _b, _c, d) -> d)
+                let inputs = env, hidingInfo, file
+                let phase3Res = phase3 inputs
+                res.Phase3 <- Some phase3Res
+
+                seq {
+                    // Schedule Phase3 for the next file if it exists
+                    if idx < files.Length - 1 then
+                        yield { Idx = idx + 1; Phase = Phase.Phase3 }
+                }
+                |> Seq.toArray
+            |> fun nodes -> nodes |> Array.filter nodeCanBeProcessed
+
     Parallel.processInParallel
-        [|firstNode|]
+        [| firstNode |]
         worker
         10
         (fun _ -> visited.Count >= files.Length * 3)
         (CancellationToken.None)
         (fun node -> node.ToString())
-        
+
     Debug.Assert(visited.Count = files.Length * 3)
-    
+
     let results =
         results
-        |> Array.mapi (fun i {Phase1 = phase1; Phase2 = phase2; Phase3 = phase3} ->
-            match phase1, phase2, phase3 with
-            | Some phase1, Some phase2, Some phase3 -> {FileResultsComplete.Phase1 = phase1; Phase2 = phase2; Phase3 = phase3}
-            | _ -> failwith $"Unexpected lack of results for file [{i}]"
-        )
+        |> Array.mapi
+            (fun i {
+                       Phase1 = phase1
+                       Phase2 = phase2
+                       Phase3 = phase3
+                   } ->
+                match phase1, phase2, phase3 with
+                | Some phase1, Some phase2, Some phase3 ->
+                    {
+                        FileResultsComplete.Phase1 = phase1
+                        Phase2 = phase2
+                        Phase3 = phase3
+                    }
+                | _ -> failwith $"Unexpected lack of results for file [{i}]")
+
     let collected = results |> collectResults
     collected
 
@@ -308,9 +317,8 @@ let ApplyAllOptimizations
             reportingPhase = true
         }
 
-    
     let env0 = optEnv0
-    
+
     let phase1 (env: Optimizer.IncrementalOptimizationEnv, hidden: SignatureHidingInfo, implFile: CheckedImplFile) : Phase1Res =
         //ReportTime tcConfig ("Initial simplify")
         Optimizer.OptimizeImplFile(
@@ -326,8 +334,14 @@ let ApplyAllOptimizations
             hidden,
             implFile
         )
-    
-    let phase2 (env: Optimizer.IncrementalOptimizationEnv, hidden: SignatureHidingInfo, implFileOptData: Optimizer.ImplFileOptimizationInfo, implFile: CheckedImplFile) : Phase2Res =
+
+    let phase2
+        (
+            env: Optimizer.IncrementalOptimizationEnv,
+            hidden: SignatureHidingInfo,
+            implFileOptData: Optimizer.ImplFileOptimizationInfo,
+            implFile: CheckedImplFile
+        ) : Phase2Res =
         let implFile = LowerLocalMutables.TransformImplFile tcGlobals importMap implFile
 
         // Only do this on the first pass!
@@ -341,6 +355,9 @@ let ApplyAllOptimizations
             dprintf
                 "Optimization implFileOptData:\n%s\n"
                 (LayoutRender.showL (Display.squashTo 192 (Optimizer.moduleInfoL tcGlobals implFileOptData)))
+#else
+        // Satisfy the compiler
+        implFileOptData |> ignore
 #endif
 
         if tcConfig.extraOptimizationIterations > 0 then
@@ -365,7 +382,7 @@ let ApplyAllOptimizations
             optEnvExtraLoop, implFile
         else
             env, implFile
-        
+
     let phase3 (env: Optimizer.IncrementalOptimizationEnv, hidden: SignatureHidingInfo, implFile: CheckedImplFile) : Phase3Res =
         // Only do this on the first pass!
         let optSettings =
@@ -414,28 +431,29 @@ let ApplyAllOptimizations
             optEnvFinalSimplify, implFile
         else
             env, implFile
-    
+
     let results, optEnvFirstLoop =
         match optSettings.processingMode with
-        | OptimizerMode.PartiallyParallel ->
-            let a, b =
-                optimizeFilesInParallel env0 (phase1, phase2, phase3) implFiles
+        | Optimizer.OptimizerMode.PartiallyParallel ->
+            let a, b = optimizeFilesInParallel env0 (phase1, phase2, phase3) implFiles
             a |> Array.toList, b
-        | OptimizerMode.Sequential ->
+        | Optimizer.OptimizerMode.Sequential ->
             let results, (optEnvFirstLoop, _, _, _) =
                 ((optEnv0, optEnv0, optEnv0, SignatureHidingInfo.Empty), implFiles)
 
                 ||> List.mapFold (fun (optEnvFirstLoop, optEnvExtraLoop, optEnvFinalSimplify, hidden) implFile ->
                     // Phase 1
                     //ReportTime tcConfig ("Initial simplify")
-                    let (optEnvFirstLoop, implFile, implFileOptData, hidden), optimizeDuringCodeGen = phase1 (optEnvFirstLoop, hidden, implFile)
+                    let (optEnvFirstLoop, implFile, implFileOptData, hidden), optimizeDuringCodeGen =
+                        phase1 (optEnvFirstLoop, hidden, implFile)
 
                     // Phase 2
-                    let optEnvExtraLoop, implFile = phase2 (optEnvExtraLoop, hidden, implFileOptData, implFile)
+                    let optEnvExtraLoop, implFile =
+                        phase2 (optEnvExtraLoop, hidden, implFileOptData, implFile)
 
                     // Phase 3
                     let optEnvFinalSimplify, implFile = phase3 (optEnvFinalSimplify, hidden, implFile)
-                    
+
                     let implFile =
                         {
                             ImplFile = implFile
@@ -443,6 +461,7 @@ let ApplyAllOptimizations
                         }
 
                     (implFile, implFileOptData), (optEnvFirstLoop, optEnvExtraLoop, optEnvFinalSimplify, hidden))
+
             results, optEnvFirstLoop
 
     let implFiles, implFileOptDatas = List.unzip results
diff --git a/src/Compiler/Driver/OptimizeTypes.fs b/src/Compiler/Driver/OptimizeTypes.fs
index 40f33752dcd..2b56baa0c48 100644
--- a/src/Compiler/Driver/OptimizeTypes.fs
+++ b/src/Compiler/Driver/OptimizeTypes.fs
@@ -7,22 +7,10 @@ open FSharp.Compiler.TypedTree
 open FSharp.Compiler.TypedTreeOps
 
 type OptimizeDuringCodeGen = bool -> Expr -> Expr
-type OptimizeRes =
-    (IncrementalOptimizationEnv * CheckedImplFile * ImplFileOptimizationInfo * SignatureHidingInfo) * OptimizeDuringCodeGen
+type OptimizeRes = (IncrementalOptimizationEnv * CheckedImplFile * ImplFileOptimizationInfo * SignatureHidingInfo) * OptimizeDuringCodeGen
 
 type Optimize =
-    OptimizationSettings *
-    CcuThunk *
-    TcGlobals *
-    ConstraintSolver.TcValF *
-    Import.ImportMap *
-    IncrementalOptimizationEnv *
-    bool *
-    bool *
-    bool *
-    SignatureHidingInfo *
-    CheckedImplFile ->
-        OptimizeRes
+    OptimizationSettings * CcuThunk * TcGlobals * ConstraintSolver.TcValF * Import.ImportMap * IncrementalOptimizationEnv * bool * bool * bool * SignatureHidingInfo * CheckedImplFile -> OptimizeRes
 
 type PhaseInputs = IncrementalOptimizationEnv * SignatureHidingInfo * CheckedImplFile
 
@@ -42,13 +30,16 @@ type Phase =
     | Phase1
     | Phase2
     | Phase3
+
 module Phase =
-    let all = [|Phase1; Phase2; Phase3|]
+    let all = [| Phase1; Phase2; Phase3 |]
+
     let prev (phase: Phase) =
         match phase with
         | Phase1 -> None
         | Phase2 -> Some Phase1
         | Phase3 -> Some Phase2
+
     let next (phase: Phase) =
         match phase with
         | Phase1 -> Some Phase2
@@ -59,22 +50,24 @@ type PhaseRes =
     | Phase1 of Phase1Res
     | Phase2 of Phase2Res
     | Phase3 of Phase3Res
-    with
-        member x.Which =
-            match x with
-            | Phase1 _ -> Phase.Phase1
-            | Phase2 _ -> Phase.Phase2
-            | Phase3 _ -> Phase.Phase3
-        member x.Get1() =
-            match x with
-            | Phase1 x -> x
-            | Phase2 _
-            | Phase3 _ -> failwith $"Called {nameof(x.Get1)} but this is {x.Which}"
-        member x.Get2() =
-            match x with
-            | Phase2 x -> x
-            | Phase1 _
-            | Phase3 _ -> failwith $"Called {nameof(x.Get2)} but this is {x.Which}"
+
+    member x.Which =
+        match x with
+        | Phase1 _ -> Phase.Phase1
+        | Phase2 _ -> Phase.Phase2
+        | Phase3 _ -> Phase.Phase3
+
+    member x.Get1() =
+        match x with
+        | Phase1 x -> x
+        | Phase2 _
+        | Phase3 _ -> failwith $"Called {nameof (x.Get1)} but this is {x.Which}"
+
+    member x.Get2() =
+        match x with
+        | Phase2 x -> x
+        | Phase1 _
+        | Phase3 _ -> failwith $"Called {nameof (x.Get2)} but this is {x.Which}"
 
 type FileResultsComplete =
     {
@@ -82,5 +75,6 @@ type FileResultsComplete =
         Phase2: Phase2Res
         Phase3: Phase3Res
     }
+
 type CollectorInputs = FileResultsComplete[]
 type CollectorOutputs = (CheckedImplFileAfterOptimization * ImplFileOptimizationInfo)[] * IncrementalOptimizationEnv
diff --git a/src/Compiler/Driver/Parallel.fs b/src/Compiler/Driver/Parallel.fs
index 3e566dd97a8..df19bd434d6 100644
--- a/src/Compiler/Driver/Parallel.fs
+++ b/src/Compiler/Driver/Parallel.fs
@@ -24,19 +24,19 @@ let processInParallel
     let mutable processedCount = 0
 
     let processItem item =
-        printfn $"[{Thread.CurrentThread.ManagedThreadId}] Processing {_itemToString item}"
+        // printfn $"[{Thread.CurrentThread.ManagedThreadId}] Processing {_itemToString item}"
         let toSchedule = work item
-        printfn $"[{Thread.CurrentThread.ManagedThreadId}] Finished {_itemToString item}"
+        // printfn $"[{Thread.CurrentThread.ManagedThreadId}] Finished {_itemToString item}"
 
         let processedCount =
             lock processedCountLock (fun () ->
                 processedCount <- processedCount + 1
                 processedCount)
 
-        let toScheduleString =
-            toSchedule |> Array.map _itemToString |> (fun names -> String.Join(", ", names))
+        // let toScheduleString =
+            // toSchedule |> Array.map _itemToString |> (fun names -> String.Join(", ", names))
 
-        printfn $"[{Thread.CurrentThread.ManagedThreadId}] Scheduling {toSchedule.Length} items: {toScheduleString}"
+        // printfn $"[{Thread.CurrentThread.ManagedThreadId}] Scheduling {toSchedule.Length} items: {toScheduleString}"
         toSchedule |> Array.iter bc.Add
         processedCount
 
@@ -51,4 +51,3 @@ let processInParallel
 
     // TODO Do we need to handle cancellation given that workers do it already?
     Array.Parallel.map workerWork (Array.init parallelism (fun _ -> ())) |> ignore
-
diff --git a/src/Compiler/Driver/fsc.fs b/src/Compiler/Driver/fsc.fs
index e8ec56fa5a5..c50db076254 100644
--- a/src/Compiler/Driver/fsc.fs
+++ b/src/Compiler/Driver/fsc.fs
@@ -820,13 +820,6 @@ let main3
     ReportTime tcConfig "Encode Interface Data"
     let exportRemapping = MakeExportRemapping generatedCcu generatedCcu.Contents
 
-    let sigDataAttributes, sigDataResources =
-        try
-            EncodeSignatureData(tcConfig, tcGlobals, exportRemapping, generatedCcu, outfile, false)
-        with e ->
-            errorRecoveryNoRange e
-            exiter.Exit 1
-
     let metadataVersion =
         match tcConfig.metadataVersion with
         | Some v -> v
@@ -834,35 +827,61 @@ let main3
             match frameworkTcImports.DllTable.TryFind tcConfig.primaryAssembly.Name with
             | Some ib -> ib.RawMetadata.TryGetILModuleDef().Value.MetadataVersion
             | _ -> ""
+            
+    // TODO Use proper async code
+    let (sigDataAttributes, sigDataResources), optimizedImpls, optDataResources =
+        let mutable sigDataAttributes: ILAttribute list = []
+        let mutable sigDataResources : ILResource list = []
+        let a1 =
+            async {
+                try
+                    let sigDataAttributes2, sigDataResources2 = EncodeSignatureData(tcConfig, tcGlobals, exportRemapping, generatedCcu, outfile, false)
+                    sigDataAttributes <- sigDataAttributes2
+                    sigDataResources <- sigDataResources2
+                with e ->
+                    errorRecoveryNoRange e
+                    exiter.Exit 1
+            }
 
-    let optimizedImpls, optDataResources =
-        // Perform optimization
-        use _ = UseBuildPhase BuildPhase.Optimize
-
-        let optEnv0 = GetInitialOptimizationEnv(tcImports, tcGlobals)
-
-        let importMap = tcImports.GetImportMap()
-
-        let optimizedImpls, optimizationData, _ =
-            ApplyAllOptimizations(
-                tcConfig,
-                tcGlobals,
-                (LightweightTcValForUsingInBuildMethodCall tcGlobals),
-                outfile,
-                importMap,
-                false,
-                optEnv0,
-                generatedCcu,
-                typedImplFiles
-            )
-
-        AbortOnError(diagnosticsLogger, exiter)
+        let mutable optimizedImpls2 : CheckedAssemblyAfterOptimization option = None
+        let mutable optDataResources : ILResource list = []
+        let a2 =
+            async {
+                // Perform optimization
+                use _ = UseBuildPhase BuildPhase.Optimize
+
+                let optEnv0 = GetInitialOptimizationEnv(tcImports, tcGlobals)
+
+                let importMap = tcImports.GetImportMap()
+
+                let optimizedImpls, optimizationData, _ =
+                    ApplyAllOptimizations(
+                        tcConfig,
+                        tcGlobals,
+                        (LightweightTcValForUsingInBuildMethodCall tcGlobals),
+                        outfile,
+                        importMap,
+                        false,
+                        optEnv0,
+                        generatedCcu,
+                        typedImplFiles
+                    )
 
-        // Encode the optimization data
-        ReportTime tcConfig ("Encoding OptData")
+                AbortOnError(diagnosticsLogger, exiter)
 
-        optimizedImpls, EncodeOptimizationData(tcGlobals, tcConfig, outfile, exportRemapping, (generatedCcu, optimizationData), false)
+                // Encode the optimization data
+                ReportTime tcConfig ("Encoding OptData")
 
+                optimizedImpls2 <- Some optimizedImpls
+                optDataResources <- EncodeOptimizationData(tcGlobals, tcConfig, outfile, exportRemapping, (generatedCcu, optimizationData), false)
+            }
+        
+        let t1 = a1 |> Async.StartAsTask
+        let t2 = a2 |> Async.StartAsTask
+        t1.Wait()
+        t2.Wait()
+        (sigDataAttributes, sigDataResources), optimizedImpls2.Value, optDataResources
+        
     // Pass on only the minimum information required for the next phase
     Args(
         ctok,
diff --git a/src/Compiler/Optimize/Optimizer.fsi b/src/Compiler/Optimize/Optimizer.fsi
index 20368b34814..50bc200881c 100644
--- a/src/Compiler/Optimize/Optimizer.fsi
+++ b/src/Compiler/Optimize/Optimizer.fsi
@@ -45,8 +45,8 @@ type OptimizationSettings =
         reportHasEffect: bool
 
         reportTotalSizes: bool
-        
-        processingMode : OptimizerMode
+
+        processingMode: OptimizerMode
     }
 
     member JitOptimizationsEnabled: bool

From dbe2ee63a79089cfc585eea232593b2f59ed3112 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Mon, 28 Nov 2022 22:57:35 +0000
Subject: [PATCH 07/42] Update

---
 src/Compiler/Driver/fsc.fs | 102 +++++++++++++++++++------------------
 1 file changed, 52 insertions(+), 50 deletions(-)

diff --git a/src/Compiler/Driver/fsc.fs b/src/Compiler/Driver/fsc.fs
index c50db076254..8f13b9769a4 100644
--- a/src/Compiler/Driver/fsc.fs
+++ b/src/Compiler/Driver/fsc.fs
@@ -830,57 +830,59 @@ let main3
             
     // TODO Use proper async code
     let (sigDataAttributes, sigDataResources), optimizedImpls, optDataResources =
-        let mutable sigDataAttributes: ILAttribute list = []
-        let mutable sigDataResources : ILResource list = []
-        let a1 =
-            async {
-                try
-                    let sigDataAttributes2, sigDataResources2 = EncodeSignatureData(tcConfig, tcGlobals, exportRemapping, generatedCcu, outfile, false)
-                    sigDataAttributes <- sigDataAttributes2
-                    sigDataResources <- sigDataResources2
-                with e ->
-                    errorRecoveryNoRange e
-                    exiter.Exit 1
-            }
-
-        let mutable optimizedImpls2 : CheckedAssemblyAfterOptimization option = None
-        let mutable optDataResources : ILResource list = []
-        let a2 =
-            async {
-                // Perform optimization
-                use _ = UseBuildPhase BuildPhase.Optimize
-
-                let optEnv0 = GetInitialOptimizationEnv(tcImports, tcGlobals)
-
-                let importMap = tcImports.GetImportMap()
-
-                let optimizedImpls, optimizationData, _ =
-                    ApplyAllOptimizations(
-                        tcConfig,
-                        tcGlobals,
-                        (LightweightTcValForUsingInBuildMethodCall tcGlobals),
-                        outfile,
-                        importMap,
-                        false,
-                        optEnv0,
-                        generatedCcu,
-                        typedImplFiles
-                    )
-
-                AbortOnError(diagnosticsLogger, exiter)
-
-                // Encode the optimization data
-                ReportTime tcConfig ("Encoding OptData")
+        // async {
+            let encode =
+                async {
+                    try
+                        // return EncodeSignatureData(tcConfig, tcGlobals, exportRemapping, generatedCcu, outfile, false)
+                        return EncodeSignatureData(tcConfig, tcGlobals, exportRemapping, generatedCcu, outfile, false)
+                    with e ->
+                        errorRecoveryNoRange e
+                        exiter.Exit 1
+                        return raise (InvalidOperationException("Didn't expect to reach this place in code - expected 'exiter.Exit' to fail"))
+                        //raise (InvalidOperationException("Didn't expect to reach this place in code - expected 'exiter.Exit' to fail"))
+                }
+
+            let optimize =
+                async {
+                    // Perform optimization
+                    use _ = UseBuildPhase BuildPhase.Optimize
+
+                    let optEnv0 = GetInitialOptimizationEnv(tcImports, tcGlobals)
+
+                    let importMap = tcImports.GetImportMap()
+
+                    let optimizedImpls, optimizationData, _ =
+                        ApplyAllOptimizations(
+                            tcConfig,
+                            tcGlobals,
+                            (LightweightTcValForUsingInBuildMethodCall tcGlobals),
+                            outfile,
+                            importMap,
+                            false,
+                            optEnv0,
+                            generatedCcu,
+                            typedImplFiles
+                        )
+
+                    return optimizedImpls, optimizationData
+                    // optimizedImpls, optimizationData
+                }
+            
+            let sigDataAttributes, sigDataResources = encode |> Async.RunSynchronously
+            let optimizedImpls, optimizationData = optimize |> Async.RunSynchronously
+            
+            AbortOnError(diagnosticsLogger, exiter)
+            
+            // Encode the optimization data
+            ReportTime tcConfig ("Encoding OptData")
+            let optDataResources = EncodeOptimizationData(tcGlobals, tcConfig, outfile, exportRemapping, (generatedCcu, optimizationData), false)
+            
 
-                optimizedImpls2 <- Some optimizedImpls
-                optDataResources <- EncodeOptimizationData(tcGlobals, tcConfig, outfile, exportRemapping, (generatedCcu, optimizationData), false)
-            }
-        
-        let t1 = a1 |> Async.StartAsTask
-        let t2 = a2 |> Async.StartAsTask
-        t1.Wait()
-        t2.Wait()
-        (sigDataAttributes, sigDataResources), optimizedImpls2.Value, optDataResources
+            (sigDataAttributes, sigDataResources), optimizedImpls, optDataResources
+            // return (sigDataAttributes, sigDataResources), optimizedImpls, optDataResources
+        // }
+        // |> Async.RunSynchronously
         
     // Pass on only the minimum information required for the next phase
     Args(

From 2ad72b7d7b99f47c5fa16ac6682d77d1c4cd9c4e Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Mon, 28 Nov 2022 23:20:41 +0000
Subject: [PATCH 08/42] Fix test with a hack

---
 src/Compiler/Driver/ParseAndCheckInputs.fs  |  3 +-
 src/Compiler/Driver/ParseAndCheckInputs.fsi |  3 ++
 src/Compiler/Driver/fsc.fs                  | 57 ++++++++++++---------
 3 files changed, 37 insertions(+), 26 deletions(-)

diff --git a/src/Compiler/Driver/ParseAndCheckInputs.fs b/src/Compiler/Driver/ParseAndCheckInputs.fs
index ac36b76477c..ba7e89b6341 100644
--- a/src/Compiler/Driver/ParseAndCheckInputs.fs
+++ b/src/Compiler/Driver/ParseAndCheckInputs.fs
@@ -1,4 +1,5 @@
 // Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information.
+// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information.
 
 /// Contains logic to coordinate the parsing and checking of one or a group of files
 module internal FSharp.Compiler.ParseAndCheckInputs
@@ -765,7 +766,7 @@ let ParseOneInputFile (tcConfig: TcConfig, lexResourceManager, fileName, isLastC
 /// NOTE: this needs to be improved to commit diagnotics as soon as possible
 ///
 /// NOTE: If StopProcessing is raised by any piece of work then the overall function raises StopProcessing.
-let UseMultipleDiagnosticLoggers (inputs, diagnosticsLogger, eagerFormat) f =
+let UseMultipleDiagnosticLoggers ((inputs, diagnosticsLogger, eagerFormat): 'a list * DiagnosticsLogger * (PhasedDiagnostic -> PhasedDiagnostic) option) (f: ('a * CapturingDiagnosticsLogger) list -> 'b): 'b =
 
     // Check input files and create delayed error loggers before we try to parallel parse.
     let delayLoggers =
diff --git a/src/Compiler/Driver/ParseAndCheckInputs.fsi b/src/Compiler/Driver/ParseAndCheckInputs.fsi
index 166191d363e..e173d5a344b 100644
--- a/src/Compiler/Driver/ParseAndCheckInputs.fsi
+++ b/src/Compiler/Driver/ParseAndCheckInputs.fsi
@@ -133,6 +133,9 @@ type TcState =
 /// Get the initial type checking state for a set of inputs
 val GetInitialTcState: range * string * TcConfig * TcGlobals * TcImports * TcEnv * OpenDeclaration list -> TcState
 
+
+val UseMultipleDiagnosticLoggers : ('a list * DiagnosticsLogger * (PhasedDiagnostic -> PhasedDiagnostic) option) -> (('a * CapturingDiagnosticsLogger) list -> 'b) -> 'b
+
 /// Check one input, returned as an Eventually computation
 val CheckOneInput:
     checkForErrors: (unit -> bool) *
diff --git a/src/Compiler/Driver/fsc.fs b/src/Compiler/Driver/fsc.fs
index 8f13b9769a4..2ed3ca6fd7d 100644
--- a/src/Compiler/Driver/fsc.fs
+++ b/src/Compiler/Driver/fsc.fs
@@ -840,37 +840,44 @@ let main3
                         errorRecoveryNoRange e
                         exiter.Exit 1
                         return raise (InvalidOperationException("Didn't expect to reach this place in code - expected 'exiter.Exit' to fail"))
-                        //raise (InvalidOperationException("Didn't expect to reach this place in code - expected 'exiter.Exit' to fail"))
                 }
 
-            let optimize =
+            let optimize () =
+                // Perform optimization
+                use _ = UseBuildPhase BuildPhase.Optimize
+
+                let optEnv0 = GetInitialOptimizationEnv(tcImports, tcGlobals)
+
+                let importMap = tcImports.GetImportMap()
+
+                let optimizedImpls, optimizationData, _ =
+                    ApplyAllOptimizations(
+                        tcConfig,
+                        tcGlobals,
+                        (LightweightTcValForUsingInBuildMethodCall tcGlobals),
+                        outfile,
+                        importMap,
+                        false,
+                        optEnv0,
+                        generatedCcu,
+                        typedImplFiles
+                    )
+
+                optimizedImpls, optimizationData
+            let optimize2 =
                 async {
-                    // Perform optimization
-                    use _ = UseBuildPhase BuildPhase.Optimize
-
-                    let optEnv0 = GetInitialOptimizationEnv(tcImports, tcGlobals)
-
-                    let importMap = tcImports.GetImportMap()
-
-                    let optimizedImpls, optimizationData, _ =
-                        ApplyAllOptimizations(
-                            tcConfig,
-                            tcGlobals,
-                            (LightweightTcValForUsingInBuildMethodCall tcGlobals),
-                            outfile,
-                            importMap,
-                            false,
-                            optEnv0,
-                            generatedCcu,
-                            typedImplFiles
-                        )
-
-                    return optimizedImpls, optimizationData
-                    // optimizedImpls, optimizationData
+                    return UseMultipleDiagnosticLoggers ([1], diagnosticsLogger, None) (fun sourceFilesWithDelayLoggers ->
+                        match sourceFilesWithDelayLoggers with
+                        | [_, b] ->
+                            DiagnosticsThreadStatics.DiagnosticsLogger <- b
+                            let res = optimize ()
+                            res
+                        | _ -> failwith "blah"
+                    )
                 }
             
             let sigDataAttributes, sigDataResources = encode |> Async.RunSynchronously
-            let optimizedImpls, optimizationData = optimize |> Async.RunSynchronously
+            let optimizedImpls, optimizationData = optimize2 |> Async.RunSynchronously
             
             AbortOnError(diagnosticsLogger, exiter)
             

From 9c31d2871178cb83e25dc9a44888fcdab9a1ad67 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Thu, 1 Dec 2022 18:37:14 +0000
Subject: [PATCH 09/42] WIP

---
 src/Compiler/Driver/fsc.fs | 77 ++++++++++++++++++++------------------
 1 file changed, 41 insertions(+), 36 deletions(-)

diff --git a/src/Compiler/Driver/fsc.fs b/src/Compiler/Driver/fsc.fs
index 2ed3ca6fd7d..d96bf3ae188 100644
--- a/src/Compiler/Driver/fsc.fs
+++ b/src/Compiler/Driver/fsc.fs
@@ -532,6 +532,7 @@ let main1
 
     // Process command line, flags and collect filenames
     let sourceFiles =
+
         // The ParseCompilerOptions function calls imperative function to process "real" args
         // Rather than start processing, just collect names, then process them.
         try
@@ -709,6 +710,7 @@ let main2
            exiter: Exiter,
            ilSourceDocs))
     =
+
     if tcConfig.typeCheckOnly then
         exiter.Exit 0
 
@@ -794,6 +796,21 @@ let main2
         ilSourceDocs
     )
 
+let doInParallelWithSettingThreadStaticLogger (logger: DiagnosticsLogger) (actions: (unit -> unit) list) =
+    UseMultipleDiagnosticLoggers (actions, logger, None) (fun actionsWithLoggers ->
+        let go (action: unit -> unit, logger: DiagnosticsLogger) : unit =
+            let oldLogger = DiagnosticsThreadStatics.DiagnosticsLogger
+            try
+                DiagnosticsThreadStatics.DiagnosticsLogger <- logger
+                action ()
+            finally
+                DiagnosticsThreadStatics.DiagnosticsLogger <- oldLogger
+        
+        actionsWithLoggers
+        |> List.toArray
+        |> ArrayParallel.iter go
+    )
+
 /// Third phase of compilation.
 ///   - encode signature data
 ///   - optimize
@@ -830,19 +847,17 @@ let main3
             
     // TODO Use proper async code
     let (sigDataAttributes, sigDataResources), optimizedImpls, optDataResources =
-        // async {
-            let encode =
-                async {
-                    try
-                        // return EncodeSignatureData(tcConfig, tcGlobals, exportRemapping, generatedCcu, outfile, false)
-                        return EncodeSignatureData(tcConfig, tcGlobals, exportRemapping, generatedCcu, outfile, false)
-                    with e ->
-                        errorRecoveryNoRange e
-                        exiter.Exit 1
-                        return raise (InvalidOperationException("Didn't expect to reach this place in code - expected 'exiter.Exit' to fail"))
-                }
-
-            let optimize () =
+            let mutable encodeResult : (ILAttribute list * ILResource list) option = None
+            let encode () =
+                try
+                    EncodeSignatureData(tcConfig, tcGlobals, exportRemapping, generatedCcu, outfile, false)
+                with e ->
+                    errorRecoveryNoRange e
+                    exiter.Exit 1
+                    raise (InvalidOperationException("Didn't expect to reach this place in code - expected 'exiter.Exit' to fail"))
+            
+            let mutable optimizeResult : (CheckedAssemblyAfterOptimization * Optimizer.LazyModuleInfo) option = None
+            let optimize (): CheckedAssemblyAfterOptimization * Optimizer.LazyModuleInfo =
                 // Perform optimization
                 use _ = UseBuildPhase BuildPhase.Optimize
 
@@ -862,31 +877,21 @@ let main3
                         generatedCcu,
                         typedImplFiles
                     )
-
                 optimizedImpls, optimizationData
-            let optimize2 =
-                async {
-                    return UseMultipleDiagnosticLoggers ([1], diagnosticsLogger, None) (fun sourceFilesWithDelayLoggers ->
-                        match sourceFilesWithDelayLoggers with
-                        | [_, b] ->
-                            DiagnosticsThreadStatics.DiagnosticsLogger <- b
-                            let res = optimize ()
-                            res
-                        | _ -> failwith "blah"
-                    )
-                }
-            
-            let sigDataAttributes, sigDataResources = encode |> Async.RunSynchronously
-            let optimizedImpls, optimizationData = optimize2 |> Async.RunSynchronously
-            
-            AbortOnError(diagnosticsLogger, exiter)
-            
-            // Encode the optimization data
-            ReportTime tcConfig ("Encoding OptData")
-            let optDataResources = EncodeOptimizationData(tcGlobals, tcConfig, outfile, exportRemapping, (generatedCcu, optimizationData), false)
-            
 
-            (sigDataAttributes, sigDataResources), optimizedImpls, optDataResources
+            let encode2 () = encodeResult <- Some (encode())
+            let optimize2 () = optimizeResult <- Some (optimize())
+            doInParallelWithSettingThreadStaticLogger diagnosticsLogger [encode2; optimize2]
+            
+            match encodeResult, optimizeResult with
+            | Some (sigDataAttributes, sigDataResources), Some (optimizedImpls, optimizationData) ->
+                AbortOnError(diagnosticsLogger, exiter)
+                // Encode the optimization data
+                ReportTime tcConfig ("Encoding OptData")
+                let optDataResources = EncodeOptimizationData(tcGlobals, tcConfig, outfile, exportRemapping, (generatedCcu, optimizationData), false)
+                (sigDataAttributes, sigDataResources), optimizedImpls, optDataResources
+            | _, _ ->
+                failwith "Expected encode and optimize results to be populated at this point."
             // return (sigDataAttributes, sigDataResources), optimizedImpls, optDataResources
         // }
         // |> Async.RunSynchronously

From 3e4e279c686dd3d20dbe8fee6775adf8b60c645f Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Thu, 1 Dec 2022 18:40:12 +0000
Subject: [PATCH 10/42] Revert changes to fsc.fs - no need to run Encode &
 Optimize in parallel for now as almost no gain.

---
 src/Compiler/Driver/fsc.fs | 105 ++++++++++++++-----------------------
 1 file changed, 38 insertions(+), 67 deletions(-)

diff --git a/src/Compiler/Driver/fsc.fs b/src/Compiler/Driver/fsc.fs
index d96bf3ae188..96647409565 100644
--- a/src/Compiler/Driver/fsc.fs
+++ b/src/Compiler/Driver/fsc.fs
@@ -796,21 +796,6 @@ let main2
         ilSourceDocs
     )
 
-let doInParallelWithSettingThreadStaticLogger (logger: DiagnosticsLogger) (actions: (unit -> unit) list) =
-    UseMultipleDiagnosticLoggers (actions, logger, None) (fun actionsWithLoggers ->
-        let go (action: unit -> unit, logger: DiagnosticsLogger) : unit =
-            let oldLogger = DiagnosticsThreadStatics.DiagnosticsLogger
-            try
-                DiagnosticsThreadStatics.DiagnosticsLogger <- logger
-                action ()
-            finally
-                DiagnosticsThreadStatics.DiagnosticsLogger <- oldLogger
-        
-        actionsWithLoggers
-        |> List.toArray
-        |> ArrayParallel.iter go
-    )
-
 /// Third phase of compilation.
 ///   - encode signature data
 ///   - optimize
@@ -833,10 +818,18 @@ let main3
            exiter: Exiter,
            ilSourceDocs))
     =
+
     // Encode the signature data
     ReportTime tcConfig "Encode Interface Data"
     let exportRemapping = MakeExportRemapping generatedCcu generatedCcu.Contents
 
+    let sigDataAttributes, sigDataResources =
+        try
+            EncodeSignatureData(tcConfig, tcGlobals, exportRemapping, generatedCcu, outfile, false)
+        with e ->
+            errorRecoveryNoRange e
+            exiter.Exit 1
+
     let metadataVersion =
         match tcConfig.metadataVersion with
         | Some v -> v
@@ -844,58 +837,35 @@ let main3
             match frameworkTcImports.DllTable.TryFind tcConfig.primaryAssembly.Name with
             | Some ib -> ib.RawMetadata.TryGetILModuleDef().Value.MetadataVersion
             | _ -> ""
-            
-    // TODO Use proper async code
-    let (sigDataAttributes, sigDataResources), optimizedImpls, optDataResources =
-            let mutable encodeResult : (ILAttribute list * ILResource list) option = None
-            let encode () =
-                try
-                    EncodeSignatureData(tcConfig, tcGlobals, exportRemapping, generatedCcu, outfile, false)
-                with e ->
-                    errorRecoveryNoRange e
-                    exiter.Exit 1
-                    raise (InvalidOperationException("Didn't expect to reach this place in code - expected 'exiter.Exit' to fail"))
-            
-            let mutable optimizeResult : (CheckedAssemblyAfterOptimization * Optimizer.LazyModuleInfo) option = None
-            let optimize (): CheckedAssemblyAfterOptimization * Optimizer.LazyModuleInfo =
-                // Perform optimization
-                use _ = UseBuildPhase BuildPhase.Optimize
-
-                let optEnv0 = GetInitialOptimizationEnv(tcImports, tcGlobals)
-
-                let importMap = tcImports.GetImportMap()
-
-                let optimizedImpls, optimizationData, _ =
-                    ApplyAllOptimizations(
-                        tcConfig,
-                        tcGlobals,
-                        (LightweightTcValForUsingInBuildMethodCall tcGlobals),
-                        outfile,
-                        importMap,
-                        false,
-                        optEnv0,
-                        generatedCcu,
-                        typedImplFiles
-                    )
-                optimizedImpls, optimizationData
-
-            let encode2 () = encodeResult <- Some (encode())
-            let optimize2 () = optimizeResult <- Some (optimize())
-            doInParallelWithSettingThreadStaticLogger diagnosticsLogger [encode2; optimize2]
-            
-            match encodeResult, optimizeResult with
-            | Some (sigDataAttributes, sigDataResources), Some (optimizedImpls, optimizationData) ->
-                AbortOnError(diagnosticsLogger, exiter)
-                // Encode the optimization data
-                ReportTime tcConfig ("Encoding OptData")
-                let optDataResources = EncodeOptimizationData(tcGlobals, tcConfig, outfile, exportRemapping, (generatedCcu, optimizationData), false)
-                (sigDataAttributes, sigDataResources), optimizedImpls, optDataResources
-            | _, _ ->
-                failwith "Expected encode and optimize results to be populated at this point."
-            // return (sigDataAttributes, sigDataResources), optimizedImpls, optDataResources
-        // }
-        // |> Async.RunSynchronously
-        
+
+    let optimizedImpls, optDataResources =
+        // Perform optimization
+        use _ = UseBuildPhase BuildPhase.Optimize
+
+        let optEnv0 = GetInitialOptimizationEnv(tcImports, tcGlobals)
+
+        let importMap = tcImports.GetImportMap()
+
+        let optimizedImpls, optimizationData, _ =
+            ApplyAllOptimizations(
+                tcConfig,
+                tcGlobals,
+                (LightweightTcValForUsingInBuildMethodCall tcGlobals),
+                outfile,
+                importMap,
+                false,
+                optEnv0,
+                generatedCcu,
+                typedImplFiles
+            )
+
+        AbortOnError(diagnosticsLogger, exiter)
+
+        // Encode the optimization data
+        ReportTime tcConfig ("Encoding OptData")
+
+        optimizedImpls, EncodeOptimizationData(tcGlobals, tcConfig, outfile, exportRemapping, (generatedCcu, optimizationData), false)
+
     // Pass on only the minimum information required for the next phase
     Args(
         ctok,
@@ -944,6 +914,7 @@ let main4
            exiter: Exiter,
            ilSourceDocs))
     =
+
     match tcImportsCapture with
     | None -> ()
     | Some f -> f tcImports

From 7970ba35e7bccfb9a634ab2a4d281fd05ff8c2eb Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Thu, 1 Dec 2022 22:31:06 +0000
Subject: [PATCH 11/42] Cleanup + fantomas

---
 src/Compiler/Driver/Graph.fs                | 110 ----
 src/Compiler/Driver/GraphProcessing.fs      | 437 ----------------
 src/Compiler/Driver/OptimizeInputs.fs       | 533 +++++++++++---------
 src/Compiler/Driver/OptimizeInputs.fsi      |   2 -
 src/Compiler/Driver/OptimizeTypes.fs        |  80 ---
 src/Compiler/Driver/Parallel.fs             |  61 +--
 src/Compiler/FSharp.Compiler.Service.fsproj |   3 -
 src/Compiler/Utilities/lib.fs               |  19 +-
 8 files changed, 332 insertions(+), 913 deletions(-)
 delete mode 100644 src/Compiler/Driver/Graph.fs
 delete mode 100644 src/Compiler/Driver/GraphProcessing.fs
 delete mode 100644 src/Compiler/Driver/OptimizeTypes.fs

diff --git a/src/Compiler/Driver/Graph.fs b/src/Compiler/Driver/Graph.fs
deleted file mode 100644
index 16434ccfd48..00000000000
--- a/src/Compiler/Driver/Graph.fs
+++ /dev/null
@@ -1,110 +0,0 @@
-module FSharp.Compiler.Service.Driver.Graph
-
-#nowarn "1182"
-#nowarn "40"
-
-open System.Collections.Generic
-
-/// <summary> DAG of files </summary>
-type Graph<'Node> = IReadOnlyDictionary<'Node, 'Node[]>
-
-module Graph =
-
-    let make (nodeDeps: ('Node * 'Node[]) seq) = nodeDeps |> readOnlyDict
-
-    let map (f: 'a -> 'b) (graph: Graph<'a>) : Graph<'b> =
-        graph
-        |> Seq.map (fun (KeyValue (node, deps)) -> f node, deps |> Array.map f)
-        |> make
-
-    let collectEdges<'Node when 'Node: equality> (graph: Graph<'Node>) : ('Node * 'Node)[] =
-        let graph: IReadOnlyDictionary<'Node, 'Node[]> = graph
-
-        graph
-        |> Seq.collect (fun (KeyValue (node, deps)) -> deps |> Array.map (fun dep -> node, dep))
-        |> Seq.toArray
-
-    let addIfMissing<'Node when 'Node: equality> (nodes: 'Node seq) (graph: Graph<'Node>) : Graph<'Node> =
-        nodes
-        |> Seq.except (graph.Keys |> Seq.toArray)
-        |> fun missing ->
-            let toAdd = missing |> Seq.map (fun n -> KeyValuePair(n, [||])) |> Seq.toArray
-
-            Array.append (graph |> Seq.toArray) toAdd
-            |> Array.map (fun (KeyValue (k, v)) -> k, v)
-            |> readOnlyDict
-
-    /// Create entries for nodes that don't have any dependencies but are mentioned as dependencies themselves
-    let fillEmptyNodes<'Node when 'Node: equality> (graph: Graph<'Node>) : Graph<'Node> =
-        let missingNodes =
-            graph.Values |> Seq.toArray |> Array.concat |> Array.except graph.Keys
-
-        addIfMissing missingNodes graph
-
-    /// Create a transitive closure of the graph
-    let transitiveOpt<'Node when 'Node: equality> (graph: Graph<'Node>) : Graph<'Node> =
-        let go (node: 'Node) =
-            let visited = HashSet<'Node>()
-
-            let rec dfs (node: 'Node) =
-                graph[node] |> Array.filter visited.Add |> Array.iter dfs
-
-            dfs node
-            visited |> Seq.toArray
-
-        graph.Keys
-        |> Seq.toArray
-        |> Array.Parallel.map (fun node -> node, go node)
-        |> readOnlyDict
-
-    let private memoize<'a, 'b when 'a: equality> (f: 'a -> 'b) : 'a -> 'b =
-        let cache = Dictionary<'a, 'b>()
-
-        fun a ->
-            match cache.TryGetValue a with
-            | true, b -> b
-            | false, _ ->
-                let b = f a
-                cache[a] <- b
-                b
-
-    /// Create a transitive closure of the graph.
-    let transitive<'Node when 'Node: equality> (graph: Graph<'Node>) : Graph<'Node> =
-        let rec calcTransitiveEdges =
-            fun (node: 'Node) ->
-                let edgeTargets =
-                    match graph.TryGetValue node with
-                    | true, x -> x
-                    | false, _ -> [||]
-
-                edgeTargets
-                |> Array.collect calcTransitiveEdges
-                |> Array.append edgeTargets
-                |> Array.distinct
-            |> memoize
-
-        graph.Keys
-        |> Seq.map (fun node -> node, calcTransitiveEdges node)
-        |> readOnlyDict
-
-    /// Create a reverse of the graph
-    let reverse (originalGraph: Graph<'Node>) : Graph<'Node> =
-        originalGraph
-        // Collect all edges
-        |> Seq.collect (fun (KeyValue (idx, deps)) -> deps |> Array.map (fun dep -> idx, dep))
-        // Group dependants of the same dependencies together
-        |> Seq.groupBy (fun (_idx, dep) -> dep)
-        // Construct reversed graph
-        |> Seq.map (fun (dep, edges) -> dep, edges |> Seq.map fst |> Seq.toArray)
-        |> readOnlyDict
-        |> addIfMissing originalGraph.Keys
-
-    let printCustom (graph: Graph<'Node>) (printer: 'Node -> string) : unit =
-        printfn "Graph:"
-        let join (xs: string[]) = System.String.Join(", ", xs)
-
-        graph
-        |> Seq.iter (fun (KeyValue (file, deps)) -> printfn $"{file} -> {deps |> Array.map printer |> join}")
-
-    let print (graph: Graph<'Node>) : unit =
-        printCustom graph (fun node -> node.ToString())
diff --git a/src/Compiler/Driver/GraphProcessing.fs b/src/Compiler/Driver/GraphProcessing.fs
deleted file mode 100644
index 8ec763b2f7c..00000000000
--- a/src/Compiler/Driver/GraphProcessing.fs
+++ /dev/null
@@ -1,437 +0,0 @@
-/// Parallel processing of graph of work items with dependencies
-module FSharp.Compiler.Service.Driver.GraphProcessing
-
-open System.Collections.Generic
-open System.Threading
-open FSharp.Compiler.Service.Driver.Graph
-
-/// Used for processing
-type NodeInfo<'Item> =
-    {
-        Item: 'Item
-        Deps: 'Item[]
-        TransitiveDeps: 'Item[]
-        Dependants: 'Item[]
-    }
-
-type StateMeta<'Item> =
-    {
-        Contributors: 'Item[]
-    }
-
-    static member Empty() = { Contributors = [||] }
-
-type StateWrapper<'Item, 'State> =
-    {
-        Meta: StateMeta<'Item>
-        State: 'State
-    }
-
-type ResultWrapper<'Item, 'Result> = { Item: 'Item; Result: 'Result }
-
-type Node<'Item, 'State, 'Result> =
-    {
-        Info: NodeInfo<'Item>
-        mutable ProcessedDepsCount: int
-        mutable Result: ('State * 'Result) option
-        mutable InputState: 'State option
-    }
-
-// TODO Do we need to suppress some error logging if we
-// TODO apply the same partial results multiple times?
-// TODO Maybe we can enable logging only for the final fold
-/// <summary>
-/// Combine results of dependencies needed to type-check a 'higher' node in the graph
-/// </summary>
-let combineResultsOld
-    (emptyState: 'State)
-    (deps: Node<'Item, 'State, 'Result>[])
-    (transitiveDeps: Node<'Item, 'State, 'Result>[])
-    (folder: 'State -> 'Result -> 'State)
-    : 'State =
-    match deps with
-    | [||] -> emptyState
-    | _ ->
-
-        let biggestDep =
-            let sizeMetric node =
-                // Could also use eg. total file size/AST size
-                node.Info.Item
-            // node.Info.TransitiveDeps.Length
-            deps
-            // TODO To workaround a problem with merging state in the wrong order,
-            // we temporarily effectively pick the child with the lowest index.
-            // This means children are folded fully in sequence
-            |> Array.minBy sizeMetric
-
-        let orFail value =
-            value |> Option.defaultWith (fun () -> failwith "Unexpected lack of result")
-
-        let firstState = biggestDep.Result |> orFail |> fst
-
-        // TODO Potential perf optimisation: Keep transDeps in a HashSet from the start,
-        // avoiding reconstructing the HashSet here
-
-        // Add single-file results of remaining transitive deps one-by-one using folder
-        // Note: Good to preserve order here so that folding happens in file order
-        let included =
-            let set = HashSet(biggestDep.Info.TransitiveDeps)
-            set.Add biggestDep.Info.Item |> ignore
-            set
-
-        let resultsToAdd =
-            transitiveDeps
-            |> Array.filter (fun dep -> included.Contains dep.Info.Item = false)
-            |> Array.distinctBy (fun dep -> dep.Info.Item)
-            |> Array.map (fun dep -> dep.Result |> orFail |> snd)
-
-        let state = Array.fold folder firstState resultsToAdd
-        state
-
-// TODO Do we need to suppress some error logging if we
-// TODO apply the same partial results multiple times?
-// TODO Maybe we can enable logging only for the final fold
-/// <summary>
-/// Combine results of dependencies needed to type-check a 'higher' node in the graph
-/// </summary>
-let combineResults
-    (emptyState: 'State)
-    (deps: Node<'Item, 'State, 'Result>[])
-    (transitiveDeps: Node<'Item, 'State, 'Result>[])
-    (folder: 'State -> 'Result -> 'State)
-    (_foldingOrderer: 'Item -> int)
-    : 'State =
-    match deps with
-    | [||] -> emptyState
-    | _ ->
-        let orFail value =
-            value |> Option.defaultWith (fun () -> failwith "Unexpected lack of result")
-
-        let firstState = emptyState
-        // TODO Potential perf optimisation: Keep transDeps in a HashSet from the start,
-        // avoiding reconstructing the HashSet here
-
-        // Add single-file results of remaining transitive deps one-by-one using folder
-        // Note: Good to preserve order here so that folding happens in file order
-        let included =
-            let set = HashSet()
-            //set.Add biggestDep.Info.Item |> ignore
-            set
-
-        let resultsToAdd =
-            transitiveDeps
-            // Sort it by effectively file index.
-            // For some reason this is needed, otherwise gives 'missing namespace' and other errors when using the resulting state.
-            // Does this make sense? Should the results be foldable in any order?
-            // TODO Use _foldingOrderer
-            |> Array.sortBy (fun node -> node.Info.Item)
-            |> Array.filter (fun dep -> included.Contains dep.Info.Item = false)
-            |> Array.distinctBy (fun dep -> dep.Info.Item)
-            |> Array.map (fun dep -> dep.Result |> orFail |> snd)
-
-        let state = Array.fold folder firstState resultsToAdd
-        state
-
-// TODO Could be replaced with a simpler recursive approach with memoised per-item results
-let processGraph<'Item, 'State, 'Result, 'FinalFileResult when 'Item: equality and 'Item: comparison>
-    (graph: Graph<'Item>)
-    (doWork: 'Item -> 'State -> 'Result)
-    (folder: 'State -> 'Result -> 'FinalFileResult * 'State)
-    (foldingOrderer: 'Item -> int)
-    (emptyState: 'State)
-    (includeInFinalState: 'Item -> bool)
-    (parallelism: int)
-    : 'FinalFileResult[] * 'State =
-    let transitiveDeps = graph |> Graph.transitiveOpt
-    let dependants = graph |> Graph.reverse
-
-    let makeNode (item: 'Item) : Node<'Item, StateWrapper<'Item, 'State>, ResultWrapper<'Item, 'Result>> =
-        let info =
-            let exists = graph.ContainsKey item
-
-            if
-                not exists
-                || not (transitiveDeps.ContainsKey item)
-                || not (dependants.ContainsKey item)
-            then
-                printfn $"WHAT {item}"
-
-            {
-                Item = item
-                Deps = graph[item]
-                TransitiveDeps = transitiveDeps[item]
-                Dependants = dependants[item]
-            }
-
-        {
-            Info = info
-            Result = None
-            ProcessedDepsCount = 0
-            InputState = None
-        }
-
-    let nodes = graph.Keys |> Seq.map (fun item -> item, makeNode item) |> readOnlyDict
-    let lookup item = nodes[item]
-    let lookupMany items = items |> Array.map lookup
-
-    let leaves =
-        nodes.Values |> Seq.filter (fun n -> n.Info.Deps.Length = 0) |> Seq.toArray
-
-    let emptyState =
-        {
-            Meta = StateMeta.Empty<'Item>()
-            State = emptyState
-        }
-
-    let folder { Meta = meta; State = state } { Item = item; Result = result } =
-        let finalFileResult, state = folder state result
-
-        let state =
-            {
-                Meta =
-                    {
-                        Contributors = Array.append meta.Contributors [| item |]
-                    }
-                State = state
-            }
-
-        finalFileResult, state
-
-    printfn $"Node count: {nodes.Count}"
-    // let mutable cnt = 1
-
-    let work
-        (node: Node<'Item, StateWrapper<'Item, 'State>, ResultWrapper<'Item, 'Result>>)
-        : Node<'Item, StateWrapper<'Item, 'State>, ResultWrapper<'Item, 'Result>>[] =
-        let folder x y = folder x y |> snd
-        let deps = lookupMany node.Info.Deps
-        let transitiveDeps = lookupMany node.Info.TransitiveDeps
-        let inputState = combineResults emptyState deps transitiveDeps folder foldingOrderer
-        node.InputState <- Some inputState
-        let singleRes = doWork node.Info.Item inputState.State
-
-        let singleRes =
-            {
-                Item = node.Info.Item
-                Result = singleRes
-            }
-
-        let state = folder inputState singleRes
-        //let state,  = folder inputState singleRes
-        node.Result <- Some(state, singleRes)
-        // Need to double-check that only one dependency schedules this dependant
-        let unblocked =
-            node.Info.Dependants
-            |> lookupMany
-            |> Array.filter (fun x ->
-                let pdc =
-                    // TODO Not ideal, better ways most likely exist
-                    lock x (fun () ->
-                        x.ProcessedDepsCount <- x.ProcessedDepsCount + 1
-                        x.ProcessedDepsCount)
-
-                pdc = x.Info.Deps.Length)
-        // printfn $"State after {node.Info.Item}"
-        // nodes
-        // |> Seq.map (fun (KeyValue(_, v)) ->
-        //     let x = v.Info.Deps.Length - v.ProcessedDepsCount
-        //     $"{v.Info.Item} - {x} deps left"
-        // )
-        // |> Seq.iter (fun x -> printfn $"{x}")
-        // let c = cnt
-        // cnt <- cnt+1
-        // printfn $"Finished processing node. {unblocked.Length} nodes unblocked"
-        unblocked
-
-    use cts = new CancellationTokenSource()
-
-    Parallel.processInParallel
-        leaves
-        work
-        parallelism
-        (fun processedCount -> processedCount = nodes.Count)
-        cts.Token
-        (fun x -> x.Info.Item.ToString())
-
-    let nodesArray = nodes.Values |> Seq.toArray
-
-    let finals, { State = state }: 'FinalFileResult[] * StateWrapper<'Item, 'State> =
-        nodesArray
-        |> Array.filter (fun node -> includeInFinalState node.Info.Item)
-        |> Array.sortBy (fun node -> node.Info.Item)
-        |> Array.fold
-            (fun (fileResults, state) node ->
-                let fileResult, state = folder state (node.Result.Value |> snd)
-                Array.append fileResults [| fileResult |], state)
-            ([||], emptyState)
-
-    finals, state
-
-type Node2<'Item, 'Result> =
-    {
-        Info: NodeInfo<'Item>
-        mutable ProcessedDepsCount: int
-        mutable Result: 'Result option
-    }
-
-// TODO Could be replaced with a simpler recursive approach with memoised per-item results
-let processGraphSimple<'Item, 'Result when 'Item: equality and 'Item: comparison>
-    (graph: Graph<'Item>)
-    // Accepts item and a list of item results. Handles combining results.
-    (doWork: 'Item -> ResultWrapper<'Item, 'Result>[] -> 'Result)
-    (parallelism: int)
-    : ResultWrapper<'Item, 'Result>[] =
-    let transitiveDeps = graph |> Graph.transitiveOpt
-    let dependants = graph |> Graph.reverse
-
-    let makeNode (item: 'Item) : Node2<'Item, ResultWrapper<'Item, 'Result>> =
-        let info =
-            let exists = graph.ContainsKey item
-
-            if
-                not exists
-                || not (transitiveDeps.ContainsKey item)
-                || not (dependants.ContainsKey item)
-            then
-                failwith $"WHAT {item}"
-
-            {
-                Item = item
-                Deps = graph[item]
-                TransitiveDeps = transitiveDeps[item]
-                Dependants = dependants[item]
-            }
-
-        {
-            Info = info
-            Result = None
-            ProcessedDepsCount = 0
-        }
-
-    let nodes = graph.Keys |> Seq.map (fun item -> item, makeNode item) |> readOnlyDict
-    let lookup item = nodes[item]
-    let lookupMany items = items |> Array.map lookup
-
-    let leaves =
-        nodes.Values |> Seq.filter (fun n -> n.Info.Deps.Length = 0) |> Seq.toArray
-
-    printfn $"Node count: {nodes.Count}"
-
-    let work (node: Node2<'Item, ResultWrapper<'Item, 'Result>>) : Node2<'Item, ResultWrapper<'Item, 'Result>>[] =
-        let _deps = lookupMany node.Info.Deps
-        let transitiveDeps = lookupMany node.Info.TransitiveDeps
-        let inputs = transitiveDeps |> Array.map (fun n -> n.Result |> Option.get)
-        let singleRes = doWork node.Info.Item inputs
-
-        let singleRes =
-            {
-                Item = node.Info.Item
-                Result = singleRes
-            }
-
-        node.Result <- Some singleRes
-        // Need to double-check that only one dependency schedules this dependant
-        let unblocked =
-            node.Info.Dependants
-            |> lookupMany
-            |> Array.filter (fun x ->
-                let pdc =
-                    // TODO Not ideal, better ways most likely exist
-                    lock x (fun () ->
-                        x.ProcessedDepsCount <- x.ProcessedDepsCount + 1
-                        x.ProcessedDepsCount)
-
-                pdc = x.Info.Deps.Length)
-
-        unblocked
-
-    use cts = new CancellationTokenSource()
-
-    Parallel.processInParallel
-        leaves
-        work
-        parallelism
-        (fun processedCount -> processedCount = nodes.Count)
-        cts.Token
-        (fun x -> x.Info.Item.ToString())
-
-    let nodesArray = nodes.Values |> Seq.toArray
-
-    nodesArray |> Array.map (fun n -> n.Result.Value)
-
-/// Used for processing
-type NodeInfo3<'Item> =
-    {
-        Item: 'Item
-        Deps: 'Item[]
-        Dependants: 'Item[]
-    }
-
-type Node3<'Item> =
-    {
-        Info: NodeInfo3<'Item>
-        mutable ProcessedDepsCount: int
-    }
-
-/// Graph processing that doesn't handle results but just invokes the worker when dependencies are ready
-let processGraphSimpler<'Item when 'Item: equality and 'Item: comparison>
-    (graph: Graph<'Item>)
-    // Accepts item and a list of item results. Handles combining results.
-    (doWork: 'Item -> unit)
-    (parallelism: int)
-    : unit =
-    let dependants = graph |> Graph.reverse
-
-    let makeNode (item: 'Item) : Node3<'Item> =
-        let info =
-            let exists = graph.ContainsKey item
-
-            if not exists || not (dependants.ContainsKey item) then
-                failwith $"WHAT {item}"
-
-            {
-                Item = item
-                Deps = graph[item]
-                Dependants = dependants[item]
-            }
-
-        { Info = info; ProcessedDepsCount = 0 }
-
-    let nodes = graph.Keys |> Seq.map (fun item -> item, makeNode item) |> readOnlyDict
-    let lookup item = nodes[item]
-    let lookupMany items = items |> Array.map lookup
-
-    let leaves =
-        nodes.Values |> Seq.filter (fun n -> n.Info.Deps.Length = 0) |> Seq.toArray
-
-    // printfn $"Node count: {nodes.Count}"
-
-    let work (node: Node3<'Item>) : Node3<'Item>[] =
-        let _deps = lookupMany node.Info.Deps
-        // printfn $"{node.Info.Item} DoWork"
-        doWork node.Info.Item
-        // printfn $"{node.Info.Item} DoneWork"
-        // Need to double-check that only one dependency schedules this dependant
-        let unblocked =
-            node.Info.Dependants
-            |> lookupMany
-            |> Array.filter (fun x ->
-                let pdc =
-                    // TODO Not ideal, better ways most likely exist
-                    lock x (fun () ->
-                        x.ProcessedDepsCount <- x.ProcessedDepsCount + 1
-                        x.ProcessedDepsCount)
-
-                pdc = x.Info.Deps.Length)
-        // printfn $"{node.Info.Item} unblocked gathered"
-        unblocked
-
-    use cts = new CancellationTokenSource()
-
-    Parallel.processInParallel
-        leaves
-        work
-        parallelism
-        (fun processedCount -> processedCount = nodes.Count)
-        cts.Token
-        (fun x -> x.Info.Item.ToString())
diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index 3caf45ff8e2..c2c77745b52 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -7,7 +7,6 @@ open System.Diagnostics
 open System.IO
 open System.Threading
 open FSharp.Compiler.Service.Driver
-open FSharp.Compiler.Service.Driver.OptimizeTypes
 open Internal.Utilities.Library
 open FSharp.Compiler
 open FSharp.Compiler.AbstractIL.IL
@@ -53,227 +52,288 @@ let GetInitialOptimizationEnv (tcImports: TcImports, tcGlobals: TcGlobals) =
     let optEnv = List.fold (AddExternalCcuToOptimizationEnv tcGlobals) optEnv ccuinfos
     optEnv
 
-let collectResults (inputs: CollectorInputs) : CollectorOutputs =
-    let files =
-        inputs
-        |> Array.map
-            (fun {
-                     Phase1 = phase1
-                     Phase2 = _phase2
-                     Phase3 = phase3
-                 } ->
-                let (_, _, implFileOptData, _), optimizeDuringCodeGen = phase1
-                let _, implFile = phase3
-
-                let implFile =
-                    {
-                        ImplFile = implFile
-                        OptimizeDuringCodeGen = optimizeDuringCodeGen
-                    }
+[<RequireQualifiedAccess>]
+module private ParallelOptimization =
 
-                implFile, implFileOptData)
+    open Optimizer
 
-    let lastFilePhase1Env =
-        inputs
-        |> Array.last
-        |> fun { Phase1 = phase1 } ->
-            let (optEnvPhase1, _, _, _), _ = phase1
-            optEnvPhase1
+    type OptimizeDuringCodeGen = bool -> Expr -> Expr
 
-    files, lastFilePhase1Env
+    type OptimizeRes =
+        (IncrementalOptimizationEnv * CheckedImplFile * ImplFileOptimizationInfo * SignatureHidingInfo) * OptimizeDuringCodeGen
 
-type Phase =
-    | Phase1
-    | Phase2
-    | Phase3
+    type PhaseInputs = IncrementalOptimizationEnv * SignatureHidingInfo * CheckedImplFile
 
-type FilePhaseFuncs = Phase1Fun * Phase2Fun * Phase3Fun
+    type Phase1Inputs = PhaseInputs
+    type Phase1Res = OptimizeRes
+    type Phase1Fun = Phase1Inputs -> Phase1Res
 
-type FileResults =
-    {
-        mutable Phase1: Phase1Res option
-        mutable Phase2: Phase2Res option
-        mutable Phase3: Phase3Res option
-    }
+    type Phase2Inputs = IncrementalOptimizationEnv * SignatureHidingInfo * ImplFileOptimizationInfo * CheckedImplFile
+    type Phase2Res = IncrementalOptimizationEnv * CheckedImplFile
+    type Phase2Fun = Phase2Inputs -> Phase2Res
 
-    member this.HasResult(phase: Phase) =
-        match phase with
-        | Phase.Phase1 -> this.Phase1 |> Option.isSome
-        | Phase.Phase2 -> this.Phase2 |> Option.isSome
-        | Phase.Phase3 -> this.Phase3 |> Option.isSome
+    type Phase3Inputs = PhaseInputs
+    type Phase3Res = IncrementalOptimizationEnv * CheckedImplFile
+    type Phase3Fun = Phase3Inputs -> Phase3Res
 
-    static member Empty =
+    type FileResultsComplete =
         {
-            Phase1 = None
-            Phase2 = None
-            Phase3 = None
+            Phase1: Phase1Res
+            Phase2: Phase2Res
+            Phase3: Phase3Res
         }
 
-type WorkItem =
-    | Phase1 of Phase1Inputs
-    | Phase2 of Phase2Inputs
-    | Phase3 of Phase3Inputs
+    type CollectorInputs = FileResultsComplete[]
+    type CollectorOutputs = (CheckedImplFileAfterOptimization * Optimizer.ImplFileOptimizationInfo)[] * Optimizer.IncrementalOptimizationEnv
+
+    let collectResults (inputs: CollectorInputs) : CollectorOutputs =
+        let files =
+            inputs
+            |> Array.map
+                (fun {
+                         Phase1 = phase1
+                         Phase2 = _phase2
+                         Phase3 = phase3
+                     } ->
+                    let (_, _, implFileOptData, _), optimizeDuringCodeGen = phase1
+                    let _, implFile = phase3
+
+                    let implFile =
+                        {
+                            ImplFile = implFile
+                            OptimizeDuringCodeGen = optimizeDuringCodeGen
+                        }
 
-type Idx = int
+                    implFile, implFileOptData)
 
-type Node =
-    {
-        Idx: Idx
-        Phase: Phase
-    }
+        let lastFilePhase1Env =
+            inputs
+            |> Array.last
+            |> fun { Phase1 = phase1 } ->
+                let (optEnvPhase1, _, _, _), _ = phase1
+                optEnvPhase1
 
-    override this.ToString() = $"[{this.Idx}-{this.Phase}]"
+        files, lastFilePhase1Env
 
-let getPhase1Res (p: FileResults) =
-    p.Phase1 |> Option.get |> (fun ((env, _, _, hidden), _) -> env, hidden)
+    [<RequireQualifiedAccess>]
+    type OptimizationPhase =
+        | Phase1
+        | Phase2
+        | Phase3
 
-let getPhase2Res (p: FileResults) = p.Phase2 |> Option.get
+    type FilePhaseFuncs = Phase1Fun * Phase2Fun * Phase3Fun
 
-let getPhase3Res (p: FileResults) =
-    p.Phase3 |> Option.get |> (fun (env, _) -> env)
+    type FileResults =
+        {
+            mutable Phase1: Phase1Res option
+            mutable Phase2: Phase2Res option
+            mutable Phase3: Phase3Res option
+        }
+
+        member this.HasResult(phase: OptimizationPhase) =
+            match phase with
+            | OptimizationPhase.Phase1 -> this.Phase1 |> Option.isSome
+            | OptimizationPhase.Phase2 -> this.Phase2 |> Option.isSome
+            | OptimizationPhase.Phase3 -> this.Phase3 |> Option.isSome
+
+        static member Empty =
+            {
+                Phase1 = None
+                Phase2 = None
+                Phase3 = None
+            }
+
+    type Node =
+        {
+            Idx: int
+            Phase: OptimizationPhase
+        }
 
-let optimizeFilesInParallel
-    (env0: Optimizer.IncrementalOptimizationEnv)
-    ((phase1, phase2, phase3): FilePhaseFuncs)
-    (files: CheckedImplFile list)
-    : CollectorOutputs =
-    let files = files |> List.toArray
-    // Schedule File1-Phase1
-    let firstNode = { Idx = 0; Phase = Phase.Phase1 }
+        override this.ToString() = $"[{this.Idx}-{this.Phase}]"
 
-    let results = files |> Array.map (fun _ -> FileResults.Empty)
+    let getPhase1Res (p: FileResults) =
+        p.Phase1 |> Option.get |> (fun ((env, _, _, hidden), _) -> env, hidden)
 
-    let _lock = obj ()
+    let getPhase2Res (p: FileResults) = p.Phase2 |> Option.get
 
-    let nodeCanBeProcessed { Idx = idx; Phase = phase } : bool =
-        lock (_lock) (fun () ->
-            let previousFileReady = if idx = 0 then true else results[ idx - 1 ].HasResult phase
+    let getPhase3Res (p: FileResults) =
+        p.Phase3 |> Option.get |> (fun (env, _) -> env)
 
+    let optimizeFilesInParallel
+        (env0: IncrementalOptimizationEnv)
+        ((phase1, phase2, phase3): FilePhaseFuncs)
+        (files: CheckedImplFile list)
+        (ct: CancellationToken)
+        : CollectorOutputs =
+        let files = files |> List.toArray
+
+        let firstNode =
+            {
+                Idx = 0
+                Phase = OptimizationPhase.Phase1
+            }
+
+        let results = files |> Array.map (fun _ -> FileResults.Empty)
+
+        let _lock = obj ()
+
+        let nodeCanBeProcessed { Idx = idx; Phase = phase } : bool =
             let previousPhase =
                 match phase with
-                | Phase.Phase1 -> None
-                | Phase.Phase2 -> Some Phase.Phase1
-                | Phase.Phase3 -> Some Phase.Phase2
+                | OptimizationPhase.Phase1 -> None
+                | OptimizationPhase.Phase2 -> Some OptimizationPhase.Phase1
+                | OptimizationPhase.Phase3 -> Some OptimizationPhase.Phase2
 
-            let previousPhaseReady =
-                match previousPhase with
-                | Some previousPhase -> results[ idx ].HasResult previousPhase
-                | None -> true
+            lock _lock (fun () ->
+                let previousFileReady = if idx = 0 then true else results[ idx - 1 ].HasResult phase
 
-            previousFileReady && previousPhaseReady)
+                let previousPhaseReady =
+                    match previousPhase with
+                    | Some previousPhase -> results[ idx ].HasResult previousPhase
+                    | None -> true
 
-    let visited = HashSet<Node>()
+                previousFileReady && previousPhaseReady)
 
-    let worker ({ Idx = idx; Phase = phase } as node: Node) : Node[] =
-        let notPreviouslyVisited = lock (_lock) (fun () -> visited.Add node)
+        let visited = HashSet<Node>()
 
-        if notPreviouslyVisited = false then
-            [||]
-        else
-            let res = results[idx]
-            let file = files[idx]
-            let previous = if idx > 0 then Some results[idx - 1] else None
-            let hidingInfo0 = SignatureHidingInfo.Empty
+        let worker ({ Idx = idx; Phase = phase } as node: Node) : Node[] =
+            let notPreviouslyVisited = lock _lock (fun () -> visited.Add node)
+
+            if notPreviouslyVisited = false then
+                [||]
+            else
+                let res = results[idx]
+                let file = files[idx]
+                let previous = if idx > 0 then Some results[idx - 1] else None
+                let hidingInfo0 = SignatureHidingInfo.Empty
 
-            let getPhase1Res (p: FileResults) =
-                p.Phase1
-                |> Option.get
-                |> fun ((env, file, info, hidden), _) -> env, file, info, hidden
+                let getPhase1Res (p: FileResults) =
+                    p.Phase1
+                    |> Option.get
+                    |> fun ((env, file, info, hidden), _) -> env, file, info, hidden
 
-            match phase with
-            | Phase.Phase1 ->
-                // take env from previous file
-                let env, hidingInfo =
-                    previous
-                    |> Option.map getPhase1Res
-                    |> Option.map (fun (a, _b, _c, d) -> a, d)
-                    |> Option.defaultValue (env0, hidingInfo0)
-
-                let inputs = env, hidingInfo, file
-                let phase1Res = phase1 inputs
-                res.Phase1 <- Some phase1Res
-
-                // Schedule Phase2
-                let phase2Node = { Idx = idx; Phase = Phase.Phase2 }
-
-                seq {
-                    yield phase2Node
-
-                    if idx < files.Length - 1 then
-                        yield { Idx = idx + 1; Phase = Phase.Phase1 }
-                }
-                |> Seq.toArray
-
-            | Phase.Phase2 ->
-                // take env from previous file
-                let env =
-                    previous
-                    |> Option.map getPhase2Res
-                    |> Option.map fst
-                    |> Option.defaultValue env0
-
-                let file, info, hidingInfo = res |> getPhase1Res |> (fun (_a, b, c, d) -> b, c, d)
-                let inputs = env, hidingInfo, info, file
-                let phase2Res = phase2 inputs
-                res.Phase2 <- Some phase2Res
-
-                seq {
-                    // Schedule Phase3
-                    let phase3Node = { Idx = idx; Phase = Phase.Phase3 }
-                    yield phase3Node
-                    // Schedule Phase2 for the next file if it exists
-                    if idx < files.Length - 1 then
-                        yield { Idx = idx + 1; Phase = Phase.Phase2 }
-                }
-                |> Seq.toArray
-
-            | Phase.Phase3 ->
-                // take env from previous file
-                let env = previous |> Option.map getPhase3Res |> Option.defaultValue env0
-                // impl file
-                let _, file = res |> getPhase2Res
-                let hidingInfo = res |> getPhase1Res |> (fun (_a, _b, _c, d) -> d)
-                let inputs = env, hidingInfo, file
-                let phase3Res = phase3 inputs
-                res.Phase3 <- Some phase3Res
-
-                seq {
-                    // Schedule Phase3 for the next file if it exists
-                    if idx < files.Length - 1 then
-                        yield { Idx = idx + 1; Phase = Phase.Phase3 }
-                }
-                |> Seq.toArray
-            |> fun nodes -> nodes |> Array.filter nodeCanBeProcessed
-
-    Parallel.processInParallel
-        [| firstNode |]
-        worker
-        10
-        (fun _ -> visited.Count >= files.Length * 3)
-        (CancellationToken.None)
-        (fun node -> node.ToString())
-
-    Debug.Assert(visited.Count = files.Length * 3)
-
-    let results =
-        results
-        |> Array.mapi
-            (fun i {
-                       Phase1 = phase1
-                       Phase2 = phase2
-                       Phase3 = phase3
-                   } ->
-                match phase1, phase2, phase3 with
-                | Some phase1, Some phase2, Some phase3 ->
-                    {
-                        FileResultsComplete.Phase1 = phase1
-                        Phase2 = phase2
-                        Phase3 = phase3
+                match phase with
+                | OptimizationPhase.Phase1 ->
+                    // Take env from the previous file
+                    let env, hidingInfo =
+                        previous
+                        |> Option.map getPhase1Res
+                        |> Option.map (fun (a, _b, _c, d) -> a, d)
+                        |> Option.defaultValue (env0, hidingInfo0)
+
+                    let inputs = env, hidingInfo, file
+                    let phase1Res = phase1 inputs
+                    res.Phase1 <- Some phase1Res
+
+                    let phase2Node =
+                        {
+                            Idx = idx
+                            Phase = OptimizationPhase.Phase2
+                        }
+
+                    seq {
+                        // Schedule Phase2 for the current file
+                        yield phase2Node
+                        // Schedule Phase1 for the next file if it exists
+                        if idx < files.Length - 1 then
+                            yield
+                                {
+                                    Idx = idx + 1
+                                    Phase = OptimizationPhase.Phase1
+                                }
                     }
-                | _ -> failwith $"Unexpected lack of results for file [{i}]")
+                    |> Seq.toArray
+
+                | OptimizationPhase.Phase2 ->
+                    // Take env from previous file if it exists
+                    let env =
+                        previous
+                        |> Option.map getPhase2Res
+                        |> Option.map fst
+                        |> Option.defaultValue env0
+
+                    // Take impl file from Phase1
+                    let file, info, hidingInfo =
+                        res
+                        |> getPhase1Res
+                        |> (fun (_, file, optimizationInfo, hidingInfo) -> file, optimizationInfo, hidingInfo)
+
+                    let inputs = env, hidingInfo, info, file
+                    let phase2Res = phase2 inputs
+                    res.Phase2 <- Some phase2Res
+
+                    let phase3Node =
+                        {
+                            Idx = idx
+                            Phase = OptimizationPhase.Phase3
+                        }
+
+                    seq {
+                        // Schedule Phase3 for the current file
+                        yield phase3Node
+                        // Schedule Phase2 for the next file if it exists
+                        if idx < files.Length - 1 then
+                            yield
+                                {
+                                    Idx = idx + 1
+                                    Phase = OptimizationPhase.Phase2
+                                }
+                    }
+                    |> Seq.toArray
+
+                | OptimizationPhase.Phase3 ->
+                    // Take env from previous file if it exists
+                    let env = previous |> Option.map getPhase3Res |> Option.defaultValue env0
+
+                    // Take impl file from Phase2
+                    let _, file = res |> getPhase2Res
+                    let hidingInfo = res |> getPhase1Res |> (fun (_, _, _, hidingInfo) -> hidingInfo)
+                    let inputs = env, hidingInfo, file
+                    let phase3Res = phase3 inputs
+                    res.Phase3 <- Some phase3Res
+
+                    seq {
+                        // Schedule Phase3 for the next file if it exists
+                        if idx < files.Length - 1 then
+                            yield
+                                {
+                                    Idx = idx + 1
+                                    Phase = OptimizationPhase.Phase3
+                                }
+                    }
+                    |> Seq.toArray
+                |> fun nodes -> nodes |> Array.filter nodeCanBeProcessed
+
+        Parallel.processInParallel
+            "OptimizeInputs"
+            [| firstNode |]
+            worker
+            10
+            (fun () -> visited.Count >= files.Length * 3)
+            ct
+            (fun node -> node.ToString())
+
+        Debug.Assert(visited.Count = files.Length * 3)
+
+        let results =
+            results
+            |> Array.mapi
+                (fun i {
+                           Phase1 = phase1
+                           Phase2 = phase2
+                           Phase3 = phase3
+                       } ->
+                    match phase1, phase2, phase3 with
+                    | Some phase1, Some phase2, Some phase3 ->
+                        {
+                            FileResultsComplete.Phase1 = phase1
+                            Phase2 = phase2
+                            Phase3 = phase3
+                        }
+                    | _ -> failwith $"Unexpected lack of results for file [{i}]")
 
-    let collected = results |> collectResults
-    collected
+        let collected = results |> collectResults
+        collected
 
 let ApplyAllOptimizations
     (
@@ -301,28 +361,28 @@ let ApplyAllOptimizations
         dprintf "CCU prior to optimization:\n%s\n" (LayoutRender.showL (Display.squashTo 192 (DebugPrint.entityL ccu.Contents)))
 #endif
 
-    let optEnv0 = optEnv
     ReportTime tcConfig "Optimizations"
 
-    // Only do abstract_big_targets on the first pass!  Only do it when TLR is on!
-    let optSettings = tcConfig.optSettings
-
-    let optSettings =
-        { optSettings with
+    let phase1Settings =
+        { tcConfig.optSettings with
+            // Only do abstractBigTargets in the first phase, and only when TLR is on.
             abstractBigTargets = tcConfig.doTLR
+            reportingPhase = true
         }
 
-    let optSettings =
-        { optSettings with
-            reportingPhase = true
+    // Only do these two steps in the first phase.
+    let phase2And3Settings =
+        { phase1Settings with
+            abstractBigTargets = false
+            reportingPhase = false
         }
 
-    let env0 = optEnv0
+    let phase1 (env: Optimizer.IncrementalOptimizationEnv, hidden: SignatureHidingInfo, implFile: CheckedImplFile) =
+        use _ =
+            FSharp.Compiler.Diagnostics.Activity.start "phase1" [| "QualifiedNameOfFile", implFile.QualifiedNameOfFile.Text |]
 
-    let phase1 (env: Optimizer.IncrementalOptimizationEnv, hidden: SignatureHidingInfo, implFile: CheckedImplFile) : Phase1Res =
-        //ReportTime tcConfig ("Initial simplify")
         Optimizer.OptimizeImplFile(
-            optSettings,
+            phase1Settings,
             ccu,
             tcGlobals,
             tcVal,
@@ -339,33 +399,18 @@ let ApplyAllOptimizations
         (
             env: Optimizer.IncrementalOptimizationEnv,
             hidden: SignatureHidingInfo,
-            implFileOptData: Optimizer.ImplFileOptimizationInfo,
+            _implFileOptData: Optimizer.ImplFileOptimizationInfo,
             implFile: CheckedImplFile
-        ) : Phase2Res =
-        let implFile = LowerLocalMutables.TransformImplFile tcGlobals importMap implFile
+        ) =
+        use _ =
+            FSharp.Compiler.Diagnostics.Activity.start "phase2" [| "QualifiedNameOfFile", implFile.QualifiedNameOfFile.Text |]
 
-        // Only do this on the first pass!
-        let optSettings =
-            { optSettings with
-                abstractBigTargets = false
-                reportingPhase = false
-            }
-#if DEBUG
-        if tcConfig.showOptimizationData then
-            dprintf
-                "Optimization implFileOptData:\n%s\n"
-                (LayoutRender.showL (Display.squashTo 192 (Optimizer.moduleInfoL tcGlobals implFileOptData)))
-#else
-        // Satisfy the compiler
-        implFileOptData |> ignore
-#endif
+        let implFile = LowerLocalMutables.TransformImplFile tcGlobals importMap implFile
 
         if tcConfig.extraOptimizationIterations > 0 then
-
-            //ReportTime tcConfig ("Extra simplification loop")
             let (optEnvExtraLoop, implFile, _, _), _ =
                 Optimizer.OptimizeImplFile(
-                    optSettings,
+                    phase2And3Settings,
                     ccu,
                     tcGlobals,
                     tcVal,
@@ -378,24 +423,17 @@ let ApplyAllOptimizations
                     implFile
                 )
 
-            //PrintWholeAssemblyImplementation tcConfig outfile (sprintf "extra-loop-%d" n) implFile
             optEnvExtraLoop, implFile
         else
             env, implFile
 
-    let phase3 (env: Optimizer.IncrementalOptimizationEnv, hidden: SignatureHidingInfo, implFile: CheckedImplFile) : Phase3Res =
-        // Only do this on the first pass!
-        let optSettings =
-            { optSettings with
-                abstractBigTargets = false
-                reportingPhase = false
-            }
+    let phase3 (env: Optimizer.IncrementalOptimizationEnv, hidden: SignatureHidingInfo, implFile: CheckedImplFile) =
+        use _ =
+            FSharp.Compiler.Diagnostics.Activity.start "phase3" [| "QualifiedNameOfFile", implFile.QualifiedNameOfFile.Text |]
 
         let implFile =
             if tcConfig.doDetuple then
-                //ReportTime tcConfig ("Detupled optimization")
                 let implFile = implFile |> Detuple.DetupleImplFile ccu tcGlobals
-                //PrintWholeAssemblyImplementation tcConfig outfile "post-detuple" implFile
                 implFile
             else
                 implFile
@@ -410,11 +448,9 @@ let ApplyAllOptimizations
         let implFile = LowerCalls.LowerImplFile tcGlobals implFile
 
         if tcConfig.doFinalSimplify then
-
-            //ReportTime tcConfig ("Final simplify pass")
             let (optEnvFinalSimplify, implFile, _, _), _ =
                 Optimizer.OptimizeImplFile(
-                    optSettings,
+                    phase2And3Settings,
                     ccu,
                     tcGlobals,
                     tcVal,
@@ -427,31 +463,30 @@ let ApplyAllOptimizations
                     implFile
                 )
 
-            //PrintWholeAssemblyImplementation tcConfig outfile "post-rec-opt" implFile
             optEnvFinalSimplify, implFile
         else
             env, implFile
 
     let results, optEnvFirstLoop =
-        match optSettings.processingMode with
+        match tcConfig.optSettings.processingMode with
         | Optimizer.OptimizerMode.PartiallyParallel ->
-            let a, b = optimizeFilesInParallel env0 (phase1, phase2, phase3) implFiles
+            let ct = CancellationToken.None
+
+            let a, b =
+                ParallelOptimization.optimizeFilesInParallel optEnv (phase1, phase2, phase3) implFiles ct
+
             a |> Array.toList, b
         | Optimizer.OptimizerMode.Sequential ->
             let results, (optEnvFirstLoop, _, _, _) =
-                ((optEnv0, optEnv0, optEnv0, SignatureHidingInfo.Empty), implFiles)
+                ((optEnv, optEnv, optEnv, SignatureHidingInfo.Empty), implFiles)
 
                 ||> List.mapFold (fun (optEnvFirstLoop, optEnvExtraLoop, optEnvFinalSimplify, hidden) implFile ->
-                    // Phase 1
-                    //ReportTime tcConfig ("Initial simplify")
                     let (optEnvFirstLoop, implFile, implFileOptData, hidden), optimizeDuringCodeGen =
                         phase1 (optEnvFirstLoop, hidden, implFile)
 
-                    // Phase 2
                     let optEnvExtraLoop, implFile =
                         phase2 (optEnvExtraLoop, hidden, implFileOptData, implFile)
 
-                    // Phase 3
                     let optEnvFinalSimplify, implFile = phase3 (optEnvFinalSimplify, hidden, implFile)
 
                     let implFile =
@@ -464,6 +499,16 @@ let ApplyAllOptimizations
 
             results, optEnvFirstLoop
 
+#if DEBUG
+    if tcConfig.showOptimizationData then
+        results
+        |> List.iter (fun (checkedImplFileAfterOptimization, implFileOptData) ->
+            let str =
+                (LayoutRender.showL (Display.squashTo 192 (Optimizer.moduleInfoL tcGlobals implFileOptData)))
+
+            dprintf $"Optimization implFileOptData:\n{str}\n")
+#endif
+
     let implFiles, implFileOptDatas = List.unzip results
     let assemblyOptData = Optimizer.UnionOptimizationInfos implFileOptDatas
     let tassembly = CheckedAssemblyAfterOptimization implFiles
diff --git a/src/Compiler/Driver/OptimizeInputs.fsi b/src/Compiler/Driver/OptimizeInputs.fsi
index 6876e1ce68e..d5c731ba05d 100644
--- a/src/Compiler/Driver/OptimizeInputs.fsi
+++ b/src/Compiler/Driver/OptimizeInputs.fsi
@@ -12,8 +12,6 @@ open FSharp.Compiler.Import
 open FSharp.Compiler.Optimizer
 open FSharp.Compiler.TcGlobals
 open FSharp.Compiler.TypedTree
-open System.Collections.Generic
-open FSharp.Compiler.Service.Driver.OptimizeTypes
 
 val GetGeneratedILModuleName: CompilerTarget -> string -> string
 
diff --git a/src/Compiler/Driver/OptimizeTypes.fs b/src/Compiler/Driver/OptimizeTypes.fs
deleted file mode 100644
index 2b56baa0c48..00000000000
--- a/src/Compiler/Driver/OptimizeTypes.fs
+++ /dev/null
@@ -1,80 +0,0 @@
-module internal FSharp.Compiler.Service.Driver.OptimizeTypes
-
-open FSharp.Compiler
-open FSharp.Compiler.Optimizer
-open FSharp.Compiler.TcGlobals
-open FSharp.Compiler.TypedTree
-open FSharp.Compiler.TypedTreeOps
-
-type OptimizeDuringCodeGen = bool -> Expr -> Expr
-type OptimizeRes = (IncrementalOptimizationEnv * CheckedImplFile * ImplFileOptimizationInfo * SignatureHidingInfo) * OptimizeDuringCodeGen
-
-type Optimize =
-    OptimizationSettings * CcuThunk * TcGlobals * ConstraintSolver.TcValF * Import.ImportMap * IncrementalOptimizationEnv * bool * bool * bool * SignatureHidingInfo * CheckedImplFile -> OptimizeRes
-
-type PhaseInputs = IncrementalOptimizationEnv * SignatureHidingInfo * CheckedImplFile
-
-type Phase1Inputs = PhaseInputs
-type Phase1Res = OptimizeRes
-type Phase1Fun = Phase1Inputs -> Phase1Res
-
-type Phase2Inputs = IncrementalOptimizationEnv * SignatureHidingInfo * ImplFileOptimizationInfo * CheckedImplFile
-type Phase2Res = IncrementalOptimizationEnv * CheckedImplFile
-type Phase2Fun = Phase2Inputs -> Phase2Res
-
-type Phase3Inputs = PhaseInputs
-type Phase3Res = IncrementalOptimizationEnv * CheckedImplFile
-type Phase3Fun = Phase3Inputs -> Phase3Res
-
-type Phase =
-    | Phase1
-    | Phase2
-    | Phase3
-
-module Phase =
-    let all = [| Phase1; Phase2; Phase3 |]
-
-    let prev (phase: Phase) =
-        match phase with
-        | Phase1 -> None
-        | Phase2 -> Some Phase1
-        | Phase3 -> Some Phase2
-
-    let next (phase: Phase) =
-        match phase with
-        | Phase1 -> Some Phase2
-        | Phase2 -> Some Phase3
-        | Phase3 -> None
-
-type PhaseRes =
-    | Phase1 of Phase1Res
-    | Phase2 of Phase2Res
-    | Phase3 of Phase3Res
-
-    member x.Which =
-        match x with
-        | Phase1 _ -> Phase.Phase1
-        | Phase2 _ -> Phase.Phase2
-        | Phase3 _ -> Phase.Phase3
-
-    member x.Get1() =
-        match x with
-        | Phase1 x -> x
-        | Phase2 _
-        | Phase3 _ -> failwith $"Called {nameof (x.Get1)} but this is {x.Which}"
-
-    member x.Get2() =
-        match x with
-        | Phase2 x -> x
-        | Phase1 _
-        | Phase3 _ -> failwith $"Called {nameof (x.Get2)} but this is {x.Which}"
-
-type FileResultsComplete =
-    {
-        Phase1: Phase1Res
-        Phase2: Phase2Res
-        Phase3: Phase3Res
-    }
-
-type CollectorInputs = FileResultsComplete[]
-type CollectorOutputs = (CheckedImplFileAfterOptimization * ImplFileOptimizationInfo)[] * IncrementalOptimizationEnv
diff --git a/src/Compiler/Driver/Parallel.fs b/src/Compiler/Driver/Parallel.fs
index df19bd434d6..571849a65dd 100644
--- a/src/Compiler/Driver/Parallel.fs
+++ b/src/Compiler/Driver/Parallel.fs
@@ -2,52 +2,55 @@
 
 #nowarn "1182"
 
-open System
 open System.Collections.Concurrent
 open System.Threading
+open FSharp.Compiler.Diagnostics
+open Internal.Utilities.Library.Extras
 
-// TODO Could replace with MailboxProcessor+Tasks/Asyncs instead of BlockingCollection + Threads
-// See http://www.fssnip.net/nX/title/Limit-degree-of-parallelism-using-an-agent
+/// <summary>
 /// Process items in parallel, allow more work to be scheduled as a result of finished work,
-/// limit parallelisation to 'parallelism' threads
+/// limit parallelisation to 'parallelism' threads.
+/// </summary>
+/// <remarks>
+/// Could be replace with MailboxProcessor+Tasks/Asyncs instead of BlockingCollection + Threads.
+/// See http://www.fssnip.net/nX/title/Limit-degree-of-parallelism-using-an-agent for an example.
+/// </remarks>
 let processInParallel
+    (opName: string)
     (firstItems: 'Item[])
     (work: 'Item -> 'Item[])
     (parallelism: int)
-    (shouldStop: int -> bool)
+    (shouldStop: unit -> bool)
     (ct: CancellationToken)
     (_itemToString: 'Item -> string)
     : unit =
-    let bc = new BlockingCollection<'Item>()
-    firstItems |> Array.iter bc.Add
-    let processedCountLock = Object()
-    let mutable processedCount = 0
+
+    use _ =
+        Activity.start
+            $"processInParallel - {opName}"
+            [|
+                "firstItemsCount", firstItems.Length.ToString()
+                "parallelism", parallelism.ToString()
+            |]
+
+    let toProcess = new BlockingCollection<'Item>()
+    firstItems |> Array.iter toProcess.Add
 
     let processItem item =
         // printfn $"[{Thread.CurrentThread.ManagedThreadId}] Processing {_itemToString item}"
+        use _ = Activity.start "processItem" [| "item", _itemToString item |]
         let toSchedule = work item
-        // printfn $"[{Thread.CurrentThread.ManagedThreadId}] Finished {_itemToString item}"
-
-        let processedCount =
-            lock processedCountLock (fun () ->
-                processedCount <- processedCount + 1
-                processedCount)
-
-        // let toScheduleString =
-            // toSchedule |> Array.map _itemToString |> (fun names -> String.Join(", ", names))
 
+        // printfn $"[{Thread.CurrentThread.ManagedThreadId}] Finished {_itemToString item}"
         // printfn $"[{Thread.CurrentThread.ManagedThreadId}] Scheduling {toSchedule.Length} items: {toScheduleString}"
-        toSchedule |> Array.iter bc.Add
-        processedCount
+        toSchedule |> Array.iter toProcess.Add
 
-    // TODO Could avoid workers with some semaphores
-    let workerWork () : unit =
-        for node in bc.GetConsumingEnumerable(ct) do
-            if not ct.IsCancellationRequested then // improve
-                let processedCount = processItem node
+    let worker () : unit =
+        for node in toProcess.GetConsumingEnumerable(ct) do
+            if not ct.IsCancellationRequested then
+                processItem node
 
-                if shouldStop processedCount then
-                    bc.CompleteAdding()
+                if shouldStop () then
+                    toProcess.CompleteAdding()
 
-    // TODO Do we need to handle cancellation given that workers do it already?
-    Array.Parallel.map workerWork (Array.init parallelism (fun _ -> ())) |> ignore
+    ArrayParallel.iter worker (Array.create parallelism ())
diff --git a/src/Compiler/FSharp.Compiler.Service.fsproj b/src/Compiler/FSharp.Compiler.Service.fsproj
index 8be13652447..77a9b9f52ae 100644
--- a/src/Compiler/FSharp.Compiler.Service.fsproj
+++ b/src/Compiler/FSharp.Compiler.Service.fsproj
@@ -387,9 +387,6 @@
     <Compile Include="Driver\CompilerOptions.fsi" />
     <Compile Include="Driver\CompilerOptions.fs" />
     <Compile Include="Driver\Parallel.fs" />
-    <Compile Include="Driver\Graph.fs" />
-    <Compile Include="Driver\GraphProcessing.fs" />
-    <Compile Include="Driver\OptimizeTypes.fs" />
     <Compile Include="Driver\OptimizeInputs.fsi" />
     <Compile Include="Driver\OptimizeInputs.fs" />
     <Compile Include="Driver\XmlDocFileWriter.fsi" />
diff --git a/src/Compiler/Utilities/lib.fs b/src/Compiler/Utilities/lib.fs
index 95a20226a2d..d791bec524c 100755
--- a/src/Compiler/Utilities/lib.fs
+++ b/src/Compiler/Utilities/lib.fs
@@ -589,14 +589,17 @@ type DisposablesTracker() =
 module ArrayParallel =
 
     let inline iteri f (arr: 'T []) =
-        let parallelOptions = ParallelOptions(MaxDegreeOfParallelism = max (min Environment.ProcessorCount arr.Length) 1)
-        try
-            Parallel.For(0, arr.Length, parallelOptions, fun i ->
-                f i arr[i]
-            ) |> ignore
-        with
-        | :? AggregateException as ex when ex.InnerExceptions.Count = 1 ->
-            raise(ex.InnerExceptions[0])
+        match arr with
+        | [||] -> ()
+        | arr ->
+            let parallelOptions = ParallelOptions(MaxDegreeOfParallelism = Environment.ProcessorCount)
+            try
+                Parallel.For(0, arr.Length, parallelOptions, fun i ->
+                    f i arr[i]
+                ) |> ignore
+            with
+            | :? AggregateException as ex when ex.InnerExceptions.Count = 1 ->
+                raise(ex.InnerExceptions[0])
 
     let inline iter f (arr: 'T []) =
         arr |> iteri (fun _ item -> f item)

From 0627a4f4a0ff947ee8346a643c058aac7fb2817e Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Thu, 1 Dec 2022 22:34:43 +0000
Subject: [PATCH 12/42] Revert unneeded changes

---
 src/Compiler/Driver/ParseAndCheckInputs.fs  | 3 +--
 src/Compiler/Driver/ParseAndCheckInputs.fsi | 3 ---
 2 files changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/Compiler/Driver/ParseAndCheckInputs.fs b/src/Compiler/Driver/ParseAndCheckInputs.fs
index ba7e89b6341..ac36b76477c 100644
--- a/src/Compiler/Driver/ParseAndCheckInputs.fs
+++ b/src/Compiler/Driver/ParseAndCheckInputs.fs
@@ -1,5 +1,4 @@
 // Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information.
-// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information.
 
 /// Contains logic to coordinate the parsing and checking of one or a group of files
 module internal FSharp.Compiler.ParseAndCheckInputs
@@ -766,7 +765,7 @@ let ParseOneInputFile (tcConfig: TcConfig, lexResourceManager, fileName, isLastC
 /// NOTE: this needs to be improved to commit diagnotics as soon as possible
 ///
 /// NOTE: If StopProcessing is raised by any piece of work then the overall function raises StopProcessing.
-let UseMultipleDiagnosticLoggers ((inputs, diagnosticsLogger, eagerFormat): 'a list * DiagnosticsLogger * (PhasedDiagnostic -> PhasedDiagnostic) option) (f: ('a * CapturingDiagnosticsLogger) list -> 'b): 'b =
+let UseMultipleDiagnosticLoggers (inputs, diagnosticsLogger, eagerFormat) f =
 
     // Check input files and create delayed error loggers before we try to parallel parse.
     let delayLoggers =
diff --git a/src/Compiler/Driver/ParseAndCheckInputs.fsi b/src/Compiler/Driver/ParseAndCheckInputs.fsi
index e173d5a344b..166191d363e 100644
--- a/src/Compiler/Driver/ParseAndCheckInputs.fsi
+++ b/src/Compiler/Driver/ParseAndCheckInputs.fsi
@@ -133,9 +133,6 @@ type TcState =
 /// Get the initial type checking state for a set of inputs
 val GetInitialTcState: range * string * TcConfig * TcGlobals * TcImports * TcEnv * OpenDeclaration list -> TcState
 
-
-val UseMultipleDiagnosticLoggers : ('a list * DiagnosticsLogger * (PhasedDiagnostic -> PhasedDiagnostic) option) -> (('a * CapturingDiagnosticsLogger) list -> 'b) -> 'b
-
 /// Check one input, returned as an Eventually computation
 val CheckOneInput:
     checkForErrors: (unit -> bool) *

From 2093a73206a81634bb0b2d694a95814dcd0d651d Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Thu, 1 Dec 2022 22:51:33 +0000
Subject: [PATCH 13/42] Cleanup

---
 src/Compiler/Driver/OptimizeInputs.fs | 93 ++++++++++++---------------
 src/Compiler/Driver/Parallel.fs       |  2 +
 2 files changed, 43 insertions(+), 52 deletions(-)

diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index c2c77745b52..e5f15a0cc88 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -54,66 +54,27 @@ let GetInitialOptimizationEnv (tcImports: TcImports, tcGlobals: TcGlobals) =
 
 [<RequireQualifiedAccess>]
 module private ParallelOptimization =
-
     open Optimizer
-
     type OptimizeDuringCodeGen = bool -> Expr -> Expr
-
     type OptimizeRes =
         (IncrementalOptimizationEnv * CheckedImplFile * ImplFileOptimizationInfo * SignatureHidingInfo) * OptimizeDuringCodeGen
-
     type PhaseInputs = IncrementalOptimizationEnv * SignatureHidingInfo * CheckedImplFile
-
     type Phase1Inputs = PhaseInputs
     type Phase1Res = OptimizeRes
     type Phase1Fun = Phase1Inputs -> Phase1Res
-
     type Phase2Inputs = IncrementalOptimizationEnv * SignatureHidingInfo * ImplFileOptimizationInfo * CheckedImplFile
     type Phase2Res = IncrementalOptimizationEnv * CheckedImplFile
     type Phase2Fun = Phase2Inputs -> Phase2Res
-
     type Phase3Inputs = PhaseInputs
     type Phase3Res = IncrementalOptimizationEnv * CheckedImplFile
     type Phase3Fun = Phase3Inputs -> Phase3Res
-
     type FileResultsComplete =
         {
             Phase1: Phase1Res
             Phase2: Phase2Res
             Phase3: Phase3Res
         }
-
-    type CollectorInputs = FileResultsComplete[]
-    type CollectorOutputs = (CheckedImplFileAfterOptimization * Optimizer.ImplFileOptimizationInfo)[] * Optimizer.IncrementalOptimizationEnv
-
-    let collectResults (inputs: CollectorInputs) : CollectorOutputs =
-        let files =
-            inputs
-            |> Array.map
-                (fun {
-                         Phase1 = phase1
-                         Phase2 = _phase2
-                         Phase3 = phase3
-                     } ->
-                    let (_, _, implFileOptData, _), optimizeDuringCodeGen = phase1
-                    let _, implFile = phase3
-
-                    let implFile =
-                        {
-                            ImplFile = implFile
-                            OptimizeDuringCodeGen = optimizeDuringCodeGen
-                        }
-
-                    implFile, implFileOptData)
-
-        let lastFilePhase1Env =
-            inputs
-            |> Array.last
-            |> fun { Phase1 = phase1 } ->
-                let (optEnvPhase1, _, _, _), _ = phase1
-                optEnvPhase1
-
-        files, lastFilePhase1Env
+    type FilePhaseFuncs = Phase1Fun * Phase2Fun * Phase3Fun
 
     [<RequireQualifiedAccess>]
     type OptimizationPhase =
@@ -121,8 +82,6 @@ module private ParallelOptimization =
         | Phase2
         | Phase3
 
-    type FilePhaseFuncs = Phase1Fun * Phase2Fun * Phase3Fun
-
     type FileResults =
         {
             mutable Phase1: Phase1Res option
@@ -148,11 +107,36 @@ module private ParallelOptimization =
             Idx: int
             Phase: OptimizationPhase
         }
-
         override this.ToString() = $"[{this.Idx}-{this.Phase}]"
 
-    let getPhase1Res (p: FileResults) =
-        p.Phase1 |> Option.get |> (fun ((env, _, _, hidden), _) -> env, hidden)
+    let collectResults (inputs: FileResultsComplete[]) : (CheckedImplFileAfterOptimization * ImplFileOptimizationInfo)[] * IncrementalOptimizationEnv =
+        let files =
+            inputs
+            |> Array.map
+                (fun {
+                         Phase1 = phase1
+                         Phase2 = _phase2
+                         Phase3 = phase3
+                     } ->
+                    let (_, _, implFileOptData, _), optimizeDuringCodeGen = phase1
+                    let _, implFile = phase3
+
+                    let implFile =
+                        {
+                            ImplFile = implFile
+                            OptimizeDuringCodeGen = optimizeDuringCodeGen
+                        }
+
+                    implFile, implFileOptData)
+
+        let lastFilePhase1Env =
+            inputs
+            |> Array.last
+            |> fun { Phase1 = phase1 } ->
+                let (optEnvPhase1, _, _, _), _ = phase1
+                optEnvPhase1
+
+        files, lastFilePhase1Env
 
     let getPhase2Res (p: FileResults) = p.Phase2 |> Option.get
 
@@ -164,7 +148,7 @@ module private ParallelOptimization =
         ((phase1, phase2, phase3): FilePhaseFuncs)
         (files: CheckedImplFile list)
         (ct: CancellationToken)
-        : CollectorOutputs =
+        : (CheckedImplFileAfterOptimization * ImplFileOptimizationInfo)[] * IncrementalOptimizationEnv =
         let files = files |> List.toArray
 
         let firstNode =
@@ -283,7 +267,11 @@ module private ParallelOptimization =
 
                 | OptimizationPhase.Phase3 ->
                     // Take env from previous file if it exists
-                    let env = previous |> Option.map getPhase3Res |> Option.defaultValue env0
+                    let env =
+                        match previous with
+                        | None -> env0
+                        | Some {Phase3 = Some (env, _)} -> env
+                        | Some {Phase3 = None} -> failwith $"Unexpected lack of results for previous file [{idx-1}], phase 3"
 
                     // Take impl file from Phase2
                     let _, file = res |> getPhase2Res
@@ -313,7 +301,7 @@ module private ParallelOptimization =
             ct
             (fun node -> node.ToString())
 
-        Debug.Assert(visited.Count = files.Length * 3)
+        Debug.Assert(visited.Count = files.Length * 3, $"Expected to have visited all {files.Length} * 3 = {files.Length * 3} optimization nodes, but visited {visited.Count}")
 
         let results =
             results
@@ -330,7 +318,7 @@ module private ParallelOptimization =
                             Phase2 = phase2
                             Phase3 = phase3
                         }
-                    | _ -> failwith $"Unexpected lack of results for file [{i}]")
+                    | _ -> failwith $"Unexpected lack of optimization results for file [{i}]")
 
         let collected = results |> collectResults
         collected
@@ -472,10 +460,10 @@ let ApplyAllOptimizations
         | Optimizer.OptimizerMode.PartiallyParallel ->
             let ct = CancellationToken.None
 
-            let a, b =
+            let results, optEnvFirstPhase =
                 ParallelOptimization.optimizeFilesInParallel optEnv (phase1, phase2, phase3) implFiles ct
 
-            a |> Array.toList, b
+            results |> Array.toList, optEnvFirstPhase
         | Optimizer.OptimizerMode.Sequential ->
             let results, (optEnvFirstLoop, _, _, _) =
                 ((optEnv, optEnv, optEnv, SignatureHidingInfo.Empty), implFiles)
@@ -502,7 +490,8 @@ let ApplyAllOptimizations
 #if DEBUG
     if tcConfig.showOptimizationData then
         results
-        |> List.iter (fun (checkedImplFileAfterOptimization, implFileOptData) ->
+        |> List.map snd
+        |> List.iter (fun implFileOptData ->
             let str =
                 (LayoutRender.showL (Display.squashTo 192 (Optimizer.moduleInfoL tcGlobals implFileOptData)))
 
diff --git a/src/Compiler/Driver/Parallel.fs b/src/Compiler/Driver/Parallel.fs
index 571849a65dd..1277eb39441 100644
--- a/src/Compiler/Driver/Parallel.fs
+++ b/src/Compiler/Driver/Parallel.fs
@@ -2,6 +2,7 @@
 
 #nowarn "1182"
 
+open System
 open System.Collections.Concurrent
 open System.Threading
 open FSharp.Compiler.Diagnostics
@@ -53,4 +54,5 @@ let processInParallel
                 if shouldStop () then
                     toProcess.CompleteAdding()
 
+    let parallelism = min parallelism Environment.ProcessorCount
     ArrayParallel.iter worker (Array.create parallelism ())

From c739b4ea0dd36acfed14aae2f61e16c0aab7b759 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Thu, 1 Dec 2022 23:01:36 +0000
Subject: [PATCH 14/42] Cleanup

---
 src/Compiler/Driver/CompilerOptions.fs                |  2 +-
 src/Compiler/Driver/OptimizeInputs.fs                 |  7 +++----
 src/Compiler/Driver/fsc.fs                            |  4 ----
 src/Compiler/FSharp.Compiler.Service.fsproj           |  2 +-
 src/Compiler/Optimize/Optimizer.fs                    | 11 +++++++----
 src/Compiler/Optimize/Optimizer.fsi                   |  4 ++--
 .../Parallel.fs => Utilities/ParallelProcessing.fs}   |  2 +-
 7 files changed, 15 insertions(+), 17 deletions(-)
 rename src/Compiler/{Driver/Parallel.fs => Utilities/ParallelProcessing.fs} (96%)

diff --git a/src/Compiler/Driver/CompilerOptions.fs b/src/Compiler/Driver/CompilerOptions.fs
index 885e74fa2e5..997b2774797 100644
--- a/src/Compiler/Driver/CompilerOptions.fs
+++ b/src/Compiler/Driver/CompilerOptions.fs
@@ -1392,7 +1392,7 @@ let testFlag tcConfigB =
             | "PartiallyParallelOptimization" ->
                 tcConfigB.optSettings <-
                     { tcConfigB.optSettings with
-                        processingMode = OptimizerMode.PartiallyParallel
+                        processingMode = OptimizationProcessingMode.PartiallyParallel
                     }
 #if DEBUG
             | "ShowParserStackOnParseError" -> showParserStackOnParseError <- true
diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index e5f15a0cc88..c70e824ce71 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -6,7 +6,6 @@ open System.Collections.Generic
 open System.Diagnostics
 open System.IO
 open System.Threading
-open FSharp.Compiler.Service.Driver
 open Internal.Utilities.Library
 open FSharp.Compiler
 open FSharp.Compiler.AbstractIL.IL
@@ -292,7 +291,7 @@ module private ParallelOptimization =
                     |> Seq.toArray
                 |> fun nodes -> nodes |> Array.filter nodeCanBeProcessed
 
-        Parallel.processInParallel
+        FSharp.Compiler.Service.Utilities.ParallelProcessing.processInParallel
             "OptimizeInputs"
             [| firstNode |]
             worker
@@ -457,14 +456,14 @@ let ApplyAllOptimizations
 
     let results, optEnvFirstLoop =
         match tcConfig.optSettings.processingMode with
-        | Optimizer.OptimizerMode.PartiallyParallel ->
+        | Optimizer.OptimizationProcessingMode.PartiallyParallel ->
             let ct = CancellationToken.None
 
             let results, optEnvFirstPhase =
                 ParallelOptimization.optimizeFilesInParallel optEnv (phase1, phase2, phase3) implFiles ct
 
             results |> Array.toList, optEnvFirstPhase
-        | Optimizer.OptimizerMode.Sequential ->
+        | Optimizer.OptimizationProcessingMode.Sequential ->
             let results, (optEnvFirstLoop, _, _, _) =
                 ((optEnv, optEnv, optEnv, SignatureHidingInfo.Empty), implFiles)
 
diff --git a/src/Compiler/Driver/fsc.fs b/src/Compiler/Driver/fsc.fs
index 96647409565..e8ec56fa5a5 100644
--- a/src/Compiler/Driver/fsc.fs
+++ b/src/Compiler/Driver/fsc.fs
@@ -532,7 +532,6 @@ let main1
 
     // Process command line, flags and collect filenames
     let sourceFiles =
-
         // The ParseCompilerOptions function calls imperative function to process "real" args
         // Rather than start processing, just collect names, then process them.
         try
@@ -710,7 +709,6 @@ let main2
            exiter: Exiter,
            ilSourceDocs))
     =
-
     if tcConfig.typeCheckOnly then
         exiter.Exit 0
 
@@ -818,7 +816,6 @@ let main3
            exiter: Exiter,
            ilSourceDocs))
     =
-
     // Encode the signature data
     ReportTime tcConfig "Encode Interface Data"
     let exportRemapping = MakeExportRemapping generatedCcu generatedCcu.Contents
@@ -914,7 +911,6 @@ let main4
            exiter: Exiter,
            ilSourceDocs))
     =
-
     match tcImportsCapture with
     | None -> ()
     | Some f -> f tcImports
diff --git a/src/Compiler/FSharp.Compiler.Service.fsproj b/src/Compiler/FSharp.Compiler.Service.fsproj
index 77a9b9f52ae..f9cf0db5fc8 100644
--- a/src/Compiler/FSharp.Compiler.Service.fsproj
+++ b/src/Compiler/FSharp.Compiler.Service.fsproj
@@ -134,6 +134,7 @@
     <Compile Include="Utilities\RidHelpers.fs" />
     <Compile Include="Utilities\range.fsi" />
     <Compile Include="Utilities\range.fs" />
+    <Compile Include="Utilities\ParallelProcessing.fs" />
     <EmbeddedText Include="Facilities\UtilsStrings.txt" />
     <Compile Include="Facilities\LanguageFeatures.fsi" />
     <Compile Include="Facilities\LanguageFeatures.fs" />
@@ -386,7 +387,6 @@
     <Compile Include="Driver\ScriptClosure.fs" />
     <Compile Include="Driver\CompilerOptions.fsi" />
     <Compile Include="Driver\CompilerOptions.fs" />
-    <Compile Include="Driver\Parallel.fs" />
     <Compile Include="Driver\OptimizeInputs.fsi" />
     <Compile Include="Driver\OptimizeInputs.fs" />
     <Compile Include="Driver\XmlDocFileWriter.fsi" />
diff --git a/src/Compiler/Optimize/Optimizer.fs b/src/Compiler/Optimize/Optimizer.fs
index e0adb4befec..6b2d3c76a83 100644
--- a/src/Compiler/Optimize/Optimizer.fs
+++ b/src/Compiler/Optimize/Optimizer.fs
@@ -301,8 +301,11 @@ let [<Literal>] crossAssemblyOptimizationDefault = true
 let [<Literal>] debugPointsForPipeRightDefault = true
 
 [<RequireQualifiedAccess>]
-type OptimizerMode =
+type OptimizationProcessingMode =
+    /// Process files sequentially, on a single thread, doing all three optimization phases for each file next to each other.
     | Sequential
+    /// Use multiple threads.
+    /// As soon as a given phase for a file has finished, start processing the next phase of the current file and the same phase of the next file.
     | PartiallyParallel
 
 type OptimizationSettings = 
@@ -337,7 +340,7 @@ type OptimizationSettings =
       
       reportTotalSizes : bool
       
-      processingMode : OptimizerMode
+      processingMode : OptimizationProcessingMode
     }
 
     static member Defaults = 
@@ -354,7 +357,7 @@ type OptimizationSettings =
           reportFunctionSizes = false
           reportHasEffect = false
           reportTotalSizes = false
-          processingMode = OptimizerMode.Sequential
+          processingMode = OptimizationProcessingMode.Sequential
         }
 
     /// Determines if JIT optimizations are enabled
@@ -417,7 +420,7 @@ type OptimizationSettings =
     /// Also if we should expand "let x = Some exp1" bindings as prior tmps 
     member x.ExpandStructuralValues() = x.LocalOptimizationsEnabled
     
-    /// Determines how to process optimization of multiple files
+    /// Determines how to process optimization of multiple files and individual optimization phases
     member x.ProcessingMode() = x.processingMode
 
 type cenv =
diff --git a/src/Compiler/Optimize/Optimizer.fsi b/src/Compiler/Optimize/Optimizer.fsi
index 50bc200881c..1f68f4dcb04 100644
--- a/src/Compiler/Optimize/Optimizer.fsi
+++ b/src/Compiler/Optimize/Optimizer.fsi
@@ -10,7 +10,7 @@ open FSharp.Compiler.TypedTreeOps
 open FSharp.Compiler.TypedTreePickle
 
 [<RequireQualifiedAccess>]
-type OptimizerMode =
+type OptimizationProcessingMode =
     | Sequential
     | PartiallyParallel
 
@@ -46,7 +46,7 @@ type OptimizationSettings =
 
         reportTotalSizes: bool
 
-        processingMode: OptimizerMode
+        processingMode: OptimizationProcessingMode
     }
 
     member JitOptimizationsEnabled: bool
diff --git a/src/Compiler/Driver/Parallel.fs b/src/Compiler/Utilities/ParallelProcessing.fs
similarity index 96%
rename from src/Compiler/Driver/Parallel.fs
rename to src/Compiler/Utilities/ParallelProcessing.fs
index 1277eb39441..f4872b77604 100644
--- a/src/Compiler/Driver/Parallel.fs
+++ b/src/Compiler/Utilities/ParallelProcessing.fs
@@ -1,4 +1,4 @@
-module FSharp.Compiler.Service.Driver.Parallel
+module FSharp.Compiler.Service.Utilities.ParallelProcessing
 
 #nowarn "1182"
 

From 4db7786cda33f75b97591de7d94150c41c070301 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Thu, 1 Dec 2022 23:47:58 +0000
Subject: [PATCH 15/42] Cleanup

---
 src/Compiler/Driver/OptimizeInputs.fs        | 1 +
 src/Compiler/Utilities/ParallelProcessing.fs | 5 -----
 2 files changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index c70e824ce71..9d4899dbf16 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -291,6 +291,7 @@ module private ParallelOptimization =
                     |> Seq.toArray
                 |> fun nodes -> nodes |> Array.filter nodeCanBeProcessed
 
+        // TODO Do we need to pass in DiagnosticsLogger, or does optimization not use it?
         FSharp.Compiler.Service.Utilities.ParallelProcessing.processInParallel
             "OptimizeInputs"
             [| firstNode |]
diff --git a/src/Compiler/Utilities/ParallelProcessing.fs b/src/Compiler/Utilities/ParallelProcessing.fs
index f4872b77604..199d69520ff 100644
--- a/src/Compiler/Utilities/ParallelProcessing.fs
+++ b/src/Compiler/Utilities/ParallelProcessing.fs
@@ -38,12 +38,7 @@ let processInParallel
     firstItems |> Array.iter toProcess.Add
 
     let processItem item =
-        // printfn $"[{Thread.CurrentThread.ManagedThreadId}] Processing {_itemToString item}"
-        use _ = Activity.start "processItem" [| "item", _itemToString item |]
         let toSchedule = work item
-
-        // printfn $"[{Thread.CurrentThread.ManagedThreadId}] Finished {_itemToString item}"
-        // printfn $"[{Thread.CurrentThread.ManagedThreadId}] Scheduling {toSchedule.Length} items: {toScheduleString}"
         toSchedule |> Array.iter toProcess.Add
 
     let worker () : unit =

From 9534d4e395e33a86201562909449741cafb7b6e1 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Thu, 1 Dec 2022 23:55:33 +0000
Subject: [PATCH 16/42] Fantomas

---
 src/Compiler/Driver/OptimizeInputs.fs | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index 9d4899dbf16..fd95a9664a9 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -55,8 +55,10 @@ let GetInitialOptimizationEnv (tcImports: TcImports, tcGlobals: TcGlobals) =
 module private ParallelOptimization =
     open Optimizer
     type OptimizeDuringCodeGen = bool -> Expr -> Expr
+
     type OptimizeRes =
         (IncrementalOptimizationEnv * CheckedImplFile * ImplFileOptimizationInfo * SignatureHidingInfo) * OptimizeDuringCodeGen
+
     type PhaseInputs = IncrementalOptimizationEnv * SignatureHidingInfo * CheckedImplFile
     type Phase1Inputs = PhaseInputs
     type Phase1Res = OptimizeRes
@@ -67,12 +69,14 @@ module private ParallelOptimization =
     type Phase3Inputs = PhaseInputs
     type Phase3Res = IncrementalOptimizationEnv * CheckedImplFile
     type Phase3Fun = Phase3Inputs -> Phase3Res
+
     type FileResultsComplete =
         {
             Phase1: Phase1Res
             Phase2: Phase2Res
             Phase3: Phase3Res
         }
+
     type FilePhaseFuncs = Phase1Fun * Phase2Fun * Phase3Fun
 
     [<RequireQualifiedAccess>]
@@ -106,9 +110,12 @@ module private ParallelOptimization =
             Idx: int
             Phase: OptimizationPhase
         }
+
         override this.ToString() = $"[{this.Idx}-{this.Phase}]"
 
-    let collectResults (inputs: FileResultsComplete[]) : (CheckedImplFileAfterOptimization * ImplFileOptimizationInfo)[] * IncrementalOptimizationEnv =
+    let collectResults
+        (inputs: FileResultsComplete[])
+        : (CheckedImplFileAfterOptimization * ImplFileOptimizationInfo)[] * IncrementalOptimizationEnv =
         let files =
             inputs
             |> Array.map
@@ -269,8 +276,8 @@ module private ParallelOptimization =
                     let env =
                         match previous with
                         | None -> env0
-                        | Some {Phase3 = Some (env, _)} -> env
-                        | Some {Phase3 = None} -> failwith $"Unexpected lack of results for previous file [{idx-1}], phase 3"
+                        | Some { Phase3 = Some (env, _) } -> env
+                        | Some { Phase3 = None } -> failwith $"Unexpected lack of results for previous file [{idx - 1}], phase 3"
 
                     // Take impl file from Phase2
                     let _, file = res |> getPhase2Res
@@ -301,7 +308,10 @@ module private ParallelOptimization =
             ct
             (fun node -> node.ToString())
 
-        Debug.Assert(visited.Count = files.Length * 3, $"Expected to have visited all {files.Length} * 3 = {files.Length * 3} optimization nodes, but visited {visited.Count}")
+        Debug.Assert(
+            visited.Count = files.Length * 3,
+            $"Expected to have visited all {files.Length} * 3 = {files.Length * 3} optimization nodes, but visited {visited.Count}"
+        )
 
         let results =
             results

From d7b63e6d89258e5c92a403a49e2e7b366b1a50a3 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Fri, 2 Dec 2022 17:38:16 +0000
Subject: [PATCH 17/42] Update surface baseline

---
 src/Compiler/Utilities/ParallelProcessing.fs              | 2 +-
 ...Sharp.CompilerService.SurfaceArea.netstandard.expected | 8 +++++---
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/Compiler/Utilities/ParallelProcessing.fs b/src/Compiler/Utilities/ParallelProcessing.fs
index 199d69520ff..74cd1508c07 100644
--- a/src/Compiler/Utilities/ParallelProcessing.fs
+++ b/src/Compiler/Utilities/ParallelProcessing.fs
@@ -1,4 +1,4 @@
-module FSharp.Compiler.Service.Utilities.ParallelProcessing
+module internal FSharp.Compiler.Service.Utilities.ParallelProcessing
 
 #nowarn "1182"
 
diff --git a/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected b/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected
index 65f6aa81b24..9ae8ffb453d 100644
--- a/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected
+++ b/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected
@@ -2162,8 +2162,8 @@ FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean IsFromDispatchSlotImplemen
 FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean IsFromOpenStatement
 FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean IsFromPattern
 FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean IsFromType
-FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean IsPrivateToFile
 FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean IsFromUse
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean IsPrivateToFile
 FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean get_IsFromAttribute()
 FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean get_IsFromComputationExpression()
 FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean get_IsFromDefinition()
@@ -2171,8 +2171,8 @@ FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean get_IsFromDispatchSlotImpl
 FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean get_IsFromOpenStatement()
 FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean get_IsFromPattern()
 FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean get_IsFromType()
-FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean get_IsPrivateToFile()
 FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean get_IsFromUse()
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean get_IsPrivateToFile()
 FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: FSharp.Compiler.Symbols.FSharpDisplayContext DisplayContext
 FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: FSharp.Compiler.Symbols.FSharpDisplayContext get_DisplayContext()
 FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: FSharp.Compiler.Symbols.FSharpSymbol Symbol
@@ -4383,6 +4383,8 @@ FSharp.Compiler.Interactive.Shell: FSharp.Compiler.Interactive.Shell+FsiEvaluati
 FSharp.Compiler.Interactive.Shell: FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig
 FSharp.Compiler.Interactive.Shell: FSharp.Compiler.Interactive.Shell+FsiValue
 FSharp.Compiler.Interactive.Shell: FSharp.Compiler.Interactive.Shell+Settings
+FSharp.Compiler.Service.Utilities.ParallelProcessing
+FSharp.Compiler.Service.Utilities.ParallelProcessing: Void processInParallel[Item](System.String, Item[], Microsoft.FSharp.Core.FSharpFunc`2[Item,Item[]], Int32, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], System.Threading.CancellationToken, Microsoft.FSharp.Core.FSharpFunc`2[Item,System.String])
 FSharp.Compiler.Symbols.FSharpAbstractParameter
 FSharp.Compiler.Symbols.FSharpAbstractParameter: Boolean IsInArg
 FSharp.Compiler.Symbols.FSharpAbstractParameter: Boolean IsOptionalArg
@@ -5170,10 +5172,10 @@ FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Symbols.FSharpGenericParamet
 FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Symbols.FSharpGenericParameter get_GenericParameter()
 FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Symbols.FSharpParameter Prettify(FSharp.Compiler.Symbols.FSharpParameter)
 FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Symbols.FSharpType AbbreviatedType
+FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Symbols.FSharpType ErasedType
 FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Symbols.FSharpType Instantiate(Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpGenericParameter,FSharp.Compiler.Symbols.FSharpType]])
 FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Symbols.FSharpType Prettify(FSharp.Compiler.Symbols.FSharpType)
 FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Symbols.FSharpType StripAbbreviations()
-FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Symbols.FSharpType ErasedType
 FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Symbols.FSharpType get_AbbreviatedType()
 FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Symbols.FSharpType get_ErasedType()
 FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Text.TaggedText[] FormatLayout(FSharp.Compiler.Symbols.FSharpDisplayContext)

From 0c2d22cd7cb5be46c535b8567237470bd878d888 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Fri, 2 Dec 2022 18:41:59 +0000
Subject: [PATCH 18/42] Update surface baseline

---
 .../FSharp.CompilerService.SurfaceArea.netstandard.expected     | 2 --
 1 file changed, 2 deletions(-)

diff --git a/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected b/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected
index 9ae8ffb453d..aa47d72a960 100644
--- a/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected
+++ b/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected
@@ -4383,8 +4383,6 @@ FSharp.Compiler.Interactive.Shell: FSharp.Compiler.Interactive.Shell+FsiEvaluati
 FSharp.Compiler.Interactive.Shell: FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig
 FSharp.Compiler.Interactive.Shell: FSharp.Compiler.Interactive.Shell+FsiValue
 FSharp.Compiler.Interactive.Shell: FSharp.Compiler.Interactive.Shell+Settings
-FSharp.Compiler.Service.Utilities.ParallelProcessing
-FSharp.Compiler.Service.Utilities.ParallelProcessing: Void processInParallel[Item](System.String, Item[], Microsoft.FSharp.Core.FSharpFunc`2[Item,Item[]], Int32, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], System.Threading.CancellationToken, Microsoft.FSharp.Core.FSharpFunc`2[Item,System.String])
 FSharp.Compiler.Symbols.FSharpAbstractParameter
 FSharp.Compiler.Symbols.FSharpAbstractParameter: Boolean IsInArg
 FSharp.Compiler.Symbols.FSharpAbstractParameter: Boolean IsOptionalArg

From d0d529332731bfbc45e77d54d7d5589ca4579aa6 Mon Sep 17 00:00:00 2001
From: Janusz Wrobel <janusz.wrobel.2@gmail.com>
Date: Thu, 26 Jan 2023 08:18:04 +0000
Subject: [PATCH 19/42] Use 7 phases instead of 3, use tasks instead of manual
 thread pool, refactorings. (#38)

---
 src/Compiler/Driver/CompilerOptions.fs        |   2 +-
 src/Compiler/Driver/OptimizeInputs.fs         | 683 ++++++++----------
 .../Driver/parallel-optimization.drawio.svg   |   4 +
 src/Compiler/Driver/parallel-optimization.md  |  15 +
 src/Compiler/FSharp.Compiler.Service.fsproj   |   5 +
 5 files changed, 346 insertions(+), 363 deletions(-)
 create mode 100644 src/Compiler/Driver/parallel-optimization.drawio.svg
 create mode 100644 src/Compiler/Driver/parallel-optimization.md

diff --git a/src/Compiler/Driver/CompilerOptions.fs b/src/Compiler/Driver/CompilerOptions.fs
index 3b1c2683f8b..4fc6fbf1f11 100644
--- a/src/Compiler/Driver/CompilerOptions.fs
+++ b/src/Compiler/Driver/CompilerOptions.fs
@@ -1395,7 +1395,7 @@ let testFlag tcConfigB =
             | "ContinueAfterParseFailure" -> tcConfigB.continueAfterParseFailure <- true
             | "ParallelOff" -> tcConfigB.concurrentBuild <- false
             | "ParallelCheckingWithSignatureFilesOn" -> tcConfigB.parallelCheckingWithSignatureFiles <- true
-            | "PartiallyParallelOptimization" ->
+            | "ParallelOptimization" ->
                 tcConfigB.optSettings <-
                     { tcConfigB.optSettings with
                         processingMode = OptimizationProcessingMode.PartiallyParallel
diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index fd95a9664a9..fb960dcbcc7 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -2,10 +2,12 @@
 
 module internal FSharp.Compiler.OptimizeInputs
 
+open System.Collections.Concurrent
 open System.Collections.Generic
 open System.Diagnostics
 open System.IO
 open System.Threading
+open System.Threading.Tasks
 open Internal.Utilities.Library
 open FSharp.Compiler
 open FSharp.Compiler.AbstractIL.IL
@@ -51,287 +53,216 @@ let GetInitialOptimizationEnv (tcImports: TcImports, tcGlobals: TcGlobals) =
     let optEnv = List.fold (AddExternalCcuToOptimizationEnv tcGlobals) optEnv ccuinfos
     optEnv
 
+type private OptimizeDuringCodeGen = bool -> Expr -> Expr
+type PhaseRes =
+    {
+        OptEnvFirstLoop : Optimizer.IncrementalOptimizationEnv
+        OptInfo : Optimizer.ImplFileOptimizationInfo
+        OptEnvExtraLoop : Optimizer.IncrementalOptimizationEnv
+        OptEnvFinalSimplify : Optimizer.IncrementalOptimizationEnv
+        HidingInfo : SignatureHidingInfo
+        OptDuringCodeGen : OptimizeDuringCodeGen
+    }
+type PhaseRess = CheckedImplFile * PhaseRes
+
+type PhaseIdx = int
+type F<'In,'Out> = 'In -> 'Out
+type PhaseInputs =
+    {
+        File : CheckedImplFile
+        FileIdx : int
+        // State returned by processing the previous phase for the current file.
+        PrevPhase : PhaseRes
+        // State returned by processing the current phase for the previous file.
+        PrevFile : PhaseRes
+    }
+type PhaseFunc = PhaseInputs -> CheckedImplFile * PhaseRes
+
+/// <summary>
+/// Each file's optimization can be split into three different phases, executed one after another.
+/// Each phase calls 'Optimizer.OptimizeImplFile' and performs some other tasks.
+/// Each phase uses outputs of the previous phase and outputs of previous file's optimization for the same phase.
+/// </summary>
+type Phase =
+    {
+        Idx : PhaseIdx
+        Name : string
+    }
+    override this.ToString() = $"{this.Idx}-{this.Name}"
+
+type PhaseInfo =
+    {
+        Phase : Phase
+        Func : PhaseFunc
+    }
+
+type PhaseInfos = PhaseInfo[]
+
 [<RequireQualifiedAccess>]
 module private ParallelOptimization =
     open Optimizer
-    type OptimizeDuringCodeGen = bool -> Expr -> Expr
-
-    type OptimizeRes =
-        (IncrementalOptimizationEnv * CheckedImplFile * ImplFileOptimizationInfo * SignatureHidingInfo) * OptimizeDuringCodeGen
-
-    type PhaseInputs = IncrementalOptimizationEnv * SignatureHidingInfo * CheckedImplFile
-    type Phase1Inputs = PhaseInputs
-    type Phase1Res = OptimizeRes
-    type Phase1Fun = Phase1Inputs -> Phase1Res
-    type Phase2Inputs = IncrementalOptimizationEnv * SignatureHidingInfo * ImplFileOptimizationInfo * CheckedImplFile
-    type Phase2Res = IncrementalOptimizationEnv * CheckedImplFile
-    type Phase2Fun = Phase2Inputs -> Phase2Res
-    type Phase3Inputs = PhaseInputs
-    type Phase3Res = IncrementalOptimizationEnv * CheckedImplFile
-    type Phase3Fun = Phase3Inputs -> Phase3Res
-
-    type FileResultsComplete =
-        {
-            Phase1: Phase1Res
-            Phase2: Phase2Res
-            Phase3: Phase3Res
-        }
-
-    type FilePhaseFuncs = Phase1Fun * Phase2Fun * Phase3Fun
-
-    [<RequireQualifiedAccess>]
-    type OptimizationPhase =
-        | Phase1
-        | Phase2
-        | Phase3
-
-    type FileResults =
-        {
-            mutable Phase1: Phase1Res option
-            mutable Phase2: Phase2Res option
-            mutable Phase3: Phase3Res option
-        }
-
-        member this.HasResult(phase: OptimizationPhase) =
-            match phase with
-            | OptimizationPhase.Phase1 -> this.Phase1 |> Option.isSome
-            | OptimizationPhase.Phase2 -> this.Phase2 |> Option.isSome
-            | OptimizationPhase.Phase3 -> this.Phase3 |> Option.isSome
-
-        static member Empty =
-            {
-                Phase1 = None
-                Phase2 = None
-                Phase3 = None
-            }
-
-    type Node =
+    
+    /// Identifies a work item scheduled independently of others - consists of a (file) index and OptimizationPhase.
+    /// There are (NumberOfFiles * NumberOfPhases) nodes in the whole optimization process. 
+    type private Node =
         {
-            Idx: int
-            Phase: OptimizationPhase
+            FileIdx: int
+            Phase: PhaseIdx
         }
 
-        override this.ToString() = $"[{this.Idx}-{this.Phase}]"
+        override this.ToString() = $"[{this.FileIdx}-{this.Phase}]"
 
-    let collectResults
-        (inputs: FileResultsComplete[])
+    /// Final processing of file results to produce output needed for further compilation steps.
+    let private collectFinalResults
+        (fileResults: PhaseRess[])
         : (CheckedImplFileAfterOptimization * ImplFileOptimizationInfo)[] * IncrementalOptimizationEnv =
-        let files =
-            inputs
+        let finalFileResults =
+            fileResults
             |> Array.map
-                (fun {
-                         Phase1 = phase1
-                         Phase2 = _phase2
-                         Phase3 = phase3
-                     } ->
-                    let (_, _, implFileOptData, _), optimizeDuringCodeGen = phase1
-                    let _, implFile = phase3
-
+                (fun (file, res) ->
                     let implFile =
                         {
-                            ImplFile = implFile
-                            OptimizeDuringCodeGen = optimizeDuringCodeGen
+                            ImplFile = file
+                            OptimizeDuringCodeGen = res.OptDuringCodeGen
                         }
 
-                    implFile, implFileOptData)
+                    implFile, res.OptInfo)
 
-        let lastFilePhase1Env =
-            inputs
+        let lastFileFirstLoopEnv =
+            fileResults
             |> Array.last
-            |> fun { Phase1 = phase1 } ->
-                let (optEnvPhase1, _, _, _), _ = phase1
-                optEnvPhase1
+            |> fun (_file, res) -> res.OptEnvFirstLoop
 
-        files, lastFilePhase1Env
+        finalFileResults, lastFileFirstLoopEnv
 
-    let getPhase2Res (p: FileResults) = p.Phase2 |> Option.get
-
-    let getPhase3Res (p: FileResults) =
-        p.Phase3 |> Option.get |> (fun (env, _) -> env)
-
-    let optimizeFilesInParallel
+    let private raiseNoResultsExn (node: Node) =
+        raise (exn $"Unexpected lack of results for {node}")
+    
+    let optimizeFilesInParallel2
         (env0: IncrementalOptimizationEnv)
-        ((phase1, phase2, phase3): FilePhaseFuncs)
+        (phases : PhaseInfos)
         (files: CheckedImplFile list)
-        (ct: CancellationToken)
         : (CheckedImplFileAfterOptimization * ImplFileOptimizationInfo)[] * IncrementalOptimizationEnv =
-        let files = files |> List.toArray
-
-        let firstNode =
+        
+        /// Initial state for processing the current file.
+        let initialState =
             {
-                Idx = 0
-                Phase = OptimizationPhase.Phase1
+                OptEnvFirstLoop = env0
+                OptInfo = lazy failwith "This dummy value wrapped in a Lazy was not expected to be evaluated before being replaced."
+                OptEnvExtraLoop = env0
+                OptEnvFinalSimplify = env0
+                HidingInfo = SignatureHidingInfo.Empty
+                // A no-op optimizer
+                OptDuringCodeGen = fun _ expr -> expr
             }
-
-        let results = files |> Array.map (fun _ -> FileResults.Empty)
-
-        let _lock = obj ()
-
-        let nodeCanBeProcessed { Idx = idx; Phase = phase } : bool =
-            let previousPhase =
-                match phase with
-                | OptimizationPhase.Phase1 -> None
-                | OptimizationPhase.Phase2 -> Some OptimizationPhase.Phase1
-                | OptimizationPhase.Phase3 -> Some OptimizationPhase.Phase2
-
-            lock _lock (fun () ->
-                let previousFileReady = if idx = 0 then true else results[ idx - 1 ].HasResult phase
-
-                let previousPhaseReady =
-                    match previousPhase with
-                    | Some previousPhase -> results[ idx ].HasResult previousPhase
-                    | None -> true
-
-                previousFileReady && previousPhaseReady)
-
-        let visited = HashSet<Node>()
-
-        let worker ({ Idx = idx; Phase = phase } as node: Node) : Node[] =
-            let notPreviouslyVisited = lock _lock (fun () -> visited.Add node)
-
-            if notPreviouslyVisited = false then
-                [||]
-            else
-                let res = results[idx]
-                let file = files[idx]
-                let previous = if idx > 0 then Some results[idx - 1] else None
-                let hidingInfo0 = SignatureHidingInfo.Empty
-
-                let getPhase1Res (p: FileResults) =
-                    p.Phase1
-                    |> Option.get
-                    |> fun ((env, file, info, hidden), _) -> env, file, info, hidden
-
-                match phase with
-                | OptimizationPhase.Phase1 ->
-                    // Take env from the previous file
-                    let env, hidingInfo =
-                        previous
-                        |> Option.map getPhase1Res
-                        |> Option.map (fun (a, _b, _c, d) -> a, d)
-                        |> Option.defaultValue (env0, hidingInfo0)
-
-                    let inputs = env, hidingInfo, file
-                    let phase1Res = phase1 inputs
-                    res.Phase1 <- Some phase1Res
-
-                    let phase2Node =
-                        {
-                            Idx = idx
-                            Phase = OptimizationPhase.Phase2
-                        }
-
-                    seq {
-                        // Schedule Phase2 for the current file
-                        yield phase2Node
-                        // Schedule Phase1 for the next file if it exists
-                        if idx < files.Length - 1 then
-                            yield
-                                {
-                                    Idx = idx + 1
-                                    Phase = OptimizationPhase.Phase1
-                                }
-                    }
-                    |> Seq.toArray
-
-                | OptimizationPhase.Phase2 ->
-                    // Take env from previous file if it exists
-                    let env =
-                        previous
-                        |> Option.map getPhase2Res
-                        |> Option.map fst
-                        |> Option.defaultValue env0
-
-                    // Take impl file from Phase1
-                    let file, info, hidingInfo =
-                        res
-                        |> getPhase1Res
-                        |> (fun (_, file, optimizationInfo, hidingInfo) -> file, optimizationInfo, hidingInfo)
-
-                    let inputs = env, hidingInfo, info, file
-                    let phase2Res = phase2 inputs
-                    res.Phase2 <- Some phase2Res
-
-                    let phase3Node =
-                        {
-                            Idx = idx
-                            Phase = OptimizationPhase.Phase3
-                        }
-
-                    seq {
-                        // Schedule Phase3 for the current file
-                        yield phase3Node
-                        // Schedule Phase2 for the next file if it exists
-                        if idx < files.Length - 1 then
-                            yield
-                                {
-                                    Idx = idx + 1
-                                    Phase = OptimizationPhase.Phase2
-                                }
-                    }
-                    |> Seq.toArray
-
-                | OptimizationPhase.Phase3 ->
-                    // Take env from previous file if it exists
-                    let env =
-                        match previous with
-                        | None -> env0
-                        | Some { Phase3 = Some (env, _) } -> env
-                        | Some { Phase3 = None } -> failwith $"Unexpected lack of results for previous file [{idx - 1}], phase 3"
-
-                    // Take impl file from Phase2
-                    let _, file = res |> getPhase2Res
-                    let hidingInfo = res |> getPhase1Res |> (fun (_, _, _, hidingInfo) -> hidingInfo)
-                    let inputs = env, hidingInfo, file
-                    let phase3Res = phase3 inputs
-                    res.Phase3 <- Some phase3Res
-
-                    seq {
-                        // Schedule Phase3 for the next file if it exists
-                        if idx < files.Length - 1 then
-                            yield
-                                {
-                                    Idx = idx + 1
-                                    Phase = OptimizationPhase.Phase3
-                                }
+        
+        // Functions for accessing a set of node jobs and their results
+        let getTask, setTask =
+            let tasks : Task<PhaseRess>[,] = Array2D.zeroCreate files.Length phases.Length
+            let getTask (node : Node) =
+                tasks[node.FileIdx, node.Phase]
+            let setTask (node : Node) (task : Task<PhaseRess>) =
+                tasks[node.FileIdx, node.Phase] <- task
+            getTask, setTask
+            
+        let getNodeInputs (node : Node) =
+            task {
+                let prevPhaseTask =
+                    if node.Phase > 0 then
+                        getTask {node with Phase = node.Phase-1}
+                    else
+                        // First phase uses input file without modifications
+                        (files[node.FileIdx], initialState)
+                        |> Task.FromResult
+                let prevFileTask =
+                    if node.FileIdx > 0 then
+                        getTask {node with FileIdx = node.FileIdx-1}
+                    else
+                        // We don't use the file result in this case, but we need something, so just take the first input file as a placeholder. 
+                        (files[0], initialState)
+                        |> Task.FromResult
+                
+                let! results = [|prevPhaseTask; prevFileTask|] |> Task.WhenAll
+                let prevPhaseFile, prevPhaseRes = results[0]
+                let _prevFileFile, prevFileRes = results[1]
+                let inputs = {File = prevPhaseFile; FileIdx = node.FileIdx; PrevPhase = prevPhaseRes; PrevFile = prevFileRes}
+                return inputs
+            }
+        
+        let startNodeTask (phase : PhaseInfo) (node : Node) =
+            // A workaround to make sure that the initial part of each task is scheduled asynchronously
+            async {
+                let nodeTask =
+                    task {
+                        let! inputs = getNodeInputs node
+                        let res = phase.Func inputs
+                        return res
                     }
-                    |> Seq.toArray
-                |> fun nodes -> nodes |> Array.filter nodeCanBeProcessed
-
-        // TODO Do we need to pass in DiagnosticsLogger, or does optimization not use it?
-        FSharp.Compiler.Service.Utilities.ParallelProcessing.processInParallel
-            "OptimizeInputs"
-            [| firstNode |]
-            worker
-            10
-            (fun () -> visited.Count >= files.Length * 3)
-            ct
-            (fun node -> node.ToString())
-
-        Debug.Assert(
-            visited.Count = files.Length * 3,
-            $"Expected to have visited all {files.Length} * 3 = {files.Length * 3} optimization nodes, but visited {visited.Count}"
+                return! nodeTask |> Async.AwaitTask
+            } |> Async.StartAsTask
+        
+        let fileIndices = [|0..files.Length-1|]
+        
+        for fileIdx in fileIndices do
+            for phase in phases do
+                let node = {Node.Phase = phase.Phase.Idx; FileIdx = fileIdx}
+                let task = startNodeTask phase node
+                setTask node task
+        
+        let lastPhaseResultsTask =
+            let lastPhaseIndex = phases[phases.Length-1].Phase.Idx
+            fileIndices
+            |> Array.map (fun fileIdx -> getTask {Node.FileIdx = fileIdx; Phase = lastPhaseIndex})
+            |> Task.WhenAll
+        
+        let lastPhaseResults =
+            try
+                lastPhaseResultsTask.GetAwaiter().GetResult()
+            // If multiple exceptions returned by multiple tasks, ignore all but the first one.
+            with :? System.AggregateException as ex when ex.InnerExceptions.Count > 0 ->
+                raise ex.InnerExceptions[0]
+            
+        collectFinalResults lastPhaseResults
+
+let optimizeFilesSequentially optEnv (phases : PhaseInfos) implFiles =
+    let results, (optEnvFirstLoop, _, _, _) =
+        let implFiles = implFiles |> List.mapi (fun i file -> i, file)
+        ((optEnv, optEnv, optEnv, SignatureHidingInfo.Empty), implFiles)
+
+        ||> List.mapFold (fun (optEnvFirstLoop: Optimizer.IncrementalOptimizationEnv, optEnvExtraLoop, optEnvFinalSimplify, hidden) (fileIdx, implFile) ->
+            
+            /// Initial state for processing the current file.
+            let state =
+                implFile,
+                {
+                    OptEnvFirstLoop = optEnvFirstLoop
+                    OptInfo = lazy failwith "This dummy value wrapped in a Lazy was not expected to be evaluated before being replaced."
+                    OptEnvExtraLoop = optEnvExtraLoop
+                    OptEnvFinalSimplify = optEnvFinalSimplify
+                    HidingInfo = hidden
+                    // A no-op optimizer
+                    OptDuringCodeGen = fun _ expr -> expr
+                }
+            
+            let runPhase (file : CheckedImplFile, state : PhaseRes) (phase : PhaseInfo) =
+                // In the sequential mode we always process all phases of the previous file before processing the current file.
+                // This is why the state returned by the previous phase of the current file contains all changes made in the previous file,
+                // and we can use it in both places.
+                let input = {File = file; FileIdx = fileIdx; PrevPhase = state; PrevFile = state}
+                phase.Func input
+            
+            let implFile, state = Array.fold runPhase state phases
+
+            let file =
+                {
+                    ImplFile = implFile
+                    OptimizeDuringCodeGen = state.OptDuringCodeGen
+                }
+            
+            (file, state.OptInfo), (state.OptEnvFirstLoop, state.OptEnvExtraLoop, state.OptEnvFinalSimplify, state.HidingInfo)
         )
 
-        let results =
-            results
-            |> Array.mapi
-                (fun i {
-                           Phase1 = phase1
-                           Phase2 = phase2
-                           Phase3 = phase3
-                       } ->
-                    match phase1, phase2, phase3 with
-                    | Some phase1, Some phase2, Some phase3 ->
-                        {
-                            FileResultsComplete.Phase1 = phase1
-                            Phase2 = phase2
-                            Phase3 = phase3
-                        }
-                    | _ -> failwith $"Unexpected lack of optimization results for file [{i}]")
-
-        let collected = results |> collectResults
-        collected
+    results, optEnvFirstLoop
 
 let ApplyAllOptimizations
     (
@@ -375,127 +306,155 @@ let ApplyAllOptimizations
             reportingPhase = false
         }
 
-    let phase1 (env: Optimizer.IncrementalOptimizationEnv, hidden: SignatureHidingInfo, implFile: CheckedImplFile) =
-        use _ =
-            FSharp.Compiler.Diagnostics.Activity.start "phase1" [| "QualifiedNameOfFile", implFile.QualifiedNameOfFile.Text |]
-
-        Optimizer.OptimizeImplFile(
+    let measurements = ConcurrentDictionary<string, int64>()
+    let measure (name: string) =
+        let sw = Stopwatch.StartNew()
+        {
+            new System.IDisposable with
+                member this.Dispose() =
+                    lock measurements (fun () ->
+                        if measurements.ContainsKey name = false then measurements[name] <- 0L
+                        measurements[name] <- measurements[name] + sw.ElapsedMilliseconds
+                    )
+        }
+   
+    let wrapPhaseFunc (f : PhaseFunc) (info : Phase) =
+        fun (inputs : PhaseInputs) ->
+            use _ = measure info.Name
+            use _ =
+                let tags =
+                    [|
+                        "QualifiedNameOfFile", inputs.File.QualifiedNameOfFile.Text
+                        "OptimisationPhase", info.Name
+                    |]
+                FSharp.Compiler.Diagnostics.Activity.start $"file-{inputs.FileIdx}_phase-{info.Name}" tags
+            f inputs
+    
+    let phases = List<PhaseInfo>()
+    
+    let addPhase (name : string) (phaseFunc : PhaseFunc) =
+        let phase =
+            {
+                Idx = phases.Count
+                Name = name
+            }
+        let phaseInfo =
+            {
+                Phase = phase
+                Func = wrapPhaseFunc phaseFunc phase
+            }
+        phases.Add(phaseInfo)
+    
+    let firstLoop ({File = file; PrevPhase = prevPhase; PrevFile = prevFile} : PhaseInputs) : PhaseRess =
+        let (env, file, optInfo, hidingInfo), optDuringCodeGen = Optimizer.OptimizeImplFile(
             phase1Settings,
             ccu,
             tcGlobals,
             tcVal,
             importMap,
-            env,
+            prevFile.OptEnvFirstLoop,
             isIncrementalFragment,
             tcConfig.fsiMultiAssemblyEmit,
             tcConfig.emitTailcalls,
-            hidden,
-            implFile
+            prevFile.HidingInfo,
+            file
         )
-
-    let phase2
-        (
-            env: Optimizer.IncrementalOptimizationEnv,
-            hidden: SignatureHidingInfo,
-            _implFileOptData: Optimizer.ImplFileOptimizationInfo,
-            implFile: CheckedImplFile
-        ) =
-        use _ =
-            FSharp.Compiler.Diagnostics.Activity.start "phase2" [| "QualifiedNameOfFile", implFile.QualifiedNameOfFile.Text |]
-
-        let implFile = LowerLocalMutables.TransformImplFile tcGlobals importMap implFile
-
-        if tcConfig.extraOptimizationIterations > 0 then
-            let (optEnvExtraLoop, implFile, _, _), _ =
-                Optimizer.OptimizeImplFile(
-                    phase2And3Settings,
-                    ccu,
-                    tcGlobals,
-                    tcVal,
-                    importMap,
-                    env,
-                    isIncrementalFragment,
-                    tcConfig.fsiMultiAssemblyEmit,
-                    tcConfig.emitTailcalls,
-                    hidden,
-                    implFile
-                )
-
-            optEnvExtraLoop, implFile
-        else
-            env, implFile
-
-    let phase3 (env: Optimizer.IncrementalOptimizationEnv, hidden: SignatureHidingInfo, implFile: CheckedImplFile) =
-        use _ =
-            FSharp.Compiler.Diagnostics.Activity.start "phase3" [| "QualifiedNameOfFile", implFile.QualifiedNameOfFile.Text |]
-
-        let implFile =
-            if tcConfig.doDetuple then
-                let implFile = implFile |> Detuple.DetupleImplFile ccu tcGlobals
-                implFile
-            else
-                implFile
-
-        let implFile =
-            if tcConfig.doTLR then
-                implFile
-                |> InnerLambdasToTopLevelFuncs.MakeTopLevelRepresentationDecisions ccu tcGlobals
-            else
-                implFile
-
-        let implFile = LowerCalls.LowerImplFile tcGlobals implFile
-
-        if tcConfig.doFinalSimplify then
-            let (optEnvFinalSimplify, implFile, _, _), _ =
-                Optimizer.OptimizeImplFile(
-                    phase2And3Settings,
-                    ccu,
-                    tcGlobals,
-                    tcVal,
-                    importMap,
-                    env,
-                    isIncrementalFragment,
-                    tcConfig.fsiMultiAssemblyEmit,
-                    tcConfig.emitTailcalls,
-                    hidden,
-                    implFile
-                )
-
-            optEnvFinalSimplify, implFile
-        else
-            env, implFile
-
+        file,
+        {
+            prevPhase with
+                OptEnvFirstLoop = env
+                OptInfo = optInfo
+                HidingInfo = hidingInfo
+                OptDuringCodeGen = optDuringCodeGen
+        }
+    addPhase "firstLoop" firstLoop
+            
+    let lowerLocalMutables ({File = file; PrevPhase = prevPhase; PrevFile = _prevFile} : PhaseInputs) : PhaseRess =
+        let file = LowerLocalMutables.TransformImplFile tcGlobals importMap file
+        file, prevPhase
+    addPhase "lowerLocalMutables" lowerLocalMutables
+        
+    let extraLoop ({File = file; PrevPhase = prevPhase; PrevFile = prevFile} : PhaseInputs) : PhaseRess =
+        let (optEnvExtraLoop, file, _, _), _ =
+            Optimizer.OptimizeImplFile(
+                phase2And3Settings,
+                ccu,
+                tcGlobals,
+                tcVal,
+                importMap,
+                prevFile.OptEnvExtraLoop,
+                isIncrementalFragment,
+                tcConfig.fsiMultiAssemblyEmit,
+                tcConfig.emitTailcalls,
+                prevPhase.HidingInfo,
+                file
+            )
+
+        file,
+        {
+            prevPhase with
+                OptEnvExtraLoop = optEnvExtraLoop
+        }
+    
+    if tcConfig.extraOptimizationIterations > 0 then
+        addPhase "ExtraLoop" extraLoop
+    
+    let detuple ({File = file; PrevPhase = prevPhase; PrevFile = _prevFile} : PhaseInputs) : PhaseRess =
+        let file = file |> Detuple.DetupleImplFile ccu tcGlobals
+        file, prevPhase
+    if tcConfig.doDetuple then
+        addPhase "Detuple" detuple
+    
+    let innerLambdasToToplevelFuncs ({File = file; PrevPhase = prevPhase; PrevFile = _prevFile} : PhaseInputs) : PhaseRess =
+        let file =
+            file
+            |> InnerLambdasToTopLevelFuncs.MakeTopLevelRepresentationDecisions ccu tcGlobals
+        file, prevPhase
+    if tcConfig.doTLR then
+        addPhase "InnerLambdasToToplevelFuncs" innerLambdasToToplevelFuncs
+    
+    let lowerCalls ({File = file; PrevPhase = prevPhase; PrevFile = _prevFile} : PhaseInputs) : PhaseRess =
+        let file = LowerCalls.LowerImplFile tcGlobals file
+        file, prevPhase
+    addPhase "LowerCalls" lowerCalls
+    
+    let finalSimplify ({File = file; PrevPhase = prevPhase; PrevFile = prevFile} : PhaseInputs) : PhaseRess =
+        let (optEnvFinalSimplify, file, _, _), _ =
+            Optimizer.OptimizeImplFile(
+                phase2And3Settings,
+                ccu,
+                tcGlobals,
+                tcVal,
+                importMap,
+                prevFile.OptEnvFinalSimplify,
+                isIncrementalFragment,
+                tcConfig.fsiMultiAssemblyEmit,
+                tcConfig.emitTailcalls,
+                prevPhase.HidingInfo,
+                file
+            )
+
+        file,
+        {
+            prevPhase with
+                OptEnvFinalSimplify = optEnvFinalSimplify
+        }
+    if tcConfig.doFinalSimplify then
+        addPhase "FinalSimplify" finalSimplify    
+    
+    let phases = phases.ToArray()
+    
     let results, optEnvFirstLoop =
         match tcConfig.optSettings.processingMode with
         | Optimizer.OptimizationProcessingMode.PartiallyParallel ->
-            let ct = CancellationToken.None
-
             let results, optEnvFirstPhase =
-                ParallelOptimization.optimizeFilesInParallel optEnv (phase1, phase2, phase3) implFiles ct
-
+                ParallelOptimization.optimizeFilesInParallel2 optEnv phases implFiles
             results |> Array.toList, optEnvFirstPhase
         | Optimizer.OptimizationProcessingMode.Sequential ->
-            let results, (optEnvFirstLoop, _, _, _) =
-                ((optEnv, optEnv, optEnv, SignatureHidingInfo.Empty), implFiles)
-
-                ||> List.mapFold (fun (optEnvFirstLoop, optEnvExtraLoop, optEnvFinalSimplify, hidden) implFile ->
-                    let (optEnvFirstLoop, implFile, implFileOptData, hidden), optimizeDuringCodeGen =
-                        phase1 (optEnvFirstLoop, hidden, implFile)
-
-                    let optEnvExtraLoop, implFile =
-                        phase2 (optEnvExtraLoop, hidden, implFileOptData, implFile)
-
-                    let optEnvFinalSimplify, implFile = phase3 (optEnvFinalSimplify, hidden, implFile)
-
-                    let implFile =
-                        {
-                            ImplFile = implFile
-                            OptimizeDuringCodeGen = optimizeDuringCodeGen
-                        }
-
-                    (implFile, implFileOptData), (optEnvFirstLoop, optEnvExtraLoop, optEnvFinalSimplify, hidden))
-
-            results, optEnvFirstLoop
+            optimizeFilesSequentially optEnv phases implFiles
+    
+    for kvp in measurements do
+        printfn $"[{kvp.Key}] = {kvp.Value}"
 
 #if DEBUG
     if tcConfig.showOptimizationData then
diff --git a/src/Compiler/Driver/parallel-optimization.drawio.svg b/src/Compiler/Driver/parallel-optimization.drawio.svg
new file mode 100644
index 00000000000..141b0cfa7f4
--- /dev/null
+++ b/src/Compiler/Driver/parallel-optimization.drawio.svg
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Do not edit this file with editors other than diagrams.net -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="832px" height="971px" viewBox="-0.5 -0.5 832 971" content="&lt;mxfile host=&quot;drawio-plugin&quot; modified=&quot;2023-01-26T08:09:13.222Z&quot; agent=&quot;5.0 (Windows NT 6.2; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.5112.102 Safari/537.36&quot; etag=&quot;fHFLSYkoG7nGUFD-2Gvc&quot; version=&quot;20.5.3&quot; type=&quot;embed&quot;&gt;&lt;diagram id=&quot;Bl_DV8DP9ffBamNHP7EW&quot; name=&quot;Page-1&quot;&gt;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&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g><rect x="60" y="170" width="60" height="40" fill="#f5f5f5" stroke="#666666" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 190px; margin-left: 61px;"><div data-drawio-colors="color: #333333; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(51, 51, 51); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">A.fs</div></div></div></foreignObject><text x="90" y="194" fill="#333333" font-family="Helvetica" font-size="12px" text-anchor="middle">A.fs</text></switch></g><rect x="60" y="290" width="60" height="40" fill="#f5f5f5" stroke="#666666" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 310px; margin-left: 61px;"><div data-drawio-colors="color: #333333; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(51, 51, 51); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">B.fs</div></div></div></foreignObject><text x="90" y="314" fill="#333333" font-family="Helvetica" font-size="12px" text-anchor="middle">B.fs</text></switch></g><rect x="60" y="410" width="60" height="40" fill="#f5f5f5" stroke="#666666" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 430px; margin-left: 61px;"><div data-drawio-colors="color: #333333; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(51, 51, 51); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">C.fs</div></div></div></foreignObject><text x="90" y="434" fill="#333333" font-family="Helvetica" font-size="12px" text-anchor="middle">C.fs</text></switch></g><rect x="200" y="90" width="60" height="20" fill="#f5f5f5" stroke="#666666" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 100px; margin-left: 201px;"><div data-drawio-colors="color: #333333; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(51, 51, 51); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">Phase 1</div></div></div></foreignObject><text x="230" y="104" fill="#333333" font-family="Helvetica" font-size="12px" text-anchor="middle">Phase 1</text></switch></g><rect x="360" y="90" width="60" height="20" fill="#f5f5f5" stroke="#666666" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 100px; margin-left: 361px;"><div data-drawio-colors="color: #333333; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(51, 51, 51); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">Phase 2</div></div></div></foreignObject><text x="390" y="104" fill="#333333" font-family="Helvetica" font-size="12px" text-anchor="middle">Phase 2</text></switch></g><rect x="520" y="90" width="60" height="20" fill="#f5f5f5" stroke="#666666" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 100px; margin-left: 521px;"><div data-drawio-colors="color: #333333; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(51, 51, 51); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">Phase 3*</div></div></div></foreignObject><text x="550" y="104" fill="#333333" font-family="Helvetica" font-size="12px" text-anchor="middle">Phase 3*</text></switch></g><rect x="200" y="170" width="60" height="40" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 190px; margin-left: 201px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">A - 1</div></div></div></foreignObject><text x="230" y="194" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">A - 1</text></switch></g><rect x="360" y="170" width="60" height="40" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 190px; margin-left: 361px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">A - 2</div></div></div></foreignObject><text x="390" y="194" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">A - 2</text></switch></g><path d="M 550 210 L 550 250 L 230 250 L 230 283.63" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 230 288.88 L 226.5 281.88 L 230 283.63 L 233.5 281.88 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><rect x="520" y="170" width="60" height="40" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 190px; margin-left: 521px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">A - 3</div></div></div></foreignObject><text x="550" y="194" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">A - 3</text></switch></g><rect x="200" y="290" width="60" height="40" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 310px; margin-left: 201px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">B - 1</div></div></div></foreignObject><text x="230" y="314" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">B - 1</text></switch></g><rect x="360" y="290" width="60" height="40" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 310px; margin-left: 361px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">B - 2</div></div></div></foreignObject><text x="390" y="314" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">B - 2</text></switch></g><path d="M 550 330 L 550 370 L 230 370 L 230 403.63" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 230 408.88 L 226.5 401.88 L 230 403.63 L 233.5 401.88 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><rect x="520" y="290" width="60" height="40" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 310px; margin-left: 521px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">B - 3</div></div></div></foreignObject><text x="550" y="314" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">B - 3</text></switch></g><rect x="200" y="410" width="60" height="40" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 430px; margin-left: 201px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">C - 1</div></div></div></foreignObject><text x="230" y="434" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">C - 1</text></switch></g><rect x="360" y="410" width="60" height="40" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 430px; margin-left: 361px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">C - 2</div></div></div></foreignObject><text x="390" y="434" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">C - 2</text></switch></g><rect x="520" y="410" width="60" height="40" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 430px; margin-left: 521px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">C - 3</div></div></div></foreignObject><text x="550" y="434" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">C - 3</text></switch></g><path d="M 260 190 L 353.63 190" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 358.88 190 L 351.88 193.5 L 353.63 190 L 351.88 186.5 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 420 189.41 L 513.63 189.41" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 518.88 189.41 L 511.88 192.91 L 513.63 189.41 L 511.88 185.91 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 260 309.71 L 353.63 309.71" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 358.88 309.71 L 351.88 313.21 L 353.63 309.71 L 351.88 306.21 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 420 309.12 L 513.63 309.12" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 518.88 309.12 L 511.88 312.62 L 513.63 309.12 L 511.88 305.62 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 260 429.71 L 353.63 429.71" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 358.88 429.71 L 351.88 433.21 L 353.63 429.71 L 351.88 426.21 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 420 429.12 L 513.63 429.12" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 518.88 429.12 L 511.88 432.62 L 513.63 429.12 L 511.88 425.62 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><rect x="60" y="650" width="60" height="40" fill="#f5f5f5" stroke="#666666" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 670px; margin-left: 61px;"><div data-drawio-colors="color: #333333; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(51, 51, 51); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">A.fs</div></div></div></foreignObject><text x="90" y="674" fill="#333333" font-family="Helvetica" font-size="12px" text-anchor="middle">A.fs</text></switch></g><rect x="60" y="770" width="60" height="40" fill="#f5f5f5" stroke="#666666" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 790px; margin-left: 61px;"><div data-drawio-colors="color: #333333; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(51, 51, 51); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">B.fs</div></div></div></foreignObject><text x="90" y="794" fill="#333333" font-family="Helvetica" font-size="12px" text-anchor="middle">B.fs</text></switch></g><rect x="60" y="890" width="60" height="40" fill="#f5f5f5" stroke="#666666" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 910px; margin-left: 61px;"><div data-drawio-colors="color: #333333; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(51, 51, 51); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">C.fs</div></div></div></foreignObject><text x="90" y="914" fill="#333333" font-family="Helvetica" font-size="12px" text-anchor="middle">C.fs</text></switch></g><rect x="200" y="570" width="60" height="20" fill="#f5f5f5" stroke="#666666" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 580px; margin-left: 201px;"><div data-drawio-colors="color: #333333; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(51, 51, 51); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">Phase 1</div></div></div></foreignObject><text x="230" y="584" fill="#333333" font-family="Helvetica" font-size="12px" text-anchor="middle">Phase 1</text></switch></g><rect x="360" y="570" width="60" height="20" fill="#f5f5f5" stroke="#666666" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 580px; margin-left: 361px;"><div data-drawio-colors="color: #333333; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(51, 51, 51); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">Phase 2</div></div></div></foreignObject><text x="390" y="584" fill="#333333" font-family="Helvetica" font-size="12px" text-anchor="middle">Phase 2</text></switch></g><rect x="520" y="570" width="60" height="20" fill="#f5f5f5" stroke="#666666" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 580px; margin-left: 521px;"><div data-drawio-colors="color: #333333; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(51, 51, 51); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">Phase 3</div></div></div></foreignObject><text x="550" y="584" fill="#333333" font-family="Helvetica" font-size="12px" text-anchor="middle">Phase 3</text></switch></g><path d="M 230 690 L 230 763.63" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 230 768.88 L 226.5 761.88 L 230 763.63 L 233.5 761.88 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><rect x="200" y="650" width="60" height="40" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 670px; margin-left: 201px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">A - 1</div></div></div></foreignObject><text x="230" y="674" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">A - 1</text></switch></g><path d="M 390 690 L 390 763.63" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 390 768.88 L 386.5 761.88 L 390 763.63 L 393.5 761.88 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><rect x="360" y="650" width="60" height="40" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 670px; margin-left: 361px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">A - 2</div></div></div></foreignObject><text x="390" y="674" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">A - 2</text></switch></g><path d="M 550 690 L 550 763.63" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 550 768.88 L 546.5 761.88 L 550 763.63 L 553.5 761.88 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><rect x="520" y="650" width="60" height="40" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 670px; margin-left: 521px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">A - 3</div></div></div></foreignObject><text x="550" y="674" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">A - 3</text></switch></g><path d="M 230 810 L 230 883.63" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 230 888.88 L 226.5 881.88 L 230 883.63 L 233.5 881.88 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><rect x="200" y="770" width="60" height="40" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 790px; margin-left: 201px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">B - 1</div></div></div></foreignObject><text x="230" y="794" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">B - 1</text></switch></g><path d="M 390 810 L 390 883.63" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 390 888.88 L 386.5 881.88 L 390 883.63 L 393.5 881.88 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><rect x="360" y="770" width="60" height="40" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 790px; margin-left: 361px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">B - 2</div></div></div></foreignObject><text x="390" y="794" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">B - 2</text></switch></g><path d="M 550 810 L 550 883.63" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 550 888.88 L 546.5 881.88 L 550 883.63 L 553.5 881.88 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><rect x="520" y="770" width="60" height="40" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 790px; margin-left: 521px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">B - 3</div></div></div></foreignObject><text x="550" y="794" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">B - 3</text></switch></g><rect x="200" y="890" width="60" height="40" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 910px; margin-left: 201px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">C - 1</div></div></div></foreignObject><text x="230" y="914" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">C - 1</text></switch></g><rect x="360" y="890" width="60" height="40" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 910px; margin-left: 361px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">C - 2</div></div></div></foreignObject><text x="390" y="914" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">C - 2</text></switch></g><rect x="520" y="890" width="60" height="40" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 910px; margin-left: 521px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">C - 3</div></div></div></foreignObject><text x="550" y="914" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">C - 3</text></switch></g><path d="M 260 669.85 L 353.63 669.85" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 358.88 669.85 L 351.88 673.35 L 353.63 669.85 L 351.88 666.35 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 420 669.26 L 513.63 669.26" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 518.88 669.26 L 511.88 672.76 L 513.63 669.26 L 511.88 665.76 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 260 789.56 L 353.63 789.56" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 358.88 789.56 L 351.88 793.06 L 353.63 789.56 L 351.88 786.06 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 420 788.97 L 513.63 788.97" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 518.88 788.97 L 511.88 792.47 L 513.63 788.97 L 511.88 785.47 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 260 909.56 L 353.63 909.56" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 358.88 909.56 L 351.88 913.06 L 353.63 909.56 L 351.88 906.06 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 420 908.97 L 513.63 908.97" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 518.88 908.97 L 511.88 912.47 L 513.63 908.97 L 511.88 905.47 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 75px; margin-left: 50px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: nowrap;"><font style="font-size: 16px;">Sequential</font></div></div></div></foreignObject><text x="50" y="79" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">Sequential</text></switch></g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 555px; margin-left: 70px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: nowrap;"><font style="font-size: 16px;">Partially parallel<br /></font></div></div></div></foreignObject><text x="70" y="559" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">Partially parallel&#xa;</text></switch></g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 475px; margin-left: 395px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: nowrap;">Single sequence of work items, no parallelism.</div></div></div></foreignObject><text x="395" y="480" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="16px" text-anchor="middle">Single sequence of work items, no parallelis...</text></switch></g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 955px; margin-left: 395px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: nowrap;">Three sequences of work items, up to 3 work items processed at a time.</div></div></div></foreignObject><text x="395" y="960" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="16px" text-anchor="middle">Three sequences of work items, up to 3 work items processed at a t...</text></switch></g><path d="M 0 510 L 830 510" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" stroke-dasharray="3 3" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 15px; margin-left: 395px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; font-weight: bold; white-space: nowrap;">Comparison of work scheduling between fully sequential and parallel optimization</div></div></div></foreignObject><text x="395" y="20" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="16px" text-anchor="middle" font-weight="bold">Comparison of work scheduling between fully sequential and parallel optimization</text></switch></g><path d="M 720 65 L 773.63 64.55" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><path d="M 778.88 64.51 L 771.91 68.07 L 773.63 64.55 L 771.85 61.07 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 85px; margin-left: 745px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: nowrap;">B waits for A</div></div></div></foreignObject><text x="745" y="89" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">B waits for A</text></switch></g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 65px; margin-left: 705px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: nowrap;">A</div></div></div></foreignObject><text x="705" y="70" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="16px" text-anchor="middle">A</text></switch></g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 65px; margin-left: 795px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: nowrap;">B</div></div></div></foreignObject><text x="795" y="70" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="16px" text-anchor="middle">B</text></switch></g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 125px; margin-left: 745px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: nowrap;">* There are up to 7 phases</div></div></div></foreignObject><text x="745" y="129" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">* There are up to 7 phases</text></switch></g></g><switch><g requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"/><a transform="translate(0,-5)" xlink:href="https://www.diagrams.net/doc/faq/svg-export-text-problems" target="_blank"><text text-anchor="middle" font-size="10px" x="50%" y="100%">Text is not SVG - cannot display</text></a></switch></svg>
\ No newline at end of file
diff --git a/src/Compiler/Driver/parallel-optimization.md b/src/Compiler/Driver/parallel-optimization.md
new file mode 100644
index 00000000000..bf7d79104e2
--- /dev/null
+++ b/src/Compiler/Driver/parallel-optimization.md
@@ -0,0 +1,15 @@
+# Parallel Optimizations
+
+The Optimization phase of standalone compilation can take a significant part of compilation time.
+
+By default it runs fully sequentially, file-by-file.
+
+However, optimization of each file can be decomposed into up to 7 distinct 'phases',
+with the interesting property that evaluating phase P of file F does not depend on results of phases P+1... for any of the preceding files.
+
+This allows us to parallelize the whole process as shown in the diagram below:
+
+![Optimisation chart](parallel-optimization.drawio.svg)
+
+This parallelization is implemented in `OptimizeInputs.fs`.
+It can enabled with an experimental flag `--test:ParallelOptimization`.
\ No newline at end of file
diff --git a/src/Compiler/FSharp.Compiler.Service.fsproj b/src/Compiler/FSharp.Compiler.Service.fsproj
index f9cf0db5fc8..149f320b423 100644
--- a/src/Compiler/FSharp.Compiler.Service.fsproj
+++ b/src/Compiler/FSharp.Compiler.Service.fsproj
@@ -496,4 +496,9 @@
     <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="$(SystemRuntimeCompilerServicesUnsafeVersion)" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Content Include="Driver\parallel-optimization.md" />
+    <Content Include="Driver\parallel-optimization.drawio.svg" />
+  </ItemGroup>
+
 </Project>

From 9c713f923a44a9dd2951809bb4a3463142048c2b Mon Sep 17 00:00:00 2001
From: Janusz Wrobel <janusz.wrobel.2@gmail.com>
Date: Thu, 26 Jan 2023 08:25:31 +0000
Subject: [PATCH 20/42] Merge upstream/main (#39)

---
 .devcontainer/Dockerfile                      |     2 +-
 .devcontainer/devcontainer.json               |     2 +-
 FSharpBuild.Directory.Build.props             |     1 +
 INTERNAL.md                                   |     9 +-
 azure-pipelines.yml                           |   149 +-
 buildtools/README-fslexyacc.md                |     2 +-
 .../checkpackages/Directory.Build.targets     |     1 +
 .../FSharp.Compiler.Service_notshipped.fsproj |     8 +
 .../FSharp.Core_notshipped.fsproj             |     8 +
 buildtools/checkpackages/check.ps1            |    17 +
 buildtools/fslex/Arg.fs                       |    51 +-
 buildtools/fslex/Arg.fsi                      |     8 +-
 buildtools/fslex/Lexing.fs                    |   847 +-
 buildtools/fslex/Lexing.fsi                   |   125 +-
 buildtools/fslex/Parsing.fs                   |   280 +-
 buildtools/fslex/Parsing.fsi                  |    67 +-
 buildtools/fslex/fslex.fs                     |   262 +-
 buildtools/fslex/fslex.fsproj                 |     2 +-
 buildtools/fslex/fslexast.fs                  |   550 +-
 buildtools/fslex/fslexdriver.fs               |   205 +
 buildtools/fslex/fslexlex.fs                  |   176 +-
 buildtools/fslex/fslexpars.fs                 |   493 +-
 buildtools/fsyacc/Arg.fs                      |    51 +-
 buildtools/fsyacc/Arg.fsi                     |     8 +-
 buildtools/fsyacc/Lexing.fs                   |   847 +-
 buildtools/fsyacc/Lexing.fsi                  |   125 +-
 buildtools/fsyacc/Parsing.fs                  |   280 +-
 buildtools/fsyacc/Parsing.fsi                 |    67 +-
 buildtools/fsyacc/fsyacc.fs                   |   555 +-
 buildtools/fsyacc/fsyacc.fsproj               |     2 +-
 buildtools/fsyacc/fsyaccast.fs                |   136 +-
 buildtools/fsyacc/fsyaccdriver.fs             |   547 +
 buildtools/fsyacc/fsyacclex.fs                |   166 +-
 buildtools/fsyacc/fsyaccpars.fs               |   198 +-
 docs/diagnostics.md                           |    11 +-
 docs/overview.md                              |     8 +-
 eng/Build.ps1                                 |    40 +-
 eng/Versions.props                            |    36 +-
 eng/release/insert-into-vs.yml                |     2 +-
 global.json                                   |     8 +-
 src/Compiler/AbstractIL/il.fs                 |    61 +-
 src/Compiler/AbstractIL/ilmorph.fs            |     7 +-
 src/Compiler/AbstractIL/ilnativeres.fs        |     3 -
 src/Compiler/AbstractIL/ilprint.fs            |   489 -
 src/Compiler/AbstractIL/ilread.fs             |    72 +-
 src/Compiler/AbstractIL/ilreflect.fs          |    60 -
 src/Compiler/AbstractIL/ilsign.fs             |    49 +-
 src/Compiler/AbstractIL/ilsign.fsi            |    10 +-
 src/Compiler/AbstractIL/ilsupp.fs             |    92 -
 src/Compiler/AbstractIL/ilwrite.fs            |   148 +-
 src/Compiler/AbstractIL/ilwrite.fsi           |     1 -
 src/Compiler/AbstractIL/ilwritepdb.fs         |    14 +-
 src/Compiler/AbstractIL/ilwritepdb.fsi        |     1 -
 src/Compiler/AbstractIL/ilx.fs                |     2 -
 src/Compiler/Checking/AttributeChecking.fs    |     4 +-
 src/Compiler/Checking/AttributeChecking.fsi   |     2 +-
 .../Checking/AugmentWithHashCompare.fs        |    15 +-
 .../Checking/CheckComputationExpressions.fs   |     6 +-
 src/Compiler/Checking/CheckDeclarations.fs    |   109 +-
 src/Compiler/Checking/CheckExpressions.fs     |   142 +-
 src/Compiler/Checking/CheckFormatStrings.fs   |    13 +-
 src/Compiler/Checking/InfoReader.fs           |    17 +-
 src/Compiler/Checking/InfoReader.fsi          |     4 +
 src/Compiler/Checking/MethodCalls.fs          |     6 +-
 src/Compiler/Checking/MethodOverrides.fs      |     4 +-
 src/Compiler/Checking/MethodOverrides.fsi     |     3 +-
 src/Compiler/Checking/NameResolution.fs       |     5 +-
 src/Compiler/Checking/NicePrint.fs            |     8 -
 .../Checking/PatternMatchCompilation.fs       |    12 -
 src/Compiler/Checking/PostInferenceChecks.fs  |    28 +-
 src/Compiler/Checking/QuotationTranslator.fs  |     2 +-
 src/Compiler/CodeGen/EraseClosures.fs         |    21 -
 src/Compiler/CodeGen/EraseUnions.fs           |     2 -
 src/Compiler/CodeGen/IlxGen.fs                |   365 +-
 src/Compiler/CodeGen/IlxGen.fsi               |     3 +
 src/Compiler/Driver/CompilerConfig.fs         |    43 +-
 src/Compiler/Driver/CompilerConfig.fsi        |    15 +
 src/Compiler/Driver/CompilerImports.fs        |    11 +-
 src/Compiler/Driver/CompilerImports.fsi       |     2 +-
 src/Compiler/Driver/CompilerOptions.fs        |   191 +-
 src/Compiler/Driver/CompilerOptions.fsi       |     6 +-
 src/Compiler/Driver/CreateILModule.fs         |    46 +-
 src/Compiler/Driver/CreateILModule.fsi        |     4 +
 src/Compiler/Driver/FxResolver.fs             |    61 +-
 src/Compiler/Driver/OptimizeInputs.fs         |     1 +
 src/Compiler/Driver/ParseAndCheckInputs.fs    |    54 +-
 src/Compiler/Driver/ParseAndCheckInputs.fsi   |     3 +-
 src/Compiler/Driver/StaticLinking.fs          |     2 +-
 src/Compiler/Driver/fsc.fs                    |    21 +-
 src/Compiler/FSComp.txt                       |    12 +
 src/Compiler/FSharp.Compiler.Service.fsproj   |     1 +
 src/Compiler/Facilities/CompilerLocation.fs   |     5 -
 src/Compiler/Facilities/LanguageFeatures.fs   |    14 +-
 src/Compiler/Facilities/LanguageFeatures.fsi  |     4 +
 src/Compiler/Interactive/FSIstrings.txt       |     2 -
 src/Compiler/Interactive/fsi.fs               |   148 +-
 .../Interactive/xlf/FSIstrings.txt.cs.xlf     |    10 -
 .../Interactive/xlf/FSIstrings.txt.de.xlf     |    10 -
 .../Interactive/xlf/FSIstrings.txt.es.xlf     |    10 -
 .../Interactive/xlf/FSIstrings.txt.fr.xlf     |    10 -
 .../Interactive/xlf/FSIstrings.txt.it.xlf     |    10 -
 .../Interactive/xlf/FSIstrings.txt.ja.xlf     |    10 -
 .../Interactive/xlf/FSIstrings.txt.ko.xlf     |    10 -
 .../Interactive/xlf/FSIstrings.txt.pl.xlf     |    10 -
 .../Interactive/xlf/FSIstrings.txt.pt-BR.xlf  |    10 -
 .../Interactive/xlf/FSIstrings.txt.ru.xlf     |    10 -
 .../Interactive/xlf/FSIstrings.txt.tr.xlf     |    10 -
 .../xlf/FSIstrings.txt.zh-Hans.xlf            |    10 -
 .../xlf/FSIstrings.txt.zh-Hant.xlf            |    10 -
 src/Compiler/Optimize/DetupleArgs.fs          |    21 -
 .../Optimize/LowerComputedCollections.fs      |     2 -
 src/Compiler/Optimize/LowerSequences.fs       |     2 -
 src/Compiler/Optimize/Optimizer.fs            |    12 -
 src/Compiler/Service/FSharpCheckerResults.fs  |    39 +-
 src/Compiler/Service/FSharpCheckerResults.fsi |     3 +-
 src/Compiler/Service/FSharpSource.fs          |     4 +-
 src/Compiler/Service/FSharpSource.fsi         |     3 +-
 src/Compiler/Service/IncrementalBuild.fs      |    61 +-
 src/Compiler/Service/IncrementalBuild.fsi     |     7 +-
 .../Service/ServiceInterfaceStubGenerator.fs  |    15 -
 src/Compiler/Service/ServiceLexing.fs         |     1 -
 src/Compiler/Service/ServiceParseTreeWalk.fs  |     2 +-
 src/Compiler/Service/ServiceStructure.fs      |    73 +-
 src/Compiler/Service/service.fs               |   185 +-
 src/Compiler/Service/service.fsi              |    21 +-
 src/Compiler/Symbols/SymbolHelpers.fs         |    16 -
 src/Compiler/Symbols/SymbolPatterns.fs        |     2 -
 src/Compiler/Symbols/Symbols.fs               |    10 +-
 src/Compiler/Symbols/Symbols.fsi              |     3 +
 src/Compiler/SyntaxTree/LexFilter.fs          |    15 -
 src/Compiler/SyntaxTree/LexHelpers.fs         |     2 -
 src/Compiler/SyntaxTree/ParseHelpers.fs       |    16 +-
 src/Compiler/SyntaxTree/ParseHelpers.fsi      |     4 +-
 src/Compiler/SyntaxTree/SyntaxTree.fs         |     3 +-
 src/Compiler/SyntaxTree/SyntaxTree.fsi        |     5 +-
 src/Compiler/SyntaxTree/SyntaxTrivia.fs       |     5 +
 src/Compiler/SyntaxTree/SyntaxTrivia.fsi      |     9 +
 src/Compiler/TypedTree/CompilerGlobalState.fs |    70 +-
 .../TypedTree/CompilerGlobalState.fsi         |     2 -
 src/Compiler/TypedTree/TcGlobals.fs           |     2 +
 src/Compiler/TypedTree/TypedTree.fs           |     5 +
 src/Compiler/TypedTree/TypedTree.fsi          |     6 +
 src/Compiler/TypedTree/TypedTreeOps.fs        |   279 +-
 src/Compiler/TypedTree/TypedTreeOps.fsi       |    26 +-
 src/Compiler/TypedTree/TypedTreePickle.fs     |   106 +-
 src/Compiler/Utilities/Activity.fs            |   218 +-
 src/Compiler/Utilities/Activity.fsi           |    15 +
 src/Compiler/Utilities/FileSystem.fs          |     2 -
 src/Compiler/Utilities/ImmutableArray.fs      |    30 -
 src/Compiler/Utilities/illib.fs               |    88 +-
 src/Compiler/Utilities/illib.fsi              |    13 +-
 src/Compiler/Utilities/lib.fs                 |   123 +-
 src/Compiler/Utilities/lib.fsi                |    41 +-
 src/Compiler/Utilities/sformat.fs             |    40 +-
 src/Compiler/Utilities/sformat.fsi            |     4 -
 src/Compiler/Utilities/sr.fs                  |     1 -
 src/Compiler/pars.fsy                         |    50 +-
 src/Compiler/xlf/FSComp.txt.cs.xlf            |   152 +-
 src/Compiler/xlf/FSComp.txt.de.xlf            |   152 +-
 src/Compiler/xlf/FSComp.txt.es.xlf            |   152 +-
 src/Compiler/xlf/FSComp.txt.fr.xlf            |   152 +-
 src/Compiler/xlf/FSComp.txt.it.xlf            |   152 +-
 src/Compiler/xlf/FSComp.txt.ja.xlf            |    94 +-
 src/Compiler/xlf/FSComp.txt.ko.xlf            |   152 +-
 src/Compiler/xlf/FSComp.txt.pl.xlf            |   152 +-
 src/Compiler/xlf/FSComp.txt.pt-BR.xlf         |   152 +-
 src/Compiler/xlf/FSComp.txt.ru.xlf            |   152 +-
 src/Compiler/xlf/FSComp.txt.tr.xlf            |   152 +-
 src/Compiler/xlf/FSComp.txt.zh-Hans.xlf       |   152 +-
 src/Compiler/xlf/FSComp.txt.zh-Hant.xlf       |    94 +-
 src/Compiler/xlf/FSStrings.cs.xlf             |     6 +-
 src/Compiler/xlf/FSStrings.de.xlf             |     6 +-
 src/Compiler/xlf/FSStrings.es.xlf             |     6 +-
 src/Compiler/xlf/FSStrings.fr.xlf             |     6 +-
 src/Compiler/xlf/FSStrings.it.xlf             |     6 +-
 src/Compiler/xlf/FSStrings.ja.xlf             |     4 +-
 src/Compiler/xlf/FSStrings.ko.xlf             |     6 +-
 src/Compiler/xlf/FSStrings.pl.xlf             |     6 +-
 src/Compiler/xlf/FSStrings.pt-BR.xlf          |     6 +-
 src/Compiler/xlf/FSStrings.ru.xlf             |     6 +-
 src/Compiler/xlf/FSStrings.tr.xlf             |     6 +-
 src/Compiler/xlf/FSStrings.zh-Hans.xlf        |     6 +-
 src/Compiler/xlf/FSStrings.zh-Hant.xlf        |     4 +-
 src/FSharp.Core/ILLink.LinkAttributes.xml     |     5 +-
 src/FSharp.Core/Linq.fs                       |     7 -
 src/FSharp.Core/array2.fs                     |     7 +-
 src/FSharp.Core/eventmodule.fs                |     4 -
 src/FSharp.Core/fslib-extra-pervasives.fs     |    48 +-
 src/FSharp.Core/map.fs                        |    35 +
 src/FSharp.Core/map.fsi                       |     1 +
 src/FSharp.Core/observable.fsi                |     1 -
 src/FSharp.Core/prim-types.fs                 |    15 +-
 src/FSharp.Core/quotations.fs                 |    79 -
 src/FSharp.Core/reflect.fs                    |    66 +-
 src/FSharp.Core/result.fs                     |     6 -
 src/FSharp.Core/result.fsi                    |     6 +-
 src/FSharp.Core/resumable.fs                  |     3 -
 src/FSharp.Core/seqcore.fs                    |     3 -
 src/FSharp.Core/set.fs                        |    28 +-
 src/FSharp.Core/set.fsi                       |     1 +
 src/FSharp.Core/tasks.fs                      |     4 +-
 .../LegacyMSBuildReferenceResolver.fs         |    13 -
 .../xlf/LegacyResolver.txt.cs.xlf             |     8 +-
 .../xlf/LegacyResolver.txt.de.xlf             |     8 +-
 .../xlf/LegacyResolver.txt.es.xlf             |     8 +-
 .../xlf/LegacyResolver.txt.fr.xlf             |     8 +-
 .../xlf/LegacyResolver.txt.it.xlf             |     8 +-
 .../xlf/LegacyResolver.txt.ja.xlf             |     8 +-
 .../xlf/LegacyResolver.txt.ko.xlf             |     8 +-
 .../xlf/LegacyResolver.txt.pl.xlf             |     8 +-
 .../xlf/LegacyResolver.txt.pt-BR.xlf          |     8 +-
 .../xlf/LegacyResolver.txt.ru.xlf             |     8 +-
 .../xlf/LegacyResolver.txt.tr.xlf             |     8 +-
 .../xlf/LegacyResolver.txt.zh-Hans.xlf        |     8 +-
 .../xlf/LegacyResolver.txt.zh-Hant.xlf        |     8 +-
 src/fsi/console.fs                            |   167 +-
 .../CompilerOptions/fsc/sourceFiles.fs        |    20 +
 .../CompilerOptions/fsc/times/times.fs        |    45 +
 .../CompilerOptions/fsc/warnon/warnon.fs      |   108 +
 .../AttributeUsage/AttributeUsage.fs          |    11 -
 .../IWSAMsAndSRTPs/IWSAMsAndSRTPsTests.fs     |    83 +-
 .../EmittedIL/Enums.fs                        |    53 +
 .../EmittedIL/Literals.fs                     |   204 +
 ...dImplAttribute.NoInlining_InlineKeyword.fs |     3 +
 .../MethodImplAttribute.fs                    |    14 +
 .../EmittedIL/SkipLocalsInit.fs               |    14 +-
 .../Structure/UnionTypeWithSignature02.fs     |     2 +-
 .../ErrorMessages/ClassesTests.fs             |   146 +-
 .../ErrorMessages/UnsupportedAttributes.fs    |     6 +-
 .../FSharp.Compiler.ComponentTests.fsproj     |     8 +
 .../FSharpChecker/CommonWorkflows.fs          |    43 +
 .../FSharpChecker/FindReferences.fs           |    16 +-
 .../Interop/DeeplyNestedCSharpClasses.fs      |    86 +
 .../Interop/RequiredAndInitOnlyProperties.fs  |    84 +-
 .../Interop/StaticsInInterfaces.fs            |    48 +-
 .../Language/AttributeCheckingTests.fs        |     6 +-
 .../Language/ComputationExpressionTests.fs    |    45 +-
 .../DynamicAssignmentOperatorTests.fs         |    21 +
 .../Language/IndexerSetterParamArray.fs       |    11 +-
 .../Language/InterpolatedStringsTests.fs      |    19 +-
 .../Language/StaticClassTests.fs              |   780 ++
 .../Scripting/Interactive.fs                  |    15 +
 .../SkipLocalsInit.fs                         |    14 +-
 ...rvice.SurfaceArea.netstandard20.debug.bsl} |   348 +-
 ...vice.SurfaceArea.netstandard20.release.bsl | 11301 ++++++++++++++++
 .../FSharp.Compiler.Service.Tests.fsproj      |     7 +-
 .../LibraryTestFx.fs                          |    77 -
 .../SurfaceArea.fs                            |    38 +
 .../SurfaceArea.netstandard.fs                |    13 -
 .../AssemblySigningAttributes.fs              |    16 +-
 tests/FSharp.Compiler.UnitTests/FsiTests.fs   |    60 +-
 ...p.Core.SurfaceArea.netstandard20.debug.bsl |  2508 ++++
 ...Core.SurfaceArea.netstandard20.release.bsl |  2507 ++++
 ...p.Core.SurfaceArea.netstandard21.debug.bsl |  2509 ++++
 ...Core.SurfaceArea.netstandard21.release.bsl |  2508 ++++
 .../FSharp.Core.UnitTests.fsproj              |     3 +-
 .../FSharp.Core/ComparersRegression.fs        |   216 +-
 .../Microsoft.FSharp.Collections/ListType.fs  |    23 +
 .../Microsoft.FSharp.Control/AsyncModule.fs   |     9 -
 .../Microsoft.FSharp.Control/Tasks.fs         |    19 +-
 .../ExtraTopLevelOperatorsTests.fs            |     4 +-
 .../FSharp.Core/PrimTypes.fs                  |    51 +-
 tests/FSharp.Core.UnitTests/LibraryTestFx.fs  |    72 -
 tests/FSharp.Core.UnitTests/SurfaceArea.fs    |  2549 +---
 tests/FSharp.Core.UnitTests/TypeForwarding.fs |    34 -
 tests/FSharp.Test.Utilities/Compiler.fs       |     9 +-
 .../FSharp.Test.Utilities.fsproj              |     2 +
 .../ProjectGeneration.fs                      |   215 +-
 tests/FSharp.Test.Utilities/SurfaceArea.fs    |   127 +
 tests/FSharp.Test.Utilities/Utilities.fs      |    18 +
 tests/README.md                               |     4 +-
 .../BackgroundCompilerBenchmarks.fs           |   132 +-
 .../FSharp.Compiler.Benchmarks.fsproj         |     2 +-
 .../SomethingToCompile.fs                     |     2 +-
 .../SomethingToCompileSmaller.fs              |   581 +
 .../EmittedIL/ReferenceAssemblyTests.fs       |   127 +-
 tests/fsharp/FSharpSuite.Tests.fsproj         |     1 +
 tests/fsharp/TestHelpers.fs                   |    47 -
 .../core/printing/output.multiemit.stderr.bsl |    18 -
 .../CompilerOptions/fsc/gccerrors/env.lst     |     2 +-
 .../fsi/exename/help40.437.1033.bsl           |     4 +-
 .../fsi/help/help40-nologo.437.1033.bsl       |     4 +-
 .../fsi/help/help40.437.1033.bsl              |     4 +-
 .../EnumTypes/E_BoolUnderlyingType.fs         |     2 +-
 .../E_DiscrimnantOfDifferentTypes.fs          |     2 +-
 .../EnumTypes/E_NonInt32Enums01.fs            |     4 +-
 .../E_LiteralEnumerationMustHaveType01.fs     |     4 +-
 .../Misc/E_InheritClassWithoutDefCtor.fs      |    19 -
 .../Source/InteractiveSession/Misc/env.lst    |     2 -
 tests/fsharpqa/Source/test.lst                |     2 +-
 .../SelfContained_Trimming_Test/check.ps1     |     2 +-
 tests/service/ExprTests.fs                    |     9 +
 tests/service/ScriptOptionsTests.fs           |    29 +-
 tests/service/SyntaxTreeTests/BindingTests.fs |    41 +
 tests/service/SyntaxTreeTests/MemberTests.fs  |    47 +
 tests/service/SyntaxTreeTests/TypeTests.fs    |    12 +-
 tests/service/SyntaxTreeTests/ValTests.fs     |    20 +
 tests/service/TreeVisitorTests.fs             |    20 +-
 .../Template/ConsoleApplication.fsproj        |     2 +-
 .../LibraryProject/Template/Library.fsproj    |     2 +-
 .../TutorialProject/Template/Tutorial.fsproj  |     2 +-
 .../Common/CodeAnalysisExtensions.fs          |     4 +-
 .../src/FSharp.Editor/Common/Pervasive.fs     |     6 +-
 .../Diagnostics/DocumentDiagnosticAnalyzer.fs |    26 +-
 .../src/FSharp.Editor/FSharp.Editor.fsproj    |     2 +-
 .../src/FSharp.Editor/FSharp.Editor.resx      |     6 +-
 .../src/FSharp.Editor/Hints/HintService.fs    |    62 +-
 .../Hints/InlineParameterNameHints.fs         |    82 +-
 .../FSharp.Editor/Hints/InlineTypeHints.fs    |    15 +-
 .../src/FSharp.Editor/Hints/RoslynAdapter.fs  |     1 +
 .../FSharpProjectOptionsManager.fs            |     2 +-
 .../LanguageService/LanguageService.fs        |    39 +-
 .../LanguageService/MetadataAsSource.fs       |     2 +-
 .../LanguageService/WorkspaceExtensions.fs    |    31 +-
 .../Navigation/GoToDefinition.fs              |   360 +-
 .../FSharp.Editor/Options/EditorOptions.fs    |     8 +-
 .../FSharp.Editor/xlf/FSharp.Editor.cs.xlf    |    12 +-
 .../FSharp.Editor/xlf/FSharp.Editor.de.xlf    |    12 +-
 .../FSharp.Editor/xlf/FSharp.Editor.es.xlf    |    12 +-
 .../FSharp.Editor/xlf/FSharp.Editor.fr.xlf    |    12 +-
 .../FSharp.Editor/xlf/FSharp.Editor.it.xlf    |    12 +-
 .../FSharp.Editor/xlf/FSharp.Editor.ja.xlf    |    12 +-
 .../FSharp.Editor/xlf/FSharp.Editor.ko.xlf    |    12 +-
 .../FSharp.Editor/xlf/FSharp.Editor.pl.xlf    |    12 +-
 .../FSharp.Editor/xlf/FSharp.Editor.pt-BR.xlf |    12 +-
 .../FSharp.Editor/xlf/FSharp.Editor.ru.xlf    |    12 +-
 .../FSharp.Editor/xlf/FSharp.Editor.tr.xlf    |    12 +-
 .../xlf/FSharp.Editor.zh-Hans.xlf             |    12 +-
 .../xlf/FSharp.Editor.zh-Hant.xlf             |    12 +-
 .../AdvancedOptionsControl.xaml               |     4 +
 .../FSharp.UIResources/Strings.Designer.cs    |    22 +-
 .../src/FSharp.UIResources/Strings.resx       |    10 +-
 .../src/FSharp.UIResources/xlf/Strings.cs.xlf |    30 +-
 .../src/FSharp.UIResources/xlf/Strings.de.xlf |    30 +-
 .../src/FSharp.UIResources/xlf/Strings.es.xlf |    30 +-
 .../src/FSharp.UIResources/xlf/Strings.fr.xlf |    30 +-
 .../src/FSharp.UIResources/xlf/Strings.it.xlf |    30 +-
 .../src/FSharp.UIResources/xlf/Strings.ja.xlf |    30 +-
 .../src/FSharp.UIResources/xlf/Strings.ko.xlf |    30 +-
 .../src/FSharp.UIResources/xlf/Strings.pl.xlf |    30 +-
 .../FSharp.UIResources/xlf/Strings.pt-BR.xlf  |    30 +-
 .../src/FSharp.UIResources/xlf/Strings.ru.xlf |    30 +-
 .../src/FSharp.UIResources/xlf/Strings.tr.xlf |    30 +-
 .../xlf/Strings.zh-Hans.xlf                   |    30 +-
 .../xlf/Strings.zh-Hant.xlf                   |    30 +-
 .../src/FSharp.VS.FSI/fsiLanguageService.fs   |    10 +-
 .../BraceMatchingServiceTests.fs              |   119 +-
 .../BreakpointResolutionServiceTests.fs       |    27 +-
 .../CompletionProviderTests.fs                |   229 +-
 .../DocumentDiagnosticAnalyzerTests.fs        |    96 +-
 .../DocumentHighlightsServiceTests.fs         |    45 +-
 .../EditorFormattingServiceTests.fs           |    72 +-
 .../FSharp.Editor.Tests.fsproj                |     9 +-
 .../FsxCompletionProviderTests.fs             |    39 +-
 .../GoToDefinitionServiceTests.fs             |    61 +-
 .../HelpContextServiceTests.fs                |   106 +-
 .../Helpers/ProjectOptionsBuilder.fs          |    13 -
 .../Helpers/RoslynHelpers.fs                  |   182 +-
 .../Hints/HintTestFramework.fs                |    29 +-
 .../Hints/InlineParameterNameHintTests.fs     |   198 +-
 .../Hints/InlineTypeHintTests.fs              |    95 +-
 .../Hints/OptionParserTests.fs                |    18 +-
 .../Hints/OverallHintExperienceTests.fs       |     7 +-
 .../IndentationServiceTests.fs                |    37 +-
 .../LanguageDebugInfoServiceTests.fs          |    19 +-
 .../QuickInfoProviderTests.fs                 |    58 +-
 .../FSharp.Editor.Tests/QuickInfoTests.fs     |   140 +-
 .../RoslynSourceTextTests.fs                  |    27 +-
 ... => SemanticClassificationServiceTests.fs} |    85 +-
 .../SignatureHelpProviderTests.fs             |   186 +-
 .../SyntacticColorizationServiceTests.fs      |   305 +-
 .../FSharp.Editor.Tests/xunit.runner.json     |     7 +
 .../UnitTests/DocCommentIdParserTests.fs      |    39 +
 .../UnitTests/VisualFSharp.UnitTests.fsproj   |     3 +
 374 files changed, 33377 insertions(+), 11516 deletions(-)
 create mode 100644 buildtools/checkpackages/check.ps1
 create mode 100644 buildtools/fslex/fslexdriver.fs
 create mode 100644 buildtools/fsyacc/fsyaccdriver.fs
 mode change 100755 => 100644 src/Compiler/Service/IncrementalBuild.fsi
 create mode 100644 tests/FSharp.Compiler.ComponentTests/CompilerOptions/fsc/sourceFiles.fs
 create mode 100644 tests/FSharp.Compiler.ComponentTests/EmittedIL/Enums.fs
 create mode 100644 tests/FSharp.Compiler.ComponentTests/EmittedIL/MethodImplAttribute/MethodImplAttribute.NoInlining_InlineKeyword.fs
 create mode 100644 tests/FSharp.Compiler.ComponentTests/Interop/DeeplyNestedCSharpClasses.fs
 create mode 100644 tests/FSharp.Compiler.ComponentTests/Language/DynamicAssignmentOperatorTests.fs
 create mode 100644 tests/FSharp.Compiler.ComponentTests/Language/StaticClassTests.fs
 rename tests/FSharp.Compiler.Service.Tests/{FSharp.CompilerService.SurfaceArea.netstandard.expected => FSharp.Compiler.Service.SurfaceArea.netstandard20.debug.bsl} (98%)
 create mode 100644 tests/FSharp.Compiler.Service.Tests/FSharp.Compiler.Service.SurfaceArea.netstandard20.release.bsl
 delete mode 100644 tests/FSharp.Compiler.Service.Tests/LibraryTestFx.fs
 create mode 100644 tests/FSharp.Compiler.Service.Tests/SurfaceArea.fs
 delete mode 100644 tests/FSharp.Compiler.Service.Tests/SurfaceArea.netstandard.fs
 create mode 100644 tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.debug.bsl
 create mode 100644 tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.release.bsl
 create mode 100644 tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.debug.bsl
 create mode 100644 tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.release.bsl
 delete mode 100644 tests/FSharp.Core.UnitTests/TypeForwarding.fs
 create mode 100644 tests/FSharp.Test.Utilities/SurfaceArea.fs
 create mode 100644 tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/SomethingToCompileSmaller.fs
 delete mode 100644 tests/fsharp/TestHelpers.fs
 delete mode 100644 tests/fsharpqa/Source/InteractiveSession/Misc/E_InheritClassWithoutDefCtor.fs
 create mode 100644 tests/service/SyntaxTreeTests/ValTests.fs
 rename vsintegration/tests/FSharp.Editor.Tests/{SemanticColorizationServiceTests.fs => SemanticClassificationServiceTests.fs} (64%)
 create mode 100644 vsintegration/tests/FSharp.Editor.Tests/xunit.runner.json
 create mode 100644 vsintegration/tests/UnitTests/DocCommentIdParserTests.fs

diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile
index 74b6c7a0a39..c18a037531c 100644
--- a/.devcontainer/Dockerfile
+++ b/.devcontainer/Dockerfile
@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See https://go.microsoft.com/fwlink/?linkid=2090316 for license information.
 #-------------------------------------------------------------------------------------------------------------
 
-ARG VARIANT=7.0.100-bullseye-slim-amd64
+ARG VARIANT=7.0.102-bullseye-slim-amd64
 FROM mcr.microsoft.com/dotnet/sdk:${VARIANT}
 
 # Avoid warnings by switching to noninteractive
diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
index 4f3b8125b75..bfcf7c54e95 100644
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -6,7 +6,7 @@
         "args": {
             // Update 'VARIANT' to pick a .NET Core version: 3.1, 5.0, 6.0, 7.0
             // Append -bullseye(-slim), -focal, or -jammy to pin to an OS version.
-            "VARIANT": "7.0.100-bullseye-slim-amd64"
+            "VARIANT": "7.0.102-bullseye-slim-amd64"
         }
     },
     "hostRequirements": {
diff --git a/FSharpBuild.Directory.Build.props b/FSharpBuild.Directory.Build.props
index 0c8d9cef75c..21e531409e8 100644
--- a/FSharpBuild.Directory.Build.props
+++ b/FSharpBuild.Directory.Build.props
@@ -27,6 +27,7 @@
     <OtherFlags>$(OtherFlags) --nowarn:3384</OtherFlags>
     <OtherFlags>$(OtherFlags) --times --nowarn:75</OtherFlags>
     <OtherFlags Condition="$(ParallelCheckingWithSignatureFilesOn) == 'true'">$(OtherFlags) --test:ParallelCheckingWithSignatureFilesOn</OtherFlags>
+    <OtherFlags Condition="$(AdditionalFscCmdFlags) != ''">$(OtherFlags) $(AdditionalFscCmdFlags)</OtherFlags>
   </PropertyGroup>
 
   <!-- nuget -->
diff --git a/INTERNAL.md b/INTERNAL.md
index 4993301cb36..ec64caa69de 100644
--- a/INTERNAL.md
+++ b/INTERNAL.md
@@ -66,8 +66,13 @@ Update the `insertTargetBranch` value at the bottom of `azure-pipelines.yml` in
 ### When VS `main` is open for insertions for preview releases of VS:
 
 1. Create a new `release/dev*` branch (e.g., `release/dev17.4`) and initially set its HEAD commit to that of the previous release (e.g., `release/dev17.3` in this case).
-2. Set the new branch to receive auto-merges from `main`, and also set the old release branch to flow into the new one.  [This PR](https://github.com/dotnet/roslyn-tools/pull/1245/files) is a good example of what to do when a new `release/dev17.4` branch is created that should receive merges from both `main` and the previous release branch, `release/dev17.3`.
-3. Set the packages from the new branch to flow into the correct package feeds via the `darc` tool.  To do this:
+   ```console
+   git checkout -b release/dev17.4
+   git reset --hard upstream/release/dev17.3
+   git push --set-upstream upstream release/dev17.4
+   ```
+3. Set the new branch to receive auto-merges from `main`, and also set the old release branch to flow into the new one.  [This PR](https://github.com/dotnet/roslyn-tools/pull/1245/files) is a good example of what to do when a new `release/dev17.4` branch is created that should receive merges from both `main` and the previous release branch, `release/dev17.3`.
+4. Set the packages from the new branch to flow into the correct package feeds via the `darc` tool.  To do this:
    1. Ensure the latest `darc` tool is installed by running `eng/common/darc-init.ps1`.
    2. (only needed once) Run the command `darc authenticate`.  A text file will be opened with instructions on how to populate access tokens.
    3. Check the current package/channel subscriptions by running `darc get-default-channels --source-repo fsharp`.  For this example, notice that the latest subscription shows the F# branch `release/dev17.3` is getting added to the `VS 17.3` channel.
diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index d2590b5ba6c..3281f54c37d 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -86,11 +86,11 @@ stages:
   #                                                  Signed build                                                     #
   #-------------------------------------------------------------------------------------------------------------------#
   - ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
-    - ${{ if eq(variables['Build.SourceBranch'], 'refs/heads/release/dev17.3') }}:
+    - ${{ if eq(variables['Build.SourceBranch'], 'refs/heads/release/dev17.5') }}:
       - template: /eng/common/templates/job/onelocbuild.yml
         parameters:
           MirrorRepo: fsharp
-          MirrorBranch: release/dev17.3
+          MirrorBranch: release/dev17.5
           LclSource: lclFilesfromPackage
           LclPackageId: 'LCL-JUNO-PROD-FSHARP'
     - template: /eng/common/templates/jobs/jobs.yml
@@ -217,6 +217,13 @@ stages:
             name: $(DncEngPublicBuildPool)
             demands: ImageOverride -equals $(WindowsMachineQueueName)
           timeoutInMinutes: 90
+          strategy:
+            maxParallel: 2
+            matrix:
+              regular:
+                _experimental_flag: null
+              experimental_features:
+                _experimental_flag: 1
           steps:
           - checkout: self
             clean: true
@@ -229,6 +236,8 @@ stages:
               workingDirectory: $(Build.SourcesDirectory)
               installationPath: $(Build.SourcesDirectory)/.dotnet
           - script: .\eng\test-determinism.cmd -configuration Debug
+            env:
+              FSHARP_EXPERIMENTAL_FEATURES: $(_experimental_flag)
             displayName: Determinism tests with Debug configuration
           - task: PublishPipelineArtifact@1
             displayName: Publish Determinism Logs
@@ -264,6 +273,38 @@ stages:
               DOTNET_ROLL_FORWARD_TO_PRERELEASE: 1
             displayName: Check code formatting (run 'dotnet fantomas src -r' to fix)
 
+        # Check whether package with current version has been published to nuget.org
+        # We will try to restore both FSharp.Core and FCS and if restore is _successful_, package version needs to be bumped.
+        # NOTE: This CI check should only run on the release branches.
+        - job: Check_Published_Package_Versions
+          condition: or(startsWith(variables['Build.SourceBranch'], 'refs/heads/release/'), or(startsWith(variables['System.PullRequest.SourceBranch'], 'release/dev'), startsWith(variables['System.PullRequest.TargetBranch'], 'release/dev')))
+          pool:
+            vmImage: $(UbuntuMachineQueueName)
+          strategy:
+            maxParallel: 2
+            matrix:
+              FCS:
+                _project: "FSharp.Compiler.Service_notshipped.fsproj"
+              FSCore:
+                _project: "FSharp.Core_notshipped.fsproj"
+          steps:
+          - checkout: self
+            clean: true
+          - task: UseDotNet@2
+            displayName: install SDK
+            inputs:
+              packageType: sdk
+              useGlobalJson: true
+              includePreviewVersions: true
+              workingDirectory: $(Build.SourcesDirectory)
+              installationPath: $(Agent.ToolsDirectory)/dotnet
+          - pwsh: ./check.ps1 -project $(_project)
+            workingDirectory: $(Build.SourcesDirectory)/buildtools/checkpackages
+            env:
+                DOTNET_ROLL_FORWARD_TO_PRERELEASE: 1
+            displayName: Check published package version
+
+
   #-------------------------------------------------------------------------------------------------------------------#
   #                                                    PR builds                                                      #
   #-------------------------------------------------------------------------------------------------------------------#
@@ -280,64 +321,6 @@ stages:
         helixRepo: dotnet/fsharp
         jobs:
 
-        # Windows
-        - job: Windows
-          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
-          strategy:
-            maxParallel: 4
-            matrix:
-              desktop_release:
-                _configuration: Release
-                _testKind: testDesktop
-              coreclr_release:
-                _configuration: Release
-                _testKind: testCoreclr
-              fsharpqa_release:
-                _configuration: Release
-                _testKind: testFSharpQA
-              vs_release:
-                _configuration: Release
-                _testKind: testVs
-          steps:
-          - checkout: self
-            clean: true
-          - script: eng\CIBuild.cmd -configuration $(_configuration) -$(_testKind)
-            displayName: Build / Test
-          - task: PublishTestResults@2
-            displayName: Publish Test Results
-            inputs:
-              testResultsFormat: 'NUnit'
-              testResultsFiles: '*.xml'
-              searchFolder: '$(Build.SourcesDirectory)/artifacts/TestResults/$(_configuration)'
-            continueOnError: true
-            condition: ne(variables['_testKind'], 'testFSharpQA')
-          - task: PublishBuildArtifacts@1
-            displayName: Publish Test Logs
-            inputs:
-              PathtoPublish: '$(Build.SourcesDirectory)\artifacts\TestResults\$(_configuration)'
-              ArtifactName: 'Windows $(_configuration) $(_testKind) test logs'
-              publishLocation: Container
-            continueOnError: true
-            condition: failed()
-          - script: dotnet build $(Build.SourcesDirectory)/eng/DumpPackageRoot/DumpPackageRoot.csproj
-            displayName: Dump NuGet cache contents
-            condition: failed()
-          - task: PublishBuildArtifacts@1
-            displayName: Publish NuGet cache contents
-            inputs:
-              PathtoPublish: '$(Build.SourcesDirectory)\artifacts\NugetPackageRootContents'
-              ArtifactName: 'NuGetPackageContents Windows $(_testKind)'
-              publishLocation: Container
-            continueOnError: true
-            condition: failed()
-
         # Windows With Compressed Metadata
         - job: WindowsCompressedMetadata
           pool:
@@ -492,11 +475,22 @@ stages:
           pool:
             name: $(DncEngPublicBuildPool)
             demands: ImageOverride -equals $(WindowsMachineQueueName)
+          strategy:
+            maxParallel: 2
+            matrix:
+              regular:
+                _experimental_flag: null
+              experimental_features:
+                _experimental_flag: 1
           steps:
           - checkout: self
             clean: true
           - script: .\Build.cmd -c Release -pack
+            env:
+              FSHARP_EXPERIMENTAL_FEATURES: $(_experimental_flag)
           - script: .\tests\EndToEndBuildTests\EndToEndBuildTests.cmd -c Release
+            env:
+              FSHARP_EXPERIMENTAL_FEATURES: $(_experimental_flag)
             displayName: End to end build tests
 
         # Up-to-date - disabled due to it being flaky
@@ -512,35 +506,8 @@ stages:
         #      filePath: eng\tests\UpToDate.ps1
         #      arguments: -configuration $(_BuildConfig) -ci -binaryLog
 
-        # Run Build with --test:ParallelCheckingWithSignatureFilesOn
-        - job: ParallelCheckingWithSignatureFiles
-          condition: eq(variables['Build.Reason'], 'PullRequest')
-          variables:
-            - name: _SignType
-              value: Test
-          pool:
-            name: $(DncEngPublicBuildPool)
-            demands: ImageOverride -equals $(WindowsMachineQueueName)
-          timeoutInMinutes: 90
-          steps:
-            - checkout: self
-              clean: true
-            - task: UseDotNet@2
-              displayName: install SDK
-              inputs:
-                packageType: sdk
-                useGlobalJson: true
-                includePreviewVersions: false
-                workingDirectory: $(Build.SourcesDirectory)
-                installationPath: $(Build.SourcesDirectory)/.dotnet
-            - script: .\build.cmd -c Release -binaryLog /p:ParallelCheckingWithSignatureFilesOn=true
-              displayName: ParallelCheckingWithSignatureFiles build with Debug configuration
-            - task: PublishPipelineArtifact@1
-              displayName: Publish ParallelCheckingWithSignatureFiles Logs
-              inputs:
-                targetPath: '$(Build.SourcesDirectory)/artifacts/log/Release'
-                artifactName: 'ParallelCheckingWithSignatureFiles Attempt $(System.JobAttempt) Logs'
-              continueOnError: true
+        # Run Build with Fsharp Experimental Features
+        # Possible change: --times:$(Build.SourcesDirectory)/artifacts/log/Release/compiler_timing.csv
 
         # Plain build Windows
         - job: Plain_Build_Windows
@@ -731,8 +698,8 @@ stages:
 - ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
   - template: eng/release/insert-into-vs.yml
     parameters:
-      componentBranchName: refs/heads/release/dev17.3
-      insertTargetBranch: rel/d17.3
+      componentBranchName: refs/heads/release/dev17.5
+      insertTargetBranch: rel/d17.5
       insertTeamEmail: fsharpteam@microsoft.com
       insertTeamName: 'F#'
       completeInsertion: 'auto'
diff --git a/buildtools/README-fslexyacc.md b/buildtools/README-fslexyacc.md
index ec2d976294e..51630ddd143 100644
--- a/buildtools/README-fslexyacc.md
+++ b/buildtools/README-fslexyacc.md
@@ -35,7 +35,7 @@ However long ago we decided to duplicate and ingest the _runtime_ files for FsLe
 
 This means you can improve some aspects of the _runtime_ for FsLex and FsYacc by making direct changes to `prim-lexing.fs` and `prim-parsing.fs`.
 
-For example, the _actual_ `LexBuffer` type being used in the F# compiler (for all three lexers and grammars) is this one: https://github.com/Microsoft/visualfsharp/blob/master/src/utils/prim-lexing.fsi#L50.  (That version of the Lex/Yacc runtime has added some things: `BufferLocalStore` for example, which we use for the `XmlDoc` accumulator as we strip those out. It's also dropped any mention of async lexing, and any mention of `byte`. The use
+For example, the _actual_ `LexBuffer` type being used in the F# compiler (for all three lexers and grammars) is this one: https://github.com/dotnet/fsharp/blob/bdb64624f0ca220ca4433c83d02dd5822fe767a5/src/Compiler/Facilities/prim-lexing.fsi#L102 .  (That version of the Lex/Yacc runtime has added some things: `BufferLocalStore` for example, which we use for the `XmlDoc` accumulator as we strip those out. It's also dropped any mention of async lexing, and any mention of `byte`. The use
 of generics for `LexBuffer<'Char>` is also superfluous because `'Char` is always `char` but is needed because the FsLex/FsYacc generated code expects this type to be generic.)
 
 ## What if I want to eridicate our use of FsLex and FsYacc?
diff --git a/buildtools/checkpackages/Directory.Build.targets b/buildtools/checkpackages/Directory.Build.targets
index 8c119d5413b..faf2349bae2 100644
--- a/buildtools/checkpackages/Directory.Build.targets
+++ b/buildtools/checkpackages/Directory.Build.targets
@@ -1,2 +1,3 @@
 <Project>
+
 </Project>
diff --git a/buildtools/checkpackages/FSharp.Compiler.Service_notshipped.fsproj b/buildtools/checkpackages/FSharp.Compiler.Service_notshipped.fsproj
index f5204fd5c67..a9166e35340 100644
--- a/buildtools/checkpackages/FSharp.Compiler.Service_notshipped.fsproj
+++ b/buildtools/checkpackages/FSharp.Compiler.Service_notshipped.fsproj
@@ -20,4 +20,12 @@
     <PackageReference Include="FSharp.Compiler.Service" Version="[$(FSharpCompilerServicePackageVersion)]" />
   </ItemGroup>
 
+  <Target Name="WritePackageVersion" BeforeTargets="Restore">
+      <WriteLinesToFile
+          File="Version.txt"
+          Lines="FSharp.Compiler.Service=$(FSharpCompilerServicePackageVersion)"
+          Overwrite="true"
+          Encoding="Unicode"/>
+  </Target>
+
 </Project>
diff --git a/buildtools/checkpackages/FSharp.Core_notshipped.fsproj b/buildtools/checkpackages/FSharp.Core_notshipped.fsproj
index 5942f999fd8..7299f5aec7a 100644
--- a/buildtools/checkpackages/FSharp.Core_notshipped.fsproj
+++ b/buildtools/checkpackages/FSharp.Core_notshipped.fsproj
@@ -14,4 +14,12 @@
     <PackageReference Include="FSharp.Core" Version="[$(FSCorePackageVersionValue)]" />
   </ItemGroup>
 
+  <Target Name="WritePackageVersion" BeforeTargets="Restore">
+      <WriteLinesToFile
+          File="Version.txt"
+          Lines="FSharp.Core=$(FSCorePackageVersionValue)"
+          Overwrite="true"
+          Encoding="Unicode"/>
+  </Target>
+
 </Project>
diff --git a/buildtools/checkpackages/check.ps1 b/buildtools/checkpackages/check.ps1
new file mode 100644
index 00000000000..d956de90789
--- /dev/null
+++ b/buildtools/checkpackages/check.ps1
@@ -0,0 +1,17 @@
+# ENTRY POINT MAIN()
+Param(
+    [Parameter(Mandatory=$True)]
+    [String] $project
+)
+& dotnet restore $project 2>$null
+
+if ($LASTEXITCODE -eq 0)
+{
+    $package = Get-Content -Path .\Version.txt
+    Write-Error "
+        Package restore succeded for '${package}', expected to fail.
+        This usually means that the package has been already published.
+        Please, bump the version to fix this failure." -ErrorAction Stop
+} else {
+    exit 0
+}
diff --git a/buildtools/fslex/Arg.fs b/buildtools/fslex/Arg.fs
index b1131625cf3..d6f8ed790e3 100644
--- a/buildtools/fslex/Arg.fs
+++ b/buildtools/fslex/Arg.fs
@@ -1,11 +1,6 @@
 // (c) Microsoft Corporation 2005-2009. 
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-namespace Internal.Utilities
-#else
-namespace Microsoft.FSharp.Text
-#endif
-
+namespace FSharp.Text
 
 type ArgType = 
   | ClearArg of bool ref
@@ -35,17 +30,17 @@ exception HelpText of string
 [<Sealed>]
 type ArgParser() = 
     static let getUsage specs u =  
-      let sbuf = new System.Text.StringBuilder 100  
+      let sbuf = System.Text.StringBuilder 100  
       let pstring (s:string) = sbuf.Append s |> ignore 
       let pendline s = pstring s; pstring "\n" 
       pendline u;
       List.iter (fun (arg:ArgInfo) -> 
         match arg.Name, arg.ArgType, arg.HelpText with
-        | (s, (UnitArg _ | SetArg _ | ClearArg _), helpText) -> pstring "\t"; pstring s; pstring ": "; pendline helpText
-        | (s, StringArg _, helpText) -> pstring "\t"; pstring s; pstring " <string>: "; pendline helpText
-        | (s, IntArg _, helpText) -> pstring "\t"; pstring s; pstring " <int>: "; pendline helpText
-        | (s, FloatArg _, helpText) ->  pstring "\t"; pstring s; pstring " <float>: "; pendline helpText
-        | (s, RestArg _, helpText) -> pstring "\t"; pstring s; pstring " ...: "; pendline helpText)
+        | s, (UnitArg _ | SetArg _ | ClearArg _), helpText -> pstring "\t"; pstring s; pstring ": "; pendline helpText
+        | s, StringArg _, helpText -> pstring "\t"; pstring s; pstring " <string>: "; pendline helpText
+        | s, IntArg _, helpText -> pstring "\t"; pstring s; pstring " <int>: "; pendline helpText
+        | s, FloatArg _, helpText ->  pstring "\t"; pstring s; pstring " <float>: "; pendline helpText
+        | s, RestArg _, helpText -> pstring "\t"; pstring s; pstring " ...: "; pendline helpText)
         specs;
       pstring "\t"; pstring "--help"; pstring ": "; pendline "display this list of options";
       pstring "\t"; pstring "-help"; pstring ": "; pendline "display this list of options";
@@ -53,20 +48,20 @@ type ArgParser() =
 
 
     static member ParsePartial(cursor,argv,arguments:seq<ArgInfo>,?otherArgs,?usageText) =
-        let otherArgs = defaultArg otherArgs (fun _ -> ())
+        let other = defaultArg otherArgs (fun _ -> ())
         let usageText = defaultArg usageText ""
         let nargs = Array.length argv 
         incr cursor;
-        let arguments = arguments |> Seq.toList
-        let specs = arguments |> List.map (fun (arg:ArgInfo) -> arg.Name, arg.ArgType)
+        let argSpecs = arguments |> Seq.toList
+        let specs = argSpecs |> List.map (fun (arg:ArgInfo) -> arg.Name, arg.ArgType)
         while !cursor < nargs do
           let arg = argv.[!cursor] 
           let rec findMatchingArg args = 
             match args with
-            | ((s, action) :: _) when s = arg -> 
+            | (s, action) :: _ when s = arg -> 
                let getSecondArg () = 
                    if !cursor + 1 >= nargs then 
-                     raise(Bad("option "+s+" needs an argument.\n"+getUsage arguments usageText));
+                     raise(Bad("option "+s+" needs an argument.\n"+getUsage argSpecs usageText));
                    argv.[!cursor+1] 
                  
                match action with 
@@ -85,40 +80,40 @@ type ArgParser() =
                  cursor := !cursor + 2
                | IntArg f -> 
                  let arg2 = getSecondArg () 
-                 let arg2 = try int32 arg2 with _ -> raise(Bad(getUsage arguments usageText)) in  
+                 let arg2 = try int32 arg2 with _ -> raise(Bad(getUsage argSpecs usageText)) in  
                  f arg2;
                  cursor := !cursor + 2;
                | FloatArg f -> 
                  let arg2 = getSecondArg() 
-                 let arg2 = try float arg2 with _ -> raise(Bad(getUsage arguments usageText)) in 
+                 let arg2 = try float arg2 with _ -> raise(Bad(getUsage argSpecs usageText)) in 
                  f arg2; 
                  cursor := !cursor + 2;
                | RestArg f -> 
                  incr cursor;
                  while !cursor < nargs do
-                     f (argv.[!cursor]);
+                     f argv.[!cursor];
                      incr cursor;
 
-            | (_ :: more)  -> findMatchingArg more 
+            | _ :: more  -> findMatchingArg more 
             | [] -> 
                 if arg = "-help" || arg = "--help" || arg = "/help" || arg = "/help" || arg = "/?" then
-                    raise (HelpText (getUsage arguments usageText))
+                    raise (HelpText (getUsage argSpecs usageText))
                 // Note: for '/abc/def' does not count as an argument
                 // Note: '/abc' does
-                elif arg.Length>0 && (arg.[0] = '-' || (arg.[0] = '/' && not (arg.Length > 1 && arg.[1..].Contains ("/")))) then
-                    raise (Bad ("unrecognized argument: "+ arg + "\n" + getUsage arguments usageText))
+                elif arg.Length>0 && (arg.[0] = '-' || (arg.[0] = '/' && not (arg.Length > 1 && arg.[1..].Contains "/"))) then
+                    raise (Bad ("unrecognized argument: "+ arg + "\n" + getUsage argSpecs usageText))
                 else 
-                   otherArgs arg;
+                   other arg;
                    incr cursor
           findMatchingArg specs 
 
-    static member Usage (arguments,?usage) = 
+    static member Usage (arguments, ?usage) = 
         let usage = defaultArg usage ""
         System.Console.Error.WriteLine (getUsage (Seq.toList arguments) usage)
 
     #if FX_NO_COMMAND_LINE_ARGS
     #else
-    static member Parse (arguments,?otherArgs,?usageText) = 
+    static member Parse (arguments, ?otherArgs,?usageText) = 
         let current = ref 0
         let argv = System.Environment.GetCommandLineArgs() 
         try ArgParser.ParsePartial (current, argv, arguments, ?otherArgs=otherArgs, ?usageText=usageText)
@@ -128,6 +123,6 @@ type ArgParser() =
               System.Console.Error.WriteLine h; 
               System.Console.Error.Flush();  
               System.Environment.Exit(1); 
-          | e -> 
+          | _ -> 
               reraise()
     #endif
diff --git a/buildtools/fslex/Arg.fsi b/buildtools/fslex/Arg.fsi
index 367f69f959f..b5203999928 100644
--- a/buildtools/fslex/Arg.fsi
+++ b/buildtools/fslex/Arg.fsi
@@ -1,11 +1,7 @@
 // (c) Microsoft Corporation 2005-2009. 
 
 /// A simple command-line argument processor.
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-namespace Internal.Utilities
-#else
-namespace Microsoft.FSharp.Text
-#endif
+namespace FSharp.Text
 
 /// The spec value describes the action of the argument,
 /// and whether it expects a following parameter.
@@ -37,7 +33,7 @@ type ArgParser =
     [<System.Obsolete("This method should not be used directly as it will be removed in a future revision of this library")>]
     static member ParsePartial: cursor: int ref * argv: string[] * arguments:seq<ArgInfo> * ?otherArgs: (string -> unit) * ?usageText:string -> unit
 
-    /// Parse the arguments given by System.Environment.GetEnvironmentVariables()
+    /// Parse the arguments given by System.Environment.GetCommandLineArgs()
     /// according to the argument processing specifications "specs".
     /// Args begin with "-". Non-arguments are passed to "f" in
     /// order.  "use" is printed as part of the usage line if an error occurs.
diff --git a/buildtools/fslex/Lexing.fs b/buildtools/fslex/Lexing.fs
index 760ace5a932..40aacdcac96 100644
--- a/buildtools/fslex/Lexing.fs
+++ b/buildtools/fslex/Lexing.fs
@@ -1,423 +1,456 @@
 // (c) Microsoft Corporation 2005-2009.
+module FSharp.Text.Lexing
 
 #nowarn "47" // recursive initialization of LexBuffer
 
+open System.Collections.Generic
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-namespace Internal.Utilities.Text.Lexing
-
-#else
-namespace Microsoft.FSharp.Text.Lexing 
-#endif
-
-    open System.Collections.Generic
-
-    // REVIEW: This type showed up on a parsing-intensive performance measurement. Consider whether it can be a struct-record later when we have this feature. -jomo
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-    type internal Position = 
-#else
-    type Position = 
-#endif
-        { pos_fname : string;
-          pos_lnum : int;
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-          pos_orig_lnum : int;
-#endif
-          pos_bol : int;
-          pos_cnum : int; }
-        member x.FileName = x.pos_fname
-        member x.Line = x.pos_lnum
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-        member x.OriginalLine = x.pos_orig_lnum
-#endif
-        member x.Char = x.pos_cnum
-        member x.AbsoluteOffset = x.pos_cnum
-        member x.StartOfLine = x.pos_bol
-        member x.StartOfLineAbsoluteOffset = x.pos_bol
-        member x.Column = x.pos_cnum - x.pos_bol
-        member pos.NextLine = 
-            { pos with 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-                    pos_orig_lnum = pos.OriginalLine + 1;
-#endif
-                    pos_lnum = pos.Line+1; 
-                    pos_bol = pos.AbsoluteOffset }
-        member pos.EndOfToken(n) = {pos with pos_cnum=pos.pos_cnum + n }
-        member pos.AsNewLinePos() = pos.NextLine
-        member pos.ShiftColumnBy(by) = {pos with pos_cnum = pos.pos_cnum + by}
-        static member Empty = 
-            { pos_fname=""; 
-              pos_lnum= 0; 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-              pos_orig_lnum = 0;
-#endif
-              pos_bol= 0; 
-              pos_cnum=0 }
-        static member FirstLine(filename) = 
-            { pos_fname=filename; 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-              pos_orig_lnum = 1;
-#endif
-              pos_lnum= 1; 
-              pos_bol= 0; 
-              pos_cnum=0 }
-
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-    type internal LexBufferFiller<'char> = 
-#else
-    type LexBufferFiller<'char> = 
-#endif
-        { fillSync : (LexBuffer<'char> -> unit) option
-          fillAsync : (LexBuffer<'char> -> Async<unit>) option } 
-        
-    and [<Sealed>]
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-        internal LexBuffer<'char>(filler: LexBufferFiller<'char>) as this = 
-#else
-        LexBuffer<'char>(filler: LexBufferFiller<'char>) as this = 
-#endif
-        let context = new Dictionary<string,obj>(1) in 
-        let extendBufferSync = (fun () -> match filler.fillSync with Some refill -> refill this | None -> invalidOp "attempt to read synchronously from an asynchronous lex buffer")
-        let extendBufferAsync = (fun () -> match filler.fillAsync with Some refill -> refill this | None -> invalidOp "attempt to read asynchronously from a synchronous lex buffer")
-        let mutable buffer=[||];
-        /// number of valid charactes beyond bufferScanStart 
-        let mutable bufferMaxScanLength=0;
-        /// count into the buffer when scanning 
-        let mutable bufferScanStart=0;
-        /// number of characters scanned so far 
-        let mutable bufferScanLength=0;
-        /// length of the scan at the last accepting state 
-        let mutable lexemeLength=0;
-        /// action related to the last accepting state 
-        let mutable bufferAcceptAction=0;
-        let mutable eof = false;
-        let mutable startPos = Position.Empty ;
-        let mutable endPos = Position.Empty
-
-        // Throw away all the input besides the lexeme 
-              
-        let discardInput () = 
-            let keep = Array.sub buffer bufferScanStart bufferScanLength
-            let nkeep = keep.Length 
-            Array.blit keep 0 buffer 0 nkeep;
-            bufferScanStart <- 0;
-            bufferMaxScanLength <- nkeep
-                 
-              
-        member lexbuf.EndOfScan () : int =
-            // Printf.eprintf "endOfScan, lexBuffer.lexemeLength = %d\n" lexBuffer.lexemeLength;
-            if bufferAcceptAction < 0 then 
-                failwith "unrecognized input"
-
-            //  Printf.printf "endOfScan %d state %d on unconsumed input '%c' (%d)\n" a s (Char.chr inp) inp;
-            //   Printf.eprintf "accept, lexeme = %s\n" (lexeme lexBuffer); 
-            lexbuf.StartPos <- endPos;
-            lexbuf.EndPos <- endPos.EndOfToken(lexbuf.LexemeLength);
-            bufferAcceptAction
-
-        member lexbuf.StartPos
-           with get() = startPos
-           and  set(b) =  startPos <- b
-           
-        member lexbuf.EndPos 
-           with get() = endPos
-           and  set(b) =  endPos <- b
-
-        member lexbuf.Lexeme         = Array.sub buffer bufferScanStart lexemeLength
-        member lexbuf.LexemeChar(n)  = buffer.[n+bufferScanStart]
-        
-        member lexbuf.BufferLocalStore = (context :> IDictionary<_,_>)
-        member lexbuf.LexemeLength        with get() : int = lexemeLength    and set v = lexemeLength <- v
-        member internal lexbuf.Buffer              with get() : 'char[] = buffer              and set v = buffer <- v
-        member internal lexbuf.BufferMaxScanLength with get() = bufferMaxScanLength and set v = bufferMaxScanLength <- v
-        member internal lexbuf.BufferScanLength    with get() = bufferScanLength    and set v = bufferScanLength <- v
-        member internal lexbuf.BufferScanStart     with get() : int = bufferScanStart     and set v = bufferScanStart <- v
-        member internal lexbuf.BufferAcceptAction  with get() = bufferAcceptAction  and set v = bufferAcceptAction <- v
-        member internal lexbuf.RefillBuffer = extendBufferSync
-        member internal lexbuf.AsyncRefillBuffer = extendBufferAsync
-
-        static member LexemeString(lexbuf:LexBuffer<char>) = 
-            new System.String(lexbuf.Buffer,lexbuf.BufferScanStart,lexbuf.LexemeLength)
-
-        member lexbuf.IsPastEndOfStream 
-           with get() = eof
-           and  set(b) =  eof <- b
-
-        member lexbuf.DiscardInput() = discardInput ()
-
-        member x.BufferScanPos = bufferScanStart + bufferScanLength
-
-        member lexbuf.EnsureBufferSize n = 
-            if lexbuf.BufferScanPos + n >= buffer.Length then 
-                let repl = Array.zeroCreate (lexbuf.BufferScanPos + n) 
-                Array.blit buffer bufferScanStart repl bufferScanStart bufferScanLength;
-                buffer <- repl
-
-        static member FromReadFunctions (syncRead : ('char[] * int * int -> int) option, asyncRead : ('char[] * int * int -> Async<int>) option) : LexBuffer<'char> = 
-            let extension= Array.zeroCreate 4096
-            let fillers = 
-                { fillSync = 
-                    match syncRead with 
-                    | None -> None
-                    | Some read -> 
-                         Some (fun lexBuffer -> 
-                             let n = read(extension,0,extension.Length)
-                             lexBuffer.EnsureBufferSize n;
-                             Array.blit extension 0 lexBuffer.Buffer lexBuffer.BufferScanPos n;
-                             lexBuffer.BufferMaxScanLength <- lexBuffer.BufferScanLength + n); 
-                  fillAsync = 
-                    match asyncRead with 
-                    | None -> None
-                    | Some read -> 
-                         Some (fun lexBuffer -> 
-                                  async { 
-                                      let! n = read(extension,0,extension.Length)
-                                      lexBuffer.EnsureBufferSize n;
-                                      Array.blit extension 0 lexBuffer.Buffer lexBuffer.BufferScanPos n;
-                                      lexBuffer.BufferMaxScanLength <- lexBuffer.BufferScanLength + n }) }
-            new LexBuffer<_>(fillers)
-
-        // A full type signature is required on this method because it is used at more specific types within its own scope
-        static member FromFunction (f : 'char[] * int * int -> int) : LexBuffer<'char> =  LexBuffer<_>.FromReadFunctions(Some(f),None)
-        static member FromAsyncFunction (f : 'char[] * int * int -> Async<int>) : LexBuffer<'char> =  LexBuffer<_>.FromReadFunctions(None,Some(f))
-              
-        static member FromCharFunction f : LexBuffer<char> = 
-            LexBuffer<char>.FromFunction(fun (buff,start,len) -> 
-                let buff2 = Array.zeroCreate len
-                let n = f buff2 len 
-                Array.blit buff2 0 buff start len
-                n)
-        static member FromByteFunction f : LexBuffer<byte> = 
-            LexBuffer<byte>.FromFunction(fun (buff,start,len) -> 
-                let buff2 = Array.zeroCreate len
-                let n = f buff2 len 
-                Array.blit buff2 0 buff start len
-                n)
-
-        // A full type signature is required on this method because it is used at more specific types within its own scope
-        static member FromArray (s: 'char[]) : LexBuffer<'char> = 
-            let lexBuffer = 
-                new LexBuffer<_> 
-                    { fillSync = Some (fun _ -> ()); 
-                      fillAsync = Some (fun _ -> async { return () }) }
-            let buffer = Array.copy s 
-            lexBuffer.Buffer <- buffer;
-            lexBuffer.BufferMaxScanLength <- buffer.Length;
-            lexBuffer
-
-        static member FromBytes    (arr) = LexBuffer<byte>.FromArray(arr)
-        static member FromChars    (arr) = LexBuffer<char>.FromArray(arr) 
-        static member FromString (s:string) = LexBuffer<char>.FromChars (s.ToCharArray())
-
-        static member FromTextReader (tr:System.IO.TextReader)  : LexBuffer<char> = 
-           LexBuffer<char>.FromFunction(tr.Read) 
-
-        static member FromBinaryReader (br:System.IO.BinaryReader)  : LexBuffer<byte> = 
-           LexBuffer<byte>.FromFunction(br.Read) 
-
-        static member FromStream (stream:System.IO.Stream)  : LexBuffer<byte> = 
-           LexBuffer<byte>.FromReadFunctions(Some(stream.Read),Some(fun (buf,offset,len) -> stream.AsyncRead(buf,offset=offset,count=len))) 
-
-    module GenericImplFragments = 
-        let startInterpret(lexBuffer:LexBuffer<_>)= 
-            lexBuffer.BufferScanStart <- lexBuffer.BufferScanStart + lexBuffer.LexemeLength;
-            lexBuffer.BufferMaxScanLength <- lexBuffer.BufferMaxScanLength - lexBuffer.LexemeLength;
-            lexBuffer.BufferScanLength <- 0;
-            lexBuffer.LexemeLength <- 0;
-            lexBuffer.BufferAcceptAction <- -1;
-
-        let afterRefill (trans: uint16[] array,sentinel,lexBuffer:LexBuffer<_>,scanUntilSentinel,endOfScan,state,eofPos) = 
-            // end of file occurs if we couldn't extend the buffer 
-            if lexBuffer.BufferScanLength = lexBuffer.BufferMaxScanLength then  
-                let snew = int trans.[state].[eofPos] // == EOF 
-                if snew = sentinel then 
-                    endOfScan()
-                else 
-                    if lexBuffer.IsPastEndOfStream then failwith "End of file on lexing stream";
-                    lexBuffer.IsPastEndOfStream <- true;
-                    // Printf.printf "state %d --> %d on eof\n" state snew;
-                    scanUntilSentinel(lexBuffer,snew)
-            else 
-                scanUntilSentinel(lexBuffer, state)
+// REVIEW: This type showed up on a parsing-intensive performance measurement. Consider whether it can be a struct-record later when we have this feature. -jomo
+[<Struct>]
+type Position = 
+    { pos_fname : string
+      pos_lnum : int
+      pos_orig_lnum : int
+      pos_bol : int
+      pos_cnum : int }
 
-        let onAccept (lexBuffer:LexBuffer<_>,a) = 
-            lexBuffer.LexemeLength <- lexBuffer.BufferScanLength;
-            lexBuffer.BufferAcceptAction <- a;
+    member pos.FileName = pos.pos_fname
 
-    open GenericImplFragments
+    member pos.Line = pos.pos_lnum
 
-    [<Sealed>]
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-    type internal AsciiTables(trans: uint16[] array, accept: uint16[]) =
-#else
-    type AsciiTables(trans: uint16[] array, accept: uint16[]) =
-#endif
-        let rec scanUntilSentinel(lexBuffer, state) =
-            let sentinel = 255 * 256 + 255 
-            // Return an endOfScan after consuming the input 
-            let a = int accept.[state] 
-            if a <> sentinel then 
-                onAccept (lexBuffer,a)
-            
-            if lexBuffer.BufferScanLength = lexBuffer.BufferMaxScanLength then 
-                lexBuffer.DiscardInput();
-                lexBuffer.RefillBuffer ();
-              // end of file occurs if we couldn't extend the buffer 
-                afterRefill (trans,sentinel,lexBuffer,scanUntilSentinel,lexBuffer.EndOfScan,state,256 (* == EOF *) )
-            else
-                // read a character - end the scan if there are no further transitions 
-                let inp = int(lexBuffer.Buffer.[lexBuffer.BufferScanPos])
-                let snew = int trans.[state].[inp] 
-                if snew = sentinel then 
-                    lexBuffer.EndOfScan()
-                else 
-                    lexBuffer.BufferScanLength <- lexBuffer.BufferScanLength + 1;
-                    // Printf.printf "state %d --> %d on '%c' (%d)\n" state snew (Char.chr inp) inp;
-                    scanUntilSentinel(lexBuffer, snew)
-            
-        /// Interpret tables for an ascii lexer generated by fslex. 
-        member tables.Interpret(initialState,lexBuffer : LexBuffer<byte>) = 
-            startInterpret(lexBuffer)
-            scanUntilSentinel(lexBuffer, initialState)
+    member pos.OriginalLine = pos.pos_orig_lnum
 
-        /// Interpret tables for an ascii lexer generated by fslex. 
-        member tables.AsyncInterpret(initialState,lexBuffer : LexBuffer<byte>) = 
-        
-            let rec scanUntilSentinel(lexBuffer,state) : Async<int> = 
-                async {  
-                    let sentinel = 255 * 256 + 255 
-                    // Return an endOfScan after consuming the input 
-                    let a = int accept.[state] 
-                    if a <> sentinel then 
-                        onAccept (lexBuffer,a)
-                    
-                    if lexBuffer.BufferScanLength = lexBuffer.BufferMaxScanLength then 
-                        lexBuffer.DiscardInput();
-                        do! lexBuffer.AsyncRefillBuffer ();
-                       // end of file occurs if we couldn't extend the buffer 
-                        return! afterRefill (trans,sentinel,lexBuffer,scanUntilSentinel,endOfScan,state,256 (* == EOF *) )
-                    else
-                        // read a character - end the scan if there are no further transitions 
-                        let inp = int(lexBuffer.Buffer.[lexBuffer.BufferScanPos])
-                        let snew = int trans.[state].[inp] 
-                        if snew = sentinel then 
-                            return! endOfScan()
-                        else 
-                            lexBuffer.BufferScanLength <- lexBuffer.BufferScanLength + 1;
-                            return! scanUntilSentinel(lexBuffer,snew)
-                }
-            and endOfScan() = 
-                async { return lexBuffer.EndOfScan() }
-            startInterpret(lexBuffer)
-            scanUntilSentinel(lexBuffer, initialState)
-
-
-        static member Create(trans,accept) = new AsciiTables(trans,accept)
-
-    [<Sealed>]
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-    type internal UnicodeTables(trans: uint16[] array, accept: uint16[]) = 
-#else
-    type UnicodeTables(trans: uint16[] array, accept: uint16[]) = 
-#endif
+    member pos.Char = pos.pos_cnum
+
+    member pos.AbsoluteOffset = pos.pos_cnum
+
+    member pos.StartOfLine = pos.pos_bol
+
+    member pos.StartOfLineAbsoluteOffset = pos.pos_bol
+
+    member pos.Column = pos.pos_cnum - pos.pos_bol
+
+    member pos.NextLine = 
+        let pos = pos
+        { pos with 
+                pos_orig_lnum = pos.OriginalLine + 1
+                pos_lnum = pos.Line+1 
+                pos_bol = pos.AbsoluteOffset }
+
+    member pos.EndOfToken(n) = 
+        let pos = pos
+        {pos with pos_cnum=pos.pos_cnum + n }
+
+    member pos.AsNewLinePos() = pos.NextLine
+
+    member pos.ShiftColumnBy(by) = 
+        let pos = pos
+        {pos with pos_cnum = pos.pos_cnum + by}
+
+    static member Empty = 
+        { pos_fname="" 
+          pos_lnum= 0 
+          pos_orig_lnum = 0
+          pos_bol= 0 
+          pos_cnum=0 }
+
+    static member FirstLine(filename) = 
+        { pos_fname=filename 
+          pos_orig_lnum = 1
+          pos_lnum= 1 
+          pos_bol= 0 
+          pos_cnum=0 }
+
+type LexBufferFiller<'char> = 
+    { fillSync : (LexBuffer<'char> -> unit) option
+      fillAsync : (LexBuffer<'char> -> Async<unit>) option } 
+    
+and [<Sealed>]
+    LexBuffer<'char>(filler: LexBufferFiller<'char>) as this = 
+    let context = Dictionary<string, obj>(1) in 
+    let extendBufferSync = (fun () -> match filler.fillSync with Some refill -> refill this | None -> invalidOp "attempt to read synchronously from an asynchronous lex buffer")
+    let extendBufferAsync = (fun () -> match filler.fillAsync with Some refill -> refill this | None -> invalidOp "attempt to read asynchronously from a synchronous lex buffer")
+    let mutable buffer=[||]
+
+    /// number of valid charactes beyond bufferScanStart 
+    let mutable bufferMaxScanLength=0
+
+    /// count into the buffer when scanning 
+    let mutable bufferScanStart=0
+
+    /// number of characters scanned so far 
+    let mutable bufferScanLength=0
+
+    /// length of the scan at the last accepting state 
+    let mutable lexemeLength=0
+
+    /// action related to the last accepting state 
+    let mutable bufferAcceptAction=0
+
+    let mutable eof = false
+
+    let mutable startPos = Position.Empty 
+
+    let mutable endPos = Position.Empty
+
+    /// Throw away all the input besides the lexeme      
+    let discardInput () = 
+        Array.blit buffer bufferScanStart buffer 0 bufferScanLength
+        bufferScanStart <- 0
+        bufferMaxScanLength <- bufferScanLength
+             
+    member lexbuf.EndOfScan () : int =
+        // Printf.eprintf "endOfScan, lexBuffer.lexemeLength = %d\n" lexBuffer.lexemeLength
+        if bufferAcceptAction < 0 then 
+            failwith "unrecognized input"
+
+        // Printf.printf "endOfScan %d state %d on unconsumed input '%c' (%d)\n" a s (Char.chr inp) inp
+        // Printf.eprintf "accept, lexeme = %s\n" (lexeme lexBuffer) 
+        lexbuf.StartPos <- endPos
+        lexbuf.EndPos <- endPos.EndOfToken(lexbuf.LexemeLength)
+        bufferAcceptAction
+
+    member _.StartPos
+       with get() = startPos
+       and  set b = startPos <- b
+       
+    member _.EndPos 
+       with get() = endPos
+       and  set b = endPos <- b
+
+    member _.Lexeme = Array.sub buffer bufferScanStart lexemeLength
+
+    member _.LexemeChar n = buffer.[n+bufferScanStart]
+    
+    member _.BufferLocalStore = (context :> IDictionary<_, _>)
+
+    member _.LexemeLength
+        with get() : int = lexemeLength
+        and set v = lexemeLength <- v
+
+    member internal _.Buffer
+        with get() : 'char[] = buffer
+        and set v = buffer <- v
+
+    member internal _.BufferMaxScanLength
+        with get() = bufferMaxScanLength
+        and set v = bufferMaxScanLength <- v
+
+    member internal _.BufferScanLength
+        with get() = bufferScanLength    
+        and set v = bufferScanLength <- v
+
+    member internal _.BufferScanStart
+        with get() : int = bufferScanStart     
+        and set v = bufferScanStart <- v
+
+    member internal _.BufferAcceptAction 
+        with get() = bufferAcceptAction  
+        and set v = bufferAcceptAction <- v
+
+    member internal _.RefillBuffer = extendBufferSync
+
+    member internal _.AsyncRefillBuffer = extendBufferAsync
+
+    static member LexemeString(lexbuf:LexBuffer<char>) = 
+        System.String(lexbuf.Buffer, lexbuf.BufferScanStart, lexbuf.LexemeLength)
+
+    member _.IsPastEndOfStream 
+       with get() = eof
+       and  set b = eof <- b
+
+    member _.DiscardInput() = discardInput ()
+
+    member _.BufferScanPos = bufferScanStart + bufferScanLength
+
+    member lexbuf.EnsureBufferSize n = 
+        if lexbuf.BufferScanPos + n >= buffer.Length then 
+            let repl = Array.zeroCreate (lexbuf.BufferScanPos + n) 
+            Array.blit buffer bufferScanStart repl bufferScanStart bufferScanLength
+            buffer <- repl
+
+    static member FromReadFunctions (syncRead : ('char[] * int * int -> int) option, asyncRead : ('char[] * int * int -> Async<int>) option) : LexBuffer<'char> = 
+        let extension= Array.zeroCreate 4096
+        let fillers = 
+            { fillSync = 
+                match syncRead with 
+                | None -> None
+                | Some read -> 
+                     Some (fun lexBuffer -> 
+                         let n = read(extension, 0, extension.Length)
+                         lexBuffer.EnsureBufferSize n
+                         Array.blit extension 0 lexBuffer.Buffer lexBuffer.BufferScanPos n
+                         lexBuffer.BufferMaxScanLength <- lexBuffer.BufferScanLength + n) 
+              fillAsync = 
+                match asyncRead with 
+                | None -> None
+                | Some read -> 
+                     Some (fun lexBuffer -> 
+                              async { 
+                                  let! n = read(extension, 0, extension.Length)
+                                  lexBuffer.EnsureBufferSize n
+                                  Array.blit extension 0 lexBuffer.Buffer lexBuffer.BufferScanPos n
+                                  lexBuffer.BufferMaxScanLength <- lexBuffer.BufferScanLength + n }) }
+        LexBuffer<_>(fillers)
+
+    // A full type signature is required on this method because it is used at more specific types within its own scope
+    static member FromFunction (f : 'char[] * int * int -> int) : LexBuffer<'char> = 
+        LexBuffer<_>.FromReadFunctions(Some(f), None)
+
+    static member FromAsyncFunction (f : 'char[] * int * int -> Async<int>) : LexBuffer<'char> = 
+        LexBuffer<_>.FromReadFunctions(None, Some(f))
+          
+    static member FromCharFunction f : LexBuffer<char> = 
+        LexBuffer<char>.FromFunction(fun (buff, start, len) -> 
+            let buff2 = Array.zeroCreate len
+            let n = f buff2 len 
+            Array.blit buff2 0 buff start len
+            n)
+
+    static member FromByteFunction f : LexBuffer<byte> = 
+        LexBuffer<byte>.FromFunction(fun (buff, start, len) -> 
+            let buff2 = Array.zeroCreate len
+            let n = f buff2 len 
+            Array.blit buff2 0 buff start len
+            n)
+
+    // A full type signature is required on this method because it is used at more specific types within its own scope
+    static member FromArray (s: 'char[]) : LexBuffer<'char> = 
+        let lexBuffer = 
+            LexBuffer<_> 
+                { fillSync = Some (fun _ -> ()) 
+                  fillAsync = Some (fun _ -> async { return () }) }
+        lexBuffer.Buffer <- s
+        lexBuffer.BufferMaxScanLength <- s.Length
+        lexBuffer
+
+    static member FromBytes arr =
+        LexBuffer<byte>.FromArray(Array.copy arr)
+
+    static member FromChars arr =
+        LexBuffer<char>.FromArray(Array.copy arr)
+
+    static member FromString (s:string) =
+        LexBuffer<char>.FromArray (s.ToCharArray())
+
+    static member FromTextReader (tr:System.IO.TextReader) : LexBuffer<char> = 
+       LexBuffer<char>.FromReadFunctions(Some tr.Read, Some (tr.ReadAsync >> Async.AwaitTask))
+
+    static member FromBinaryReader (br:System.IO.BinaryReader) : LexBuffer<byte> = 
+       LexBuffer<byte>.FromFunction(br.Read)
+
+    static member FromStream (stream:System.IO.Stream) : LexBuffer<byte> = 
+       LexBuffer<byte>.FromReadFunctions(Some(stream.Read), Some(fun (buf, offset, len) -> stream.AsyncRead(buf, offset=offset, count=len))) 
+
+module GenericImplFragments = 
+    let startInterpret(lexBuffer:LexBuffer<_>)= 
+        lexBuffer.BufferScanStart <- lexBuffer.BufferScanStart + lexBuffer.LexemeLength
+        lexBuffer.BufferMaxScanLength <- lexBuffer.BufferMaxScanLength - lexBuffer.LexemeLength
+        lexBuffer.BufferScanLength <- 0
+        lexBuffer.LexemeLength <- 0
+        lexBuffer.BufferAcceptAction <- -1
+
+    let afterRefill (trans: uint16[] array, sentinel, lexBuffer:LexBuffer<_>, scanUntilSentinel, endOfScan, state, eofPos) = 
+        // end of file occurs if we couldn't extend the buffer 
+        if lexBuffer.BufferScanLength = lexBuffer.BufferMaxScanLength then  
+            let snew = int trans.[state].[eofPos] // == EOF 
+            if snew = sentinel then 
+                endOfScan()
+            else 
+                if lexBuffer.IsPastEndOfStream then failwith "End of file on lexing stream"
+                lexBuffer.IsPastEndOfStream <- true
+                // Printf.printf "state %d --> %d on eof\n" state snew
+                scanUntilSentinel(lexBuffer, snew)
+        else 
+            scanUntilSentinel(lexBuffer, state)
+
+    let onAccept (lexBuffer:LexBuffer<_>, a) = 
+        lexBuffer.LexemeLength <- lexBuffer.BufferScanLength
+        lexBuffer.BufferAcceptAction <- a
+
+open GenericImplFragments
+
+[<Sealed>]
+type AsciiTables(trans: uint16[] array, accept: uint16[]) =
+    let rec scanUntilSentinel(lexBuffer, state) =
         let sentinel = 255 * 256 + 255 
-        let numUnicodeCategories = 30 
-        let numLowUnicodeChars = 128 
-        let numSpecificUnicodeChars = (trans.[0].Length - 1 - numLowUnicodeChars - numUnicodeCategories)/2
-        let lookupUnicodeCharacters (state,inp: char) = 
-            let inpAsInt = int inp
-            // Is it a fast ASCII character?
-            if inpAsInt < numLowUnicodeChars then 
-                int trans.[state].[inpAsInt]
+        // Return an endOfScan after consuming the input 
+        let a = int accept.[state] 
+        if a <> sentinel then 
+            onAccept (lexBuffer, a)
+        
+        if lexBuffer.BufferScanLength = lexBuffer.BufferMaxScanLength then 
+            lexBuffer.DiscardInput()
+            lexBuffer.RefillBuffer ()
+          // end of file occurs if we couldn't extend the buffer 
+            afterRefill (trans, sentinel, lexBuffer, scanUntilSentinel, lexBuffer.EndOfScan, state, 256 (* == EOF *) )
+        else
+            // read a character - end the scan if there are no further transitions 
+            let inp = int(lexBuffer.Buffer.[lexBuffer.BufferScanPos])
+            let snew = int trans.[state].[inp] 
+            if snew = sentinel then 
+                lexBuffer.EndOfScan()
             else 
-                // Search for a specific unicode character
-                let baseForSpecificUnicodeChars = numLowUnicodeChars
-                let rec loop i = 
-                    if i >= numSpecificUnicodeChars then 
-                        // OK, if we failed then read the 'others' entry in the alphabet,
-                        // which covers all Unicode characters not covered in other
-                        // ways
-                        let baseForUnicodeCategories = numLowUnicodeChars+numSpecificUnicodeChars*2
-                        let unicodeCategory = System.Globalization.CharUnicodeInfo.GetUnicodeCategory(inp)
-                        //System.Console.WriteLine("inp = {0}, unicodeCategory = {1}", [| box inp; box unicodeCategory |]);
-                        int trans.[state].[baseForUnicodeCategories + int32 unicodeCategory]
-                    else 
-                        // This is the specific unicode character
-                        let c = char (int trans.[state].[baseForSpecificUnicodeChars+i*2])
-                        //System.Console.WriteLine("c = {0}, inp = {1}, i = {2}", [| box c; box inp; box i |]);
-                        // OK, have we found the entry for a specific unicode character?
-                        if c = inp
-                        then int trans.[state].[baseForSpecificUnicodeChars+i*2+1]
-                        else loop(i+1)
+                lexBuffer.BufferScanLength <- lexBuffer.BufferScanLength + 1
+                // Printf.printf "state %d --> %d on '%c' (%d)\n" state snew (Char.chr inp) inp
+                scanUntilSentinel(lexBuffer, snew)
+        
+    /// Interpret tables for an ascii lexer generated by fslex. 
+    member tables.Interpret(initialState, lexBuffer : LexBuffer<byte>) = 
+        startInterpret(lexBuffer)
+        scanUntilSentinel(lexBuffer, initialState)
+
+    /// Interpret tables for an ascii lexer generated by fslex. 
+    member tables.AsyncInterpret(initialState, lexBuffer : LexBuffer<byte>) = 
+    
+        let rec scanUntilSentinel(lexBuffer, state) : Async<int> = 
+            async { 
+                let sentinel = 255 * 256 + 255 
+                // Return an endOfScan after consuming the input 
+                let a = int accept.[state] 
+                if a <> sentinel then 
+                    onAccept (lexBuffer, a)
                 
-                loop 0
-        let eofPos    = numLowUnicodeChars + 2*numSpecificUnicodeChars + numUnicodeCategories 
+                if lexBuffer.BufferScanLength = lexBuffer.BufferMaxScanLength then 
+                    lexBuffer.DiscardInput()
+                    do! lexBuffer.AsyncRefillBuffer ()
+                   // end of file occurs if we couldn't extend the buffer 
+                    return! afterRefill (trans, sentinel, lexBuffer, scanUntilSentinel, endOfScan, state, 256 (* == EOF *) )
+                else
+                    // read a character - end the scan if there are no further transitions 
+                    let inp = int(lexBuffer.Buffer.[lexBuffer.BufferScanPos])
+                    let snew = int trans.[state].[inp] 
+                    if snew = sentinel then 
+                        return! endOfScan()
+                    else 
+                        lexBuffer.BufferScanLength <- lexBuffer.BufferScanLength + 1
+                        return! scanUntilSentinel(lexBuffer, snew)
+            }
+
+        and endOfScan() = 
+            async { return lexBuffer.EndOfScan() }
+
+        startInterpret(lexBuffer)
+
+        scanUntilSentinel(lexBuffer, initialState)
+
+
+    static member Create(trans, accept) = AsciiTables(trans, accept)
+
+[<Sealed>]
+type UnicodeTables(trans: uint16[] array, accept: uint16[]) = 
+    let sentinel = 255 * 256 + 255 
+    let numUnicodeCategories = 30 
+    let numLowUnicodeChars = 128 
+    let numSpecificUnicodeChars = (trans.[0].Length - 1 - numLowUnicodeChars - numUnicodeCategories)/2
+    let lookupUnicodeCharacters (state, inp: char) = 
+        let inpAsInt = int inp
+        // Is it a fast ASCII character?
+        if inpAsInt < numLowUnicodeChars then 
+            int trans.[state].[inpAsInt]
+        else 
+            // Search for a specific unicode character
+            let baseForSpecificUnicodeChars = numLowUnicodeChars
+            let rec loop i = 
+                if i >= numSpecificUnicodeChars then 
+                    // OK, if we failed then read the 'others' entry in the alphabet, 
+                    // which covers all Unicode characters not covered in other
+                    // ways
+                    let baseForUnicodeCategories = numLowUnicodeChars+numSpecificUnicodeChars*2
+                    let unicodeCategory = System.Globalization.CharUnicodeInfo.GetUnicodeCategory(inp)
+                    //System.Console.WriteLine("inp = {0}, unicodeCategory = {1}", [| box inp; box unicodeCategory |])
+                    int trans.[state].[baseForUnicodeCategories + int32 unicodeCategory]
+                else 
+                    // This is the specific unicode character
+                    let c = char (int trans.[state].[baseForSpecificUnicodeChars+i*2])
+                    //System.Console.WriteLine("c = {0}, inp = {1}, i = {2}", [| box c; box inp; box i |])
+                    // OK, have we found the entry for a specific unicode character?
+                    if c = inp
+                    then int trans.[state].[baseForSpecificUnicodeChars+i*2+1]
+                    else loop(i+1)
+            
+            loop 0
+    let eofPos    = numLowUnicodeChars + 2*numSpecificUnicodeChars + numUnicodeCategories 
+    
+    let rec scanUntilSentinel(lexBuffer, state) =
+        // Return an endOfScan after consuming the input 
+        let a = int accept.[state] 
+        if a <> sentinel then 
+            onAccept(lexBuffer, a)
         
-        let rec scanUntilSentinel(lexBuffer,state) =
-            // Return an endOfScan after consuming the input 
-            let a = int accept.[state] 
-            if a <> sentinel then 
-                onAccept(lexBuffer,a)
+        if lexBuffer.BufferScanLength = lexBuffer.BufferMaxScanLength then 
+            lexBuffer.DiscardInput()
+            lexBuffer.RefillBuffer ()
+          // end of file occurs if we couldn't extend the buffer 
+            afterRefill (trans, sentinel, lexBuffer, scanUntilSentinel, lexBuffer.EndOfScan, state, eofPos)
+        else
+            // read a character - end the scan if there are no further transitions 
+            let inp = lexBuffer.Buffer.[lexBuffer.BufferScanPos]
             
-            if lexBuffer.BufferScanLength = lexBuffer.BufferMaxScanLength then 
-                lexBuffer.DiscardInput();
-                lexBuffer.RefillBuffer ();
-              // end of file occurs if we couldn't extend the buffer 
-                afterRefill (trans,sentinel,lexBuffer,scanUntilSentinel,lexBuffer.EndOfScan,state,eofPos)
-            else
-                // read a character - end the scan if there are no further transitions 
-                let inp = lexBuffer.Buffer.[lexBuffer.BufferScanPos]
-                
-                // Find the new state
-                let snew = lookupUnicodeCharacters (state,inp)
+            // Find the new state
+            let snew = lookupUnicodeCharacters (state, inp)
 
-                if snew = sentinel then 
-                    lexBuffer.EndOfScan()
-                else 
-                    lexBuffer.BufferScanLength <- lexBuffer.BufferScanLength + 1;
-                    // Printf.printf "state %d --> %d on '%c' (%d)\n" s snew (char inp) inp;
-                    scanUntilSentinel(lexBuffer,snew)
-                          
-        // Each row for the Unicode table has format 
-        //      128 entries for ASCII characters
-        //      A variable number of 2*UInt16 entries for SpecificUnicodeChars 
-        //      30 entries, one for each UnicodeCategory
-        //      1 entry for EOF
-
-        member tables.Interpret(initialState,lexBuffer : LexBuffer<char>) = 
-            startInterpret(lexBuffer)
-            scanUntilSentinel(lexBuffer, initialState)
-
-        member tables.AsyncInterpret(initialState,lexBuffer : LexBuffer<char>) = 
-
-            let rec scanUntilSentinel(lexBuffer, state) =
-                async {
-                    // Return an endOfScan after consuming the input 
-                    let a = int accept.[state] 
-                    if a <> sentinel then 
-                        onAccept(lexBuffer,a)
+            if snew = sentinel then 
+                lexBuffer.EndOfScan()
+            else 
+                lexBuffer.BufferScanLength <- lexBuffer.BufferScanLength + 1
+                // Printf.printf "state %d --> %d on '%c' (%d)\n" s snew (char inp) inp
+                scanUntilSentinel(lexBuffer, snew)
+                      
+    // Each row for the Unicode table has format 
+    //      128 entries for ASCII characters
+    //      A variable number of 2*UInt16 entries for SpecificUnicodeChars 
+    //      30 entries, one for each UnicodeCategory
+    //      1 entry for EOF
+
+    member tables.Interpret(initialState, lexBuffer : LexBuffer<char>) = 
+        startInterpret(lexBuffer)
+        scanUntilSentinel(lexBuffer, initialState)
+
+    member tables.AsyncInterpret(initialState, lexBuffer : LexBuffer<char>) = 
+
+        let rec scanUntilSentinel(lexBuffer, state) =
+            async {
+                // Return an endOfScan after consuming the input 
+                let a = int accept.[state] 
+                if a <> sentinel then 
+                    onAccept(lexBuffer, a)
+                
+                if lexBuffer.BufferScanLength = lexBuffer.BufferMaxScanLength then 
+                    lexBuffer.DiscardInput()
+                    lexBuffer.RefillBuffer ()
+                    // end of file occurs if we couldn't extend the buffer 
+                    return! afterRefill (trans, sentinel, lexBuffer, scanUntilSentinel, endOfScan, state, eofPos)
+                else
+                    // read a character - end the scan if there are no further transitions 
+                    let inp = lexBuffer.Buffer.[lexBuffer.BufferScanPos]
                     
-                    if lexBuffer.BufferScanLength = lexBuffer.BufferMaxScanLength then 
-                        lexBuffer.DiscardInput();
-                        lexBuffer.RefillBuffer ();
-                        // end of file occurs if we couldn't extend the buffer 
-                        return! afterRefill (trans,sentinel,lexBuffer,scanUntilSentinel,endOfScan,state,eofPos)
-                    else
-                        // read a character - end the scan if there are no further transitions 
-                        let inp = lexBuffer.Buffer.[lexBuffer.BufferScanPos]
-                        
-                        // Find the new state
-                        let snew = lookupUnicodeCharacters (state,inp)
-
-                        if snew = sentinel then 
-                            return! endOfScan()
-                        else 
-                            lexBuffer.BufferScanLength <- lexBuffer.BufferScanLength + 1;
-                            return! scanUntilSentinel(lexBuffer, snew)
-                }
-            and endOfScan() = 
-                async { return lexBuffer.EndOfScan() } 
-            startInterpret(lexBuffer)
-            scanUntilSentinel(lexBuffer, initialState)
-
-        static member Create(trans,accept) = new UnicodeTables(trans,accept)
+                    // Find the new state
+                    let snew = lookupUnicodeCharacters (state, inp)
+
+                    if snew = sentinel then 
+                        return! endOfScan()
+                    else 
+                        lexBuffer.BufferScanLength <- lexBuffer.BufferScanLength + 1
+                        return! scanUntilSentinel(lexBuffer, snew)
+            }
+        and endOfScan() = 
+            async { return lexBuffer.EndOfScan() } 
+        startInterpret(lexBuffer)
+        scanUntilSentinel(lexBuffer, initialState)
+
+    static member Create(trans, accept) = UnicodeTables(trans, accept)
+
+open System.IO
+
+let UnicodeFileAsLexbuf (filename,codePage : int option) : FileStream * StreamReader * LexBuffer<char> =
+    // Use the .NET functionality to auto-detect the unicode encoding
+    // It also presents the bytes read to the lexer in UTF8 decoded form
+    let stream  = new FileStream(filename,FileMode.Open,FileAccess.Read,FileShare.Read)
+    let reader =
+        match codePage with
+        | None -> new  StreamReader(stream,true)
+        | Some n -> new  StreamReader(stream,System.Text.Encoding.GetEncoding(n))
+    let lexbuf = LexBuffer.FromFunction(reader.Read)
+    lexbuf.EndPos <- Position.FirstLine(filename)
+    stream, reader, lexbuf
\ No newline at end of file
diff --git a/buildtools/fslex/Lexing.fsi b/buildtools/fslex/Lexing.fsi
index e31ad411aa9..866ba6a1e56 100644
--- a/buildtools/fslex/Lexing.fsi
+++ b/buildtools/fslex/Lexing.fsi
@@ -5,147 +5,160 @@
 // (c) Microsoft Corporation 2005-2008.
 //===========================================================================
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-namespace Internal.Utilities.Text.Lexing
-#else
-namespace Microsoft.FSharp.Text.Lexing 
-#endif
+module FSharp.Text.Lexing
 
 open System.Collections.Generic
 
 /// Position information stored for lexing tokens
-//
-// Note: this is an OCaml compat record type. 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-type internal Position = 
-#else
-type Position = 
-#endif
-    { /// The file name for the position
-      pos_fname: string;
+[<Struct>]
+type Position =
+    { 
+      /// The file name for the position
+      pos_fname: string
+      
       /// The line number for the position
-      pos_lnum: int;
-#if INTERNALIZED_FSLEXYACC_RUNTIME
+      pos_lnum: int
+
       /// The line number for the position in the original source file
-      pos_orig_lnum : int;
-#endif
+      pos_orig_lnum : int
+
       /// The absolute offset of the beginning of the line
-      pos_bol: int;
+      pos_bol: int
+
       /// The absolute offset of the column for the position
-      pos_cnum: int; }
+      pos_cnum: int
+     }
+
      /// The file name associated with the input stream.
      member FileName : string
-     /// The line number in the input stream, assuming fresh positions have been updated 
+
+     /// The line number in the input stream, assuming fresh positions have been updated
      /// using AsNewLinePos() and by modifying the EndPos property of the LexBuffer.
      member Line : int
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-     /// The line number for the position in the input stream, assuming fresh positions have been updated 
+
+     /// The line number for the position in the input stream, assuming fresh positions have been updated
      /// using AsNewLinePos()
      member OriginalLine : int
-#endif
-     [<System.ObsoleteAttribute("Use the AbsoluteOffset property instead")>]
+
+     [<System.Obsolete("Use the AbsoluteOffset property instead")>]
      member Char : int
+
      /// The character number in the input stream
      member AbsoluteOffset : int
+
      /// Return absolute offset of the start of the line marked by the position
      member StartOfLineAbsoluteOffset : int
+
      /// Return the column number marked by the position, i.e. the difference between the AbsoluteOffset and the StartOfLineAbsoluteOffset
      member Column : int
+
      // Given a position just beyond the end of a line, return a position at the start of the next line
-     member NextLine : Position     
-     
+     member NextLine : Position
+
      /// Given a position at the start of a token of length n, return a position just beyond the end of the token
      member EndOfToken: n:int -> Position
+
      /// Gives a position shifted by specified number of characters
      member ShiftColumnBy: by:int -> Position
-     
-     [<System.ObsoleteAttribute("Consider using the NextLine property instead")>]
+
+     [<System.Obsolete("Consider using the NextLine property instead")>]
      member AsNewLinePos : unit -> Position
-     
-     /// Get an arbitrary position, with the empty string as filename, and  
+
+     /// Get an arbitrary position, with the empty string as filename, and
      static member Empty : Position
 
      /// Get a position corresponding to the first line (line number 1) in a given file
      static member FirstLine : filename:string -> Position
-    
+
 [<Sealed>]
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-type internal LexBuffer<'char> =
-#else
 /// Input buffers consumed by lexers generated by <c>fslex.exe </c>
 type LexBuffer<'char> =
-#endif
     /// The start position for the lexeme
     member StartPos: Position with get,set
+
     /// The end position for the lexeme
     member EndPos: Position with get,set
-    /// The matched string 
+
+    /// The matched string
     member Lexeme: 'char array
-    
+
     /// Fast helper to turn the matched characters into a string, avoiding an intermediate array
     static member LexemeString : LexBuffer<char> -> string
-    
-    /// The length of the matched string 
+
+    /// The length of the matched string
     member LexemeLength: int
-    /// Fetch a particular character in the matched string 
+
+    /// Fetch a particular character in the matched string
     member LexemeChar: int -> 'char
 
     /// Dynamically typed, non-lexically scoped parameter table
     member BufferLocalStore : IDictionary<string,obj>
-    
+
     /// True if the refill of the buffer ever failed , or if explicitly set to true.
     member IsPastEndOfStream: bool with get,set
-    /// Remove all input, though don't discard the current lexeme 
+
+    /// Remove all input, though don't discard the current lexeme
     member DiscardInput: unit -> unit
 
     /// Create a lex buffer suitable for byte lexing that reads characters from the given array
     static member FromBytes: byte[] -> LexBuffer<byte>
+
     /// Create a lex buffer suitable for Unicode lexing that reads characters from the given array
     static member FromChars: char[] -> LexBuffer<char>
+
     /// Create a lex buffer suitable for Unicode lexing that reads characters from the given string
     static member FromString: string -> LexBuffer<char>
+
     /// Create a lex buffer that reads character or byte inputs by using the given function
     static member FromFunction: ('char[] * int * int -> int) -> LexBuffer<'char>
+
     /// Create a lex buffer that asynchronously reads character or byte inputs by using the given function
     static member FromAsyncFunction: ('char[] * int * int -> Async<int>) -> LexBuffer<'char>
 
-
     [<System.Obsolete("Use LexBuffer<char>.FromFunction instead")>]
     static member FromCharFunction: (char[] -> int -> int) -> LexBuffer<char>
+
     [<System.Obsolete("Use LexBuffer<byte>.FromFunction instead")>]
     static member FromByteFunction: (byte[] -> int -> int) -> LexBuffer<byte>
 
     /// Create a lex buffer suitable for use with a Unicode lexer that reads character inputs from the given text reader
     static member FromTextReader: System.IO.TextReader -> LexBuffer<char>
+
     /// Create a lex buffer suitable for use with ASCII byte lexing that reads byte inputs from the given binary reader
     static member FromBinaryReader: System.IO.BinaryReader -> LexBuffer<byte>
 
 
-/// The type of tables for an ascii lexer generated by fslex. 
+/// The type of tables for an ascii lexer generated by fslex.
 [<Sealed>]
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-type internal AsciiTables =
-#else
 type AsciiTables =
-#endif
     static member Create : uint16[] array * uint16[] -> AsciiTables
-    /// Interpret tables for an ascii lexer generated by fslex. 
+
+    /// Interpret tables for an ascii lexer generated by fslex.
     member Interpret:  initialState:int * LexBuffer<byte>  -> int
+
+    [<System.Obsolete("Async interretation of lexer tables is now obsolete and will be removed. Please use a background thread if you want async lexing")>]
     /// Interpret tables for an ascii lexer generated by fslex, processing input asynchronously
     member AsyncInterpret:  initialState:int * LexBuffer<byte> -> Async<int>
 
 
-/// The type of tables for an unicode lexer generated by fslex. 
+/// The type of tables for an unicode lexer generated by fslex.
 [<Sealed>]
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-type internal UnicodeTables =
-#else
 type UnicodeTables =
-#endif
+
     static member Create : uint16[] array * uint16[] -> UnicodeTables
-    /// Interpret tables for a unicode lexer generated by fslex. 
+
+    /// Interpret tables for a unicode lexer generated by fslex.
     member Interpret:  initialState:int * LexBuffer<char> -> int
 
+    [<System.Obsolete("Async interretation of lexer tables is now obsolete and will be removed. Please use a background thread if you want async lexing")>]
     /// Interpret tables for a unicode lexer generated by fslex, processing input asynchronously
     member AsyncInterpret:  initialState:int * LexBuffer<char> -> Async<int>
 
+
+/// Standard utility to create a Unicode LexBuffer
+///
+/// One small annoyance is that LexBuffers and not IDisposable. This means
+/// we can't just return the LexBuffer object, since the file it wraps wouldn't
+/// get closed when we're finished with the LexBuffer. Hence we return the stream,
+/// the reader and the LexBuffer. The caller should dispose the first two when done.
+val UnicodeFileAsLexbuf: string * int option -> System.IO.FileStream * System.IO.StreamReader * LexBuffer<char>
\ No newline at end of file
diff --git a/buildtools/fslex/Parsing.fs b/buildtools/fslex/Parsing.fs
index 01dccfb6101..f66aa7a77f4 100644
--- a/buildtools/fslex/Parsing.fs
+++ b/buildtools/fslex/Parsing.fs
@@ -1,87 +1,76 @@
 // (c) Microsoft Corporation 2005-2009. 
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
+namespace FSharp.Text.Parsing
+open FSharp.Text.Lexing
 
-namespace  Internal.Utilities.Text.Parsing
-open Internal.Utilities
-open Internal.Utilities.Text.Lexing
-
-#else
-namespace Microsoft.FSharp.Text.Parsing
-open Microsoft.FSharp.Text.Lexing
-#endif
-
-
-
-open System
 open System.Collections.Generic
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-type internal IParseState = 
-#else
 type IParseState = 
-#endif
     abstract InputRange: int -> Position * Position
+
     abstract InputEndPosition: int -> Position 
+
     abstract InputStartPosition: int -> Position 
+
     abstract ResultRange: Position * Position
+
     abstract GetInput: int -> obj 
+
     abstract ParserLocalStore : IDictionary<string,obj>
+
     abstract RaiseError<'b> : unit -> 'b 
 
 //-------------------------------------------------------------------------
 // This context is passed to the error reporter when a syntax error occurs
 
 [<Sealed>]
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-type internal ParseErrorContext<'tok>
-#else
 type ParseErrorContext<'tok>
-#endif
          (//lexbuf: LexBuffer<_>,
           stateStack:int list,
           parseState: IParseState, 
           reduceTokens: int list, 
           currentToken: 'tok option, 
           reducibleProductions: int list list, 
-          shiftableTokens: int list , 
+          shiftableTokens: int list, 
           message : string) =
-      //member x.LexBuffer = lexbuf
-      member x.StateStack  = stateStack
-      member x.ReduceTokens = reduceTokens
-      member x.CurrentToken = currentToken
-      member x.ParseState = parseState
-      member x.ReducibleProductions = reducibleProductions
-      member x.ShiftTokens = shiftableTokens
-      member x.Message = message
+
+      member _.StateStack  = stateStack
+
+      member _.ReduceTokens = reduceTokens
+
+      member _.CurrentToken = currentToken
+
+      member _.ParseState = parseState
+
+      member _.ReducibleProductions = reducibleProductions
+
+      member _.ShiftTokens = shiftableTokens
+
+      member _.Message = message
 
 
 //-------------------------------------------------------------------------
 // This is the data structure emitted as code by FSYACC.  
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-type internal Tables<'tok> = 
-#else
 type Tables<'tok> = 
-#endif
-    { reductions: (IParseState -> obj) array;
-      endOfInputTag: int;
-      tagOfToken: 'tok -> int;
-      dataOfToken: 'tok -> obj; 
-      actionTableElements: uint16[];  
-      actionTableRowOffsets: uint16[];
-      reductionSymbolCounts: uint16[];
-      immediateActions: uint16[];
-      gotos: uint16[];
-      sparseGotoTableRowOffsets: uint16[];
-      stateToProdIdxsTableElements: uint16[];  
-      stateToProdIdxsTableRowOffsets: uint16[];  
-      productionToNonTerminalTable: uint16[];
+    { reductions: (IParseState -> obj)[]
+      endOfInputTag: int
+      tagOfToken: 'tok -> int
+      dataOfToken: 'tok -> obj 
+      actionTableElements: uint16[]  
+      actionTableRowOffsets: uint16[]
+      reductionSymbolCounts: uint16[]
+      immediateActions: uint16[]
+      gotos: uint16[]
+      sparseGotoTableRowOffsets: uint16[]
+      stateToProdIdxsTableElements: uint16[]  
+      stateToProdIdxsTableRowOffsets: uint16[]  
+      productionToNonTerminalTable: uint16[]
       /// For fsyacc.exe, this entry is filled in by context from the generated parser file. If no 'parse_error' function
       /// is defined by the user then ParseHelpers.parse_error is used by default (ParseHelpers is opened
       /// at the top of the generated parser file)
-      parseError:  ParseErrorContext<'tok> -> unit;
-      numTerminals: int;
+      parseError:  ParseErrorContext<'tok> -> unit
+      numTerminals: int
       tagOfErrorTerminal: int }
 
 //-------------------------------------------------------------------------
@@ -90,11 +79,7 @@ type Tables<'tok> =
 // This type is in System.dll so for the moment we can't use it in FSharp.Core.dll
 //type Stack<'a> = System.Collections.Generic.Stack<'a>
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-type Stack<'a>(n)  = 
-#else
 type internal Stack<'a>(n)  = 
-#endif
     let mutable contents = Array.zeroCreate<'a>(n)
     let mutable count = 0
 
@@ -102,16 +87,16 @@ type internal Stack<'a>(n)  =
         let oldSize = Array.length contents
         if newSize > oldSize then 
             let old = contents
-            contents <- Array.zeroCreate (max newSize (oldSize * 2));
-            Array.blit old 0 contents 0 count;
+            contents <- Array.zeroCreate (max newSize (oldSize * 2))
+            Array.blit old 0 contents 0 count
     
     member buf.Count = count
     member buf.Pop() = count <- count - 1
     member buf.Peep() = contents.[count - 1]
     member buf.Top(n) = [ for x in contents.[max 0 (count-n)..count - 1] -> x ] |> List.rev
     member buf.Push(x) =
-        buf.Ensure(count + 1); 
-        contents.[count] <- x; 
+        buf.Ensure(count + 1) 
+        contents.[count] <- x 
         count <- count + 1
         
     member buf.IsEmpty = (count = 0)
@@ -132,11 +117,7 @@ module Flags =
     let mutable debug = false
 #endif
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-module internal Implementation = 
-#else
 module Implementation = 
-#endif
     
     // Definitions shared with fsyacc 
     let anyMarker = 0xffff
@@ -153,7 +134,7 @@ module Implementation =
     // Read the tables written by FSYACC.  
 
     type AssocTable(elemTab:uint16[], offsetTab:uint16[]) =
-        let cache = new Dictionary<_,_>(2000)
+        let cache = Dictionary<_,_>(2000)
 
         member t.readAssoc (minElemNum,maxElemNum,defaultValueOfAssoc,keyToFind) =     
             // do a binary chop on the table 
@@ -164,10 +145,12 @@ module Implementation =
                 let x = int elemTab.[elemNumber*2]
                 if keyToFind = x then 
                     int elemTab.[elemNumber*2+1]
-                elif keyToFind < x then t.readAssoc (minElemNum ,elemNumber,defaultValueOfAssoc,keyToFind)
-                else                    t.readAssoc (elemNumber+1,maxElemNum,defaultValueOfAssoc,keyToFind)
+                elif keyToFind < x then
+                    t.readAssoc (minElemNum,elemNumber,defaultValueOfAssoc,keyToFind)
+                else
+                    t.readAssoc (elemNumber+1,maxElemNum,defaultValueOfAssoc,keyToFind)
 
-        member t.Read(rowNumber ,keyToFind) =
+        member t.Read(rowNumber,keyToFind) =
         
             // First check the sparse lookaside table
             // Performance note: without this lookaside table the binary chop in readAssoc
@@ -191,7 +174,7 @@ module Implementation =
 
         // Read all entries in the association table
         // Used during error recovery to find all valid entries in the table
-        member x.ReadAll(n) =       
+        member _.ReadAll(n) =       
             let headOfTable = int offsetTab.[n]
             let firstElemNumber = headOfTable + 1           
             let numberOfElementsInAssoc = int32 elemTab.[headOfTable*2]           
@@ -202,7 +185,7 @@ module Implementation =
     type IdxToIdxListTable(elemTab:uint16[], offsetTab:uint16[]) =
 
         // Read all entries in a row of the table
-        member x.ReadAll(n) =       
+        member _.ReadAll(n) =       
             let headOfTable = int offsetTab.[n]
             let firstElemNumber = headOfTable + 1           
             let numberOfElements = int32 elemTab.[headOfTable]           
@@ -217,22 +200,31 @@ module Implementation =
         val value: obj
         val startPos: Position
         val endPos: Position
-        new(value,startPos,endPos) = { value=value; startPos=startPos;endPos=endPos }
+
+        new(value,startPos,endPos) = { value=value; startPos=startPos; endPos=endPos }
 
     let interpret (tables: Tables<'tok>) lexer (lexbuf : LexBuffer<_>) initialState =                                                                      
-        let localStore = new Dictionary<string,obj>() in
-        localStore.["LexBuffer"] <- lexbuf;
+        let localStore = Dictionary<string,obj>() in
+        localStore.["LexBuffer"] <- lexbuf
 #if __DEBUG
-        if Flags.debug then System.Console.WriteLine("\nParser: interpret tables");
+        if Flags.debug then System.Console.WriteLine("\nParser: interpret tables")
 #endif
-        let stateStack : Stack<int> = new Stack<_>(100)
-        stateStack.Push(initialState);
-        let valueStack = new Stack<ValueInfo>(100)
+        let stateStack : Stack<int> = Stack<_>(100)
+
+        stateStack.Push(initialState)
+
+        let valueStack = Stack<ValueInfo>(100)
+
         let mutable haveLookahead = false                                                                              
+
         let mutable lookaheadToken = Unchecked.defaultof<'tok>
+
         let mutable lookaheadEndPos = Unchecked.defaultof<Position>
+
         let mutable lookaheadStartPos = Unchecked.defaultof<Position>
+
         let mutable finished = false
+
         // After an error occurs, we suppress errors until we've shifted three tokens in a row.
         let mutable errorSuppressionCountDown = 0
         
@@ -243,27 +235,31 @@ module Implementation =
         // where consuming one EOF to trigger an error doesn't result in overall parse failure 
         // catastrophe and the loss of intermediate results.
         //
+
         let mutable inEofCountDown = false
+
         let mutable eofCountDown = 20 // Number of EOFs to supply at the end for error recovery
+
         // The 100 here means a maximum of 100 elements for each rule
-        let ruleStartPoss = (Array.zeroCreate 100 : Position array)              
-        let ruleEndPoss   = (Array.zeroCreate 100 : Position array)              
-        let ruleValues    = (Array.zeroCreate 100 : obj array)              
-        let lhsPos        = (Array.zeroCreate 2 : Position array)                                            
+        let ruleStartPoss = (Array.zeroCreate 100 : Position[])              
+        let ruleEndPoss   = (Array.zeroCreate 100 : Position[])              
+        let ruleValues    = (Array.zeroCreate 100 : obj[])              
+        let lhsPos        = (Array.zeroCreate 2 : Position[])                                            
+
         let reductions = tables.reductions
-        let actionTable = new AssocTable(tables.actionTableElements, tables.actionTableRowOffsets)
-        let gotoTable = new AssocTable(tables.gotos, tables.sparseGotoTableRowOffsets)
-        let stateToProdIdxsTable = new IdxToIdxListTable(tables.stateToProdIdxsTableElements, tables.stateToProdIdxsTableRowOffsets)
+        let actionTable = AssocTable(tables.actionTableElements, tables.actionTableRowOffsets)
+        let gotoTable = AssocTable(tables.gotos, tables.sparseGotoTableRowOffsets)
+        let stateToProdIdxsTable = IdxToIdxListTable(tables.stateToProdIdxsTableElements, tables.stateToProdIdxsTableRowOffsets)
 
         let parseState =                                                                                            
             { new IParseState with 
-                member p.InputRange(n) = ruleStartPoss.[n-1], ruleEndPoss.[n-1]; 
-                member p.InputStartPosition(n) = ruleStartPoss.[n-1]
-                member p.InputEndPosition(n) = ruleEndPoss.[n-1]; 
-                member p.GetInput(n)    = ruleValues.[n-1];        
-                member p.ResultRange    = (lhsPos.[0], lhsPos.[1]);  
-                member p.ParserLocalStore = (localStore :> IDictionary<_,_>); 
-                member p.RaiseError()  = raise RecoverableParseError  (* NOTE: this binding tests the fairly complex logic associated with an object expression implementing a generic abstract method *)
+                member _.InputRange(n) = ruleStartPoss.[n-1], ruleEndPoss.[n-1] 
+                member _.InputStartPosition(n) = ruleStartPoss.[n-1]
+                member _.InputEndPosition(n) = ruleEndPoss.[n-1] 
+                member _.GetInput(n)    = ruleValues.[n-1]        
+                member _.ResultRange    = (lhsPos.[0], lhsPos.[1])  
+                member _.ParserLocalStore = (localStore :> IDictionary<_,_>) 
+                member _.RaiseError()  = raise RecoverableParseError  (* NOTE: this binding tests the fairly complex logic associated with an object expression implementing a generic abstract method *)
             }       
 
 #if __DEBUG
@@ -275,22 +271,22 @@ module Implementation =
         // Pop the stack until we can shift the 'error' token. If 'tokenOpt' is given
         // then keep popping until we can shift both the 'error' token and the token in 'tokenOpt'.
         // This is used at end-of-file to make sure we can shift both the 'error' token and the 'EOF' token.
-        let rec popStackUntilErrorShifted(tokenOpt) =
+        let rec popStackUntilErrorShifted tokenOpt =
             // Keep popping the stack until the "error" terminal is shifted
 #if __DEBUG
-            if Flags.debug then System.Console.WriteLine("popStackUntilErrorShifted");
+            if Flags.debug then System.Console.WriteLine("popStackUntilErrorShifted")
 #endif
             if stateStack.IsEmpty then 
 #if __DEBUG
                 if Flags.debug then 
-                    System.Console.WriteLine("state stack empty during error recovery - generating parse error");
+                    System.Console.WriteLine("state stack empty during error recovery - generating parse error")
 #endif
-                failwith "parse error";
+                failwith "parse error"
             
             let currState = stateStack.Peep()
 #if __DEBUG
             if Flags.debug then 
-                System.Console.WriteLine("In state {0} during error recovery", currState);
+                System.Console.WriteLine("In state {0} during error recovery", currState)
 #endif
             
             let action = actionTable.Read(currState, tables.tagOfErrorTerminal)
@@ -303,22 +299,22 @@ module Implementation =
                     actionKind (actionTable.Read(nextState, tables.tagOfToken(token))) = shiftFlag) then
 
 #if __DEBUG
-                if Flags.debug then System.Console.WriteLine("shifting error, continuing with error recovery");
+                if Flags.debug then System.Console.WriteLine("shifting error, continuing with error recovery")
 #endif
                 let nextState = actionValue action 
                 // The "error" non terminal needs position information, though it tends to be unreliable.
                 // Use the StartPos/EndPos from the lex buffer
-                valueStack.Push(ValueInfo(box (), lexbuf.StartPos, lexbuf.EndPos));
+                valueStack.Push(ValueInfo(box (), lexbuf.StartPos, lexbuf.EndPos))
                 stateStack.Push(nextState)
             else
                 if valueStack.IsEmpty then 
-                    failwith "parse error";
+                    failwith "parse error"
 #if __DEBUG
                 if Flags.debug then 
-                    System.Console.WriteLine("popping stack during error recovery");
+                    System.Console.WriteLine("popping stack during error recovery")
 #endif
-                valueStack.Pop();
-                stateStack.Pop();
+                valueStack.Pop()
+                stateStack.Pop()
                 popStackUntilErrorShifted(tokenOpt)
 
         while not finished do                                                                                    
@@ -350,7 +346,7 @@ module Implementation =
                                 lookaheadToken <- lexer lexbuf
                                 lookaheadStartPos <- lexbuf.StartPos
                                 lookaheadEndPos <- lexbuf.EndPos
-                                haveLookahead <- true;
+                                haveLookahead <- true
 
                         let tag = 
                             if haveLookahead then tables.tagOfToken lookaheadToken 
@@ -362,17 +358,17 @@ module Implementation =
                 let kind = actionKind action 
                 if kind = shiftFlag then (
                     if errorSuppressionCountDown > 0 then 
-                        errorSuppressionCountDown <- errorSuppressionCountDown - 1;
+                        errorSuppressionCountDown <- errorSuppressionCountDown - 1
 #if __DEBUG
-                        if Flags.debug then Console.WriteLine("shifting, reduced errorRecoverylevel to {0}\n", errorSuppressionCountDown);
+                        if Flags.debug then Console.WriteLine("shifting, reduced errorRecoverylevel to {0}\n", errorSuppressionCountDown)
 #endif
                     let nextState = actionValue action                                     
-                    if not haveLookahead then failwith "shift on end of input!";
+                    if not haveLookahead then failwith "shift on end of input!"
                     let data = tables.dataOfToken lookaheadToken
-                    valueStack.Push(ValueInfo(data, lookaheadStartPos, lookaheadEndPos));
-                    stateStack.Push(nextState);                                                                
+                    valueStack.Push(ValueInfo(data, lookaheadStartPos, lookaheadEndPos))
+                    stateStack.Push(nextState)                                                                
 #if __DEBUG
-                    if Flags.debug then Console.WriteLine("shift/consume input {0}, shift to state {1}", report haveLookahead lookaheadToken, nextState);
+                    if Flags.debug then Console.WriteLine("shift/consume input {0}, shift to state {1}", report haveLookahead lookaheadToken, nextState)
 #endif
                     haveLookahead <- false
 
@@ -382,27 +378,27 @@ module Implementation =
                     let n = int tables.reductionSymbolCounts.[prod]
                        // pop the symbols, populate the values and populate the locations                              
 #if __DEBUG
-                    if Flags.debug then Console.Write("reduce popping {0} values/states, lookahead {1}", n, report haveLookahead lookaheadToken);
+                    if Flags.debug then Console.Write("reduce popping {0} values/states, lookahead {1}", n, report haveLookahead lookaheadToken)
 #endif
                     
-                    lhsPos.[0] <- Position.Empty;                                                                     
-                    lhsPos.[1] <- Position.Empty;  
+                    lhsPos.[0] <- Position.Empty                                                                     
+                    lhsPos.[1] <- Position.Empty  
                     for i = 0 to n - 1 do                                                                             
-                        if valueStack.IsEmpty then failwith "empty symbol stack";
+                        if valueStack.IsEmpty then failwith "empty symbol stack"
                         let topVal = valueStack.Peep()
-                        valueStack.Pop();
-                        stateStack.Pop();
-                        ruleValues.[(n-i)-1] <- topVal.value;  
-                        ruleStartPoss.[(n-i)-1] <- topVal.startPos;  
-                        ruleEndPoss.[(n-i)-1] <- topVal.endPos;  
-                        if lhsPos.[1] = Position.Empty then lhsPos.[1] <- topVal.endPos;
+                        valueStack.Pop()
+                        stateStack.Pop()
+                        ruleValues.[(n-i)-1] <- topVal.value  
+                        ruleStartPoss.[(n-i)-1] <- topVal.startPos  
+                        ruleEndPoss.[(n-i)-1] <- topVal.endPos  
+                        if lhsPos.[1] = Position.Empty then lhsPos.[1] <- topVal.endPos
                         if not (topVal.startPos = Position.Empty) then lhsPos.[0] <- topVal.startPos
-                    done;                                                                                           
+                    done                                                                                           
                     
                     try                                                                                               
-                          // Printf.printf "reduce %d\n" prod;                                                       
+                          // Printf.printf "reduce %d\n" prod                                                       
                         let redResult = reduction parseState                                                          
-                        valueStack.Push(ValueInfo(redResult, lhsPos.[0], lhsPos.[1]));
+                        valueStack.Push(ValueInfo(redResult, lhsPos.[0], lhsPos.[1]))
                         let currState = stateStack.Peep()
                         let newGotoState = gotoTable.Read(int tables.productionToNonTerminalTable.[prod], currState)
                         stateStack.Push(newGotoState)
@@ -411,23 +407,23 @@ module Implementation =
 #endif
                     with                                                                                              
                     | Accept res ->                                                                            
-                          finished <- true;                                                                             
+                          finished <- true                                                                             
                           valueStack.Push(ValueInfo(res, lhsPos.[0], lhsPos.[1])) 
                     | RecoverableParseError ->
 #if __DEBUG
-                          if Flags.debug then Console.WriteLine("RecoverableParseErrorException...\n");
+                          if Flags.debug then Console.WriteLine("RecoverableParseErrorException...\n")
 #endif
-                          popStackUntilErrorShifted(None);
+                          popStackUntilErrorShifted(None)
                           // User code raised a Parse_error. Don't report errors again until three tokens have been shifted 
                           errorSuppressionCountDown <- 3
                 elif kind = errorFlag then (
 #if __DEBUG
-                    if Flags.debug then Console.Write("ErrorFlag... ");
+                    if Flags.debug then Console.Write("ErrorFlag... ")
 #endif
                     // Silently discard inputs and don't report errors 
                     // until three tokens in a row have been shifted 
 #if __DEBUG
-                    if Flags.debug then printfn "error on token '%A' " (if haveLookahead then Some(lookaheadToken) else None);
+                    if Flags.debug then printfn "error on token '%A' " (if haveLookahead then Some(lookaheadToken) else None)
 #endif
                     if errorSuppressionCountDown > 0 then 
                         // If we're in the end-of-file count down then we're very keen to 'Accept'.
@@ -435,16 +431,16 @@ module Implementation =
                         // and an EOF token. 
                         if inEofCountDown && eofCountDown < 10 then 
 #if __DEBUG
-                            if Flags.debug then printfn "poppin stack, lokking to shift both 'error' and that token, during end-of-file error recovery" ;
+                            if Flags.debug then printfn "poppin stack, lokking to shift both 'error' and that token, during end-of-file error recovery" 
 #endif
-                            popStackUntilErrorShifted(if haveLookahead then Some(lookaheadToken) else None);
+                            popStackUntilErrorShifted(if haveLookahead then Some(lookaheadToken) else None)
 
                         // If we don't haveLookahead then the end-of-file count down is over and we have no further options.
                         if not haveLookahead then 
                             failwith "parse error: unexpected end of file"
                             
 #if __DEBUG
-                        if Flags.debug then printfn "discarding token '%A' during error suppression" (if haveLookahead then Some(lookaheadToken) else None);
+                        if Flags.debug then printfn "discarding token '%A' during error suppression" (if haveLookahead then Some(lookaheadToken) else None)
 #endif
                         // Discard the token
                         haveLookahead <- false
@@ -454,10 +450,10 @@ module Implementation =
 
                         let currentToken = if haveLookahead then Some(lookaheadToken) else None
                         let actions,defaultAction = actionTable.ReadAll(state) 
-                        let explicit = Set.ofList [ for (tag,_action) in actions -> tag ]
+                        let explicit = Set.ofList [ for tag,_action in actions -> tag ]
                         
                         let shiftableTokens = 
-                           [ for (tag,action) in actions do
+                           [ for tag,action in actions do
                                  if (actionKind action) = shiftFlag then 
                                      yield tag
                              if actionKind defaultAction = shiftFlag  then
@@ -471,7 +467,7 @@ module Implementation =
                                yield stateToProdIdxsTable.ReadAll(state)  ]
 
                         let reduceTokens = 
-                           [ for (tag,action) in actions do
+                           [ for tag,action in actions do
                                 if actionKind(action) = reduceFlag then
                                     yield tag
                              if actionKind(defaultAction) = reduceFlag  then
@@ -480,35 +476,27 @@ module Implementation =
                                          yield tag ] in
                         //let activeRules = stateStack |> List.iter (fun state -> 
                         let errorContext = new ParseErrorContext<'tok>(stateStack,parseState, reduceTokens,currentToken,reducibleProductions, shiftableTokens, "syntax error")
-                        tables.parseError(errorContext);
-                        popStackUntilErrorShifted(None);
-                        errorSuppressionCountDown <- 3;
+                        tables.parseError(errorContext)
+                        popStackUntilErrorShifted(None)
+                        errorSuppressionCountDown <- 3
 #if __DEBUG
-                        if Flags.debug then System.Console.WriteLine("generated syntax error and shifted error token, haveLookahead = {0}\n", haveLookahead);
+                        if Flags.debug then System.Console.WriteLine("generated syntax error and shifted error token, haveLookahead = {0}\n", haveLookahead)
 #endif
                     )
                 ) elif kind = acceptFlag then 
                     finished <- true
 #if __DEBUG
                 else
-                  if Flags.debug then System.Console.WriteLine("ALARM!!! drop through case in parser");  
+                  if Flags.debug then System.Console.WriteLine("ALARM!!! drop through case in parser")  
 #endif
-        done;                                                                                                     
+        done                                                                                                     
         // OK, we're done - read off the overall generated value
         valueStack.Peep().value
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-type internal Tables<'tok> with
-#else
 type Tables<'tok> with
-#endif
-    member tables.Interpret (lexer,lexbuf,initialState) = 
-        Implementation.interpret tables lexer lexbuf initialState
+    member tables.Interpret (lexer,lexbuf,startState) = 
+        Implementation.interpret tables lexer lexbuf startState
     
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-module internal ParseHelpers = 
-#else
 module ParseHelpers = 
-#endif
     let parse_error (_s:string) = ()
     let parse_error_rich = (None : (ParseErrorContext<_> -> unit) option)
diff --git a/buildtools/fslex/Parsing.fsi b/buildtools/fslex/Parsing.fsi
index f4d12606462..e4e7329441a 100644
--- a/buildtools/fslex/Parsing.fsi
+++ b/buildtools/fslex/Parsing.fsi
@@ -2,129 +2,132 @@
 // (c) Microsoft Corporation 2005-2009.
 //=========================================================================
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-namespace Internal.Utilities.Text.Parsing
-open Internal.Utilities
-open Internal.Utilities.Text.Lexing
-#else
-namespace Microsoft.FSharp.Text.Parsing
-open Microsoft.FSharp.Text.Lexing
-#endif
+namespace FSharp.Text.Parsing
+open FSharp.Text.Lexing
 
 open System.Collections.Generic
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-type internal IParseState = 
-#else
 /// The information accessible via the <c>parseState</c> value within parser actions.
 type IParseState = 
-#endif
     /// Get the start and end position for the terminal or non-terminal at a given index matched by the production
     abstract InputRange: index:int -> Position * Position
+
     /// Get the end position for the terminal or non-terminal at a given index matched by the production
     abstract InputEndPosition: int -> Position 
+
     /// Get the start position for the terminal or non-terminal at a given index matched by the production
     abstract InputStartPosition: int -> Position 
+
     /// Get the full range of positions matched by the production
     abstract ResultRange: Position * Position
+
     /// Get the value produced by the terminal or non-terminal at the given position
     abstract GetInput   : int -> obj 
+
     /// Get the store of local values associated with this parser
     // Dynamically typed, non-lexically scoped local store
     abstract ParserLocalStore : IDictionary<string,obj>
+
     /// Raise an error in this parse context
     abstract RaiseError<'b> : unit -> 'b 
 
 
 [<Sealed>]
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-type internal ParseErrorContext<'tok> =
-#else
 /// The context provided when a parse error occurs
 type ParseErrorContext<'tok> =
-#endif
       /// The stack of state indexes active at the parse error 
       member StateStack  : int list
+
       /// The state active at the parse error 
       member ParseState : IParseState
+
       /// The tokens that would cause a reduction at the parse error 
       member ReduceTokens: int list
+
       /// The stack of productions that would be reduced at the parse error 
       member ReducibleProductions : int list list
+
       /// The token that caused the parse error
       member CurrentToken : 'tok option
+
       /// The token that would cause a shift at the parse error
       member ShiftTokens : int list
+
       /// The message associated with the parse error
       member Message : string
 
 /// Tables generated by fsyacc
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-type internal Tables<'tok> = 
-#else
 /// The type of the tables contained in a file produced by the fsyacc.exe parser generator.
 type Tables<'tok> = 
-#endif
-    { /// The reduction table
+    { 
+      /// The reduction table
       reductions: (IParseState -> obj) array ;
+      
       /// The token number indicating the end of input
       endOfInputTag: int;
+      
       /// A function to compute the tag of a token
       tagOfToken: 'tok -> int;
+      
       /// A function to compute the data carried by a token
       dataOfToken: 'tok -> obj; 
+      
       /// The sparse action table elements
       actionTableElements: uint16[];
+      
       /// The sparse action table row offsets
       actionTableRowOffsets: uint16[];
+      
       /// The number of symbols for each reduction
       reductionSymbolCounts: uint16[];
+      
       /// The immediate action table
       immediateActions: uint16[];      
+      
       /// The sparse goto table
       gotos: uint16[];
+      
       /// The sparse goto table row offsets
       sparseGotoTableRowOffsets: uint16[];
+      
       /// The sparse table for the productions active for each state
       stateToProdIdxsTableElements: uint16[];  
+      
       /// The sparse table offsets for the productions active for each state
       stateToProdIdxsTableRowOffsets: uint16[];  
+      
       /// This table is logically part of the Goto table
       productionToNonTerminalTable: uint16[];
+      
       /// This function is used to hold the user specified "parse_error" or "parse_error_rich" functions
       parseError:  ParseErrorContext<'tok> -> unit;
+      
       /// The total number of terminals 
       numTerminals: int;
+      
       /// The tag of the error terminal
-      tagOfErrorTerminal: int }
+      tagOfErrorTerminal: int 
+    }
 
     /// Interpret the parser table taking input from the given lexer, using the given lex buffer, and the given start state.
     /// Returns an object indicating the final synthesized value for the parse.
-    member Interpret :  lexer:(LexBuffer<'char> -> 'tok) * lexbuf:LexBuffer<'char> * initialState:int -> obj 
+    member Interpret :  lexer:(LexBuffer<'char> -> 'tok) * lexbuf:LexBuffer<'char> * startState:int -> obj 
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-exception internal Accept of obj
-exception internal RecoverableParseError
-#else
 /// Indicates an accept action has occured
 exception Accept of obj
 /// Indicates a parse error has occured and parse recovery is in progress
 exception RecoverableParseError
-#endif
 
 #if __DEBUG
 module internal Flags =
   val mutable debug : bool
 #endif
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-module internal ParseHelpers = 
-#else
 /// Helpers used by generated parsers.
 module ParseHelpers = 
-#endif
    /// The default implementation of the parse_error_rich function
    val parse_error_rich: (ParseErrorContext<'tok> -> unit) option
+   
    /// The default implementation of the parse_error function
    val parse_error: string -> unit
 
diff --git a/buildtools/fslex/fslex.fs b/buildtools/fslex/fslex.fs
index 98966fdfaf3..0769f022f39 100644
--- a/buildtools/fslex/fslex.fs
+++ b/buildtools/fslex/fslex.fs
@@ -1,220 +1,84 @@
-// (c) Microsoft Corporation 2005-2009.  
+// (c) Microsoft Corporation 2005-2009.
 
-module internal FsLexYacc.FsLex.Driver 
+module FsLexYacc.FsLex.Program
 
-open FsLexYacc.FsLex
 open FsLexYacc.FsLex.AST
-open FsLexYacc.FsLex.Parser
+open FsLexYacc.FsLex.Driver
 open Printf
-open Internal.Utilities
-open Internal.Utilities.Text.Lexing
-open System
-open System.Collections.Generic
-open System.IO 
+open FSharp.Text
+open System.IO
 
-//------------------------------------------------------------------
-// This code is duplicated from Microsoft.FSharp.Compiler.UnicodeLexing
-
-type Lexbuf =  LexBuffer<char>
-
-/// Standard utility to create a Unicode LexBuffer
-///
-/// One small annoyance is that LexBuffers and not IDisposable. This means 
-/// we can't just return the LexBuffer object, since the file it wraps wouldn't
-/// get closed when we're finished with the LexBuffer. Hence we return the stream,
-/// the reader and the LexBuffer. The caller should dispose the first two when done.
-let UnicodeFileAsLexbuf (filename,codePage : int option) : FileStream * StreamReader * Lexbuf =
-    // Use the .NET functionality to auto-detect the unicode encoding
-    // It also presents the bytes read to the lexer in UTF8 decoded form
-    let stream  = new FileStream(filename,FileMode.Open,FileAccess.Read,FileShare.Read) 
-    let reader = 
-        match codePage with 
-        | None -> new  StreamReader(stream,true)
-        | Some n -> new  StreamReader(stream,System.Text.Encoding.GetEncoding(n)) 
-    let lexbuf = LexBuffer.FromFunction(reader.Read) 
-    lexbuf.EndPos <- Position.FirstLine(filename)
-    stream, reader, lexbuf
-    
 //------------------------------------------------------------------
 // This is the program proper
 
-let input = ref None
-let out = ref None
-let inputCodePage = ref None
-let light = ref None
-
+let mutable input = None
+let mutable out = None
+let mutable inputCodePage = None
+let mutable light = None
+let mutable modname = None
+let mutable internal_module = false
 let mutable lexlib = "FSharp.Text.Lexing"
+let mutable unicode = false
+let mutable caseInsensitive = false
 
 let usage =
-  [ ArgInfo ("-o", ArgType.String (fun s -> out := Some s), "Name the output file.") 
-    ArgInfo ("--codepage", ArgType.Int (fun i -> inputCodePage := Some i), "Assume input lexer specification file is encoded with the given codepage.") 
-    ArgInfo ("--light", ArgType.Unit (fun () ->  light := Some true), "(ignored)")
-    ArgInfo ("--light-off", ArgType.Unit (fun () ->  light := Some false), "Add #light \"off\" to the top of the generated file")
+  [ ArgInfo ("-o", ArgType.String (fun s -> out <- Some s), "Name the output file.")
+    ArgInfo ("--module", ArgType.String (fun s -> modname <- Some s), "Define the F# module name to host the generated parser.");
+    ArgInfo ("--internal", ArgType.Unit (fun () -> internal_module <- true), "Generate an internal module");
+    ArgInfo ("--codepage", ArgType.Int (fun i -> inputCodePage <- Some i), "Assume input lexer specification file is encoded with the given codepage.")
+    ArgInfo ("--light", ArgType.Unit (fun () ->  light <- Some true), "(ignored)")
+    ArgInfo ("--light-off", ArgType.Unit (fun () ->  light <- Some false), "Add #light \"off\" to the top of the generated file")
     ArgInfo ("--lexlib", ArgType.String (fun s ->  lexlib <- s), "Specify the namespace for the implementation of the lexer table interpreter (default FSharp.Text.Lexing)")
-    ArgInfo ("--unicode", ArgType.Set unicode, "Produce a lexer for use with 16-bit unicode characters.")  
+    ArgInfo ("--unicode", ArgType.Unit (fun () -> unicode <- true), "Produce a lexer for use with 16-bit unicode characters.")
+    ArgInfo ("-i", ArgType.Unit (fun () -> caseInsensitive <- true), "Produce a case-insensitive lexer.")
   ]
 
-let _ = ArgParser.Parse(usage, (fun x -> match !input with Some _ -> failwith "more than one input given" | None -> input := Some x), "fslex <filename>")
-
-let outputInt (os: TextWriter) (n:int) = os.Write(string n)
-
-let outputCodedUInt16 (os: #TextWriter)  (n:int) = 
-  os.Write n
-  os.Write "us; "
-
-let sentinel = 255 * 256 + 255 
-
-let lineCount = ref 0
-let cfprintfn (os: #TextWriter) fmt = Printf.kfprintf (fun () -> incr lineCount; os.WriteLine()) os fmt
-
-let main() = 
-  try 
-    let filename = (match !input with Some x -> x | None -> failwith "no input given") 
-    let domain = if !unicode then "Unicode" else "Ascii" 
-    let spec = 
-      let stream,reader,lexbuf = UnicodeFileAsLexbuf(filename, !inputCodePage) 
-      use stream = stream
-      use reader = reader
-      try 
-          Parser.spec Lexer.token lexbuf 
-      with e -> 
-          eprintf "%s(%d,%d): error: %s" filename lexbuf.StartPos.Line lexbuf.StartPos.Column 
-              (match e with 
-               | Failure s -> s 
+let _ = ArgParser.Parse(usage, (fun x -> match input with Some _ -> failwith "more than one input given" | None -> input <- Some x), "fslex <filename>")
+
+let compileSpec (spec: Spec) (ctx: ParseContext) =
+    let perRuleData, dfaNodes = Compile ctx spec 
+    let dfaNodes = dfaNodes |> List.sortBy (fun n -> n.Id)
+    perRuleData, dfaNodes
+
+let main() =
+  try
+    let filename = (match input with Some x -> x | None -> failwith "no input given")
+    let parseContext = 
+      { unicode = unicode 
+        caseInsensitive = caseInsensitive }
+    let spec =
+        match readSpecFromFile filename inputCodePage with
+        | Ok spec -> spec
+        | Error (e, line, column) ->
+            eprintf "%s(%d,%d): error: %s" filename line column
+              (match e with
+               | Failure s -> s
                | _ -> e.Message)
-          exit 1
-    printfn "compiling to dfas (can take a while...)"
-    let perRuleData, dfaNodes = AST.Compile spec
-    let dfaNodes = dfaNodes |> List.sortBy (fun n -> n.Id) 
+            exit 1
 
+    printfn "compiling to dfas (can take a while...)"
+    let perRuleData, dfaNodes = compileSpec spec parseContext
     printfn "%d states" dfaNodes.Length
-    printfn "writing output" 
-    
-    let output = 
-        match !out with 
-        | Some x -> x 
-        | _ -> 
-            Path.Combine (Path.GetDirectoryName filename,Path.GetFileNameWithoutExtension(filename)) + ".fs"
-    use os = System.IO.File.CreateText output
-
-    if (!light = Some(false)) || (!light = None && (Path.HasExtension(output) && Path.GetExtension(output) = ".ml")) then
-        cfprintfn os "#light \"off\""
-    
-    let printLinesIfCodeDefined (code,pos:Position) =
-        if pos <> Position.Empty  // If bottom code is unspecified, then position is empty.        
-        then 
-            cfprintfn os "# %d \"%s\"" pos.Line pos.FileName
-            cfprintfn os "%s" code
-
-    printLinesIfCodeDefined spec.TopCode
-    let code = fst spec.TopCode
-    lineCount := !lineCount + code.Replace("\r","").Split([| '\n' |]).Length
-    cfprintfn os "# %d \"%s\"" !lineCount output
-    
-    cfprintfn os "let trans : uint16[] array = "
-    cfprintfn os "    [| "
-    if !unicode then 
-        let specificUnicodeChars = GetSpecificUnicodeChars()
-        // This emits a (numLowUnicodeChars+NumUnicodeCategories+(2*#specificUnicodeChars)+1) * #states array of encoded UInt16 values
-        
-        // Each row for the Unicode table has format 
-        //      128 entries for ASCII characters
-        //      A variable number of 2*UInt16 entries for SpecificUnicodeChars 
-        //      30 entries, one for each UnicodeCategory
-        //      1 entry for EOF
-        //
-        // Each entry is an encoded UInt16 value indicating the next state to transition to for this input.
-        //
-        // For the SpecificUnicodeChars the entries are char/next-state pairs.
-        for state in dfaNodes do
-            cfprintfn os "    (* State %d *)" state.Id
-            fprintf os "     [| "
-            let trans = 
-                let dict = new Dictionary<_,_>()
-                state.Transitions |> List.iter dict.Add
-                dict
-            let emit n = 
-                if trans.ContainsKey(n) then 
-                  outputCodedUInt16 os trans.[n].Id 
-                else
-                  outputCodedUInt16 os sentinel
-            for i = 0 to numLowUnicodeChars-1 do 
-                let c = char i
-                emit (EncodeChar c)
-            for c in specificUnicodeChars do 
-                outputCodedUInt16 os (int c) 
-                emit (EncodeChar c)
-            for i = 0 to NumUnicodeCategories-1 do 
-                emit (EncodeUnicodeCategoryIndex i)
-            emit Eof
-            cfprintfn os "|];"
-        done
-    
-    else
-        // Each row for the ASCII table has format 
-        //      256 entries for ASCII characters
-        //      1 entry for EOF
-        //
-        // Each entry is an encoded UInt16 value indicating the next state to transition to for this input.
-
-        // This emits a (256+1) * #states array of encoded UInt16 values
-        for state in dfaNodes do
-            cfprintfn os "   (* State %d *)" state.Id
-            fprintf os " [|"
-            let trans = 
-                let dict = new Dictionary<_,_>()
-                state.Transitions |> List.iter dict.Add
-                dict
-            let emit n = 
-                if trans.ContainsKey(n) then 
-                  outputCodedUInt16 os trans.[n].Id 
-                else
-                  outputCodedUInt16 os sentinel
-            for i = 0 to 255 do 
-                let c = char i
-                emit (EncodeChar c)
-            emit Eof
-            cfprintfn os "|];"
-        done
-    
-    cfprintfn os "    |] "
-    
-    fprintf os "let actions : uint16[] = [|"
-    for state in dfaNodes do
-        if state.Accepted.Length > 0 then 
-          outputCodedUInt16 os (snd state.Accepted.Head)
-        else
-          outputCodedUInt16 os sentinel
-    done
-    cfprintfn os "|]"
-    cfprintfn os "let _fslex_tables = %s.%sTables.Create(trans,actions)" lexlib domain
-    
-    cfprintfn os "let rec _fslex_dummy () = _fslex_dummy() "
-
-    // These actions push the additional start state and come first, because they are then typically inlined into later
-    // rules. This means more tailcalls are taken as direct branches, increasing efficiency and 
-    // improving stack usage on platforms that do not take tailcalls.
-    for ((startNode, actions),(ident,args,_)) in List.zip perRuleData spec.Rules do
-        cfprintfn os "// Rule %s" ident
-        cfprintfn os "and %s %s lexbuf =" ident (String.Join(" ",Array.ofList args))
-        cfprintfn os "  match _fslex_tables.Interpret(%d,lexbuf) with" startNode.Id
-        actions |> Seq.iteri (fun i (code:string, pos) -> 
-            cfprintfn os "  | %d -> ( " i
-            cfprintfn os "# %d \"%s\"" pos.Line pos.FileName
-            let lines = code.Split([| '\r'; '\n' |], StringSplitOptions.RemoveEmptyEntries)
-            for line in lines do
-                cfprintfn os "               %s" line
-            cfprintfn os "# %d \"%s\"" !lineCount output
-            cfprintfn os "          )")
-        cfprintfn os "  | _ -> failwith \"%s\"" ident
-    
 
-    cfprintfn os ""
-        
-    printLinesIfCodeDefined spec.BottomCode
-    cfprintfn os "# 3000000 \"%s\"" output
-    
-  with e -> 
+    printfn "writing output"
+
+    let output =
+        match out with
+        | Some x -> x
+        | _ -> Path.ChangeExtension(filename, ".fs")
+
+    let state : GeneratorState =
+        { inputFileName = filename
+          outputFileName = output
+          inputCodePage = inputCodePage |> Option.map System.Text.Encoding.GetEncoding |> Option.defaultValue System.Text.Encoding.UTF8
+          generatedModuleName = modname
+          disableLightMode = light
+          generateInternalModule = internal_module
+          lexerLibraryName = lexlib
+          domain = if unicode then Unicode else ASCII }
+    writeSpecToFile state spec perRuleData dfaNodes
+
+  with e ->
     eprintf "FSLEX: error FSL000: %s" (match e with Failure s -> s | e -> e.ToString())
     exit 1
 
diff --git a/buildtools/fslex/fslex.fsproj b/buildtools/fslex/fslex.fsproj
index 8577bf4e3af..b069eb6d53e 100644
--- a/buildtools/fslex/fslex.fsproj
+++ b/buildtools/fslex/fslex.fsproj
@@ -3,7 +3,6 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>net7.0</TargetFramework>
-    <DefineConstants>INTERNALIZED_FSLEXYACC_RUNTIME;$(DefineConstants)</DefineConstants>
     <DisableImplicitFSharpCoreReference>true</DisableImplicitFSharpCoreReference>
     <UseAppHost Condition="'$(DotNetBuildFromSource)' == 'true'">false</UseAppHost>
   </PropertyGroup>
@@ -18,6 +17,7 @@
     <Compile Include="fslexast.fs" />
     <Compile Include="fslexpars.fs" />
     <Compile Include="fslexlex.fs" />
+    <Compile Include="fslexdriver.fs" />
     <Compile Include="fslex.fs" />
   </ItemGroup>
 
diff --git a/buildtools/fslex/fslexast.fs b/buildtools/fslex/fslexast.fs
index 89cbdc4dfaf..fef6ac65ead 100644
--- a/buildtools/fslex/fslexast.fs
+++ b/buildtools/fslex/fslexast.fs
@@ -1,160 +1,182 @@
 (* (c) Microsoft Corporation 2005-2008.  *)
 
-module internal FsLexYacc.FsLex.AST
+module FsLexYacc.FsLex.AST
 
 open System.Collections.Generic
-open FSharp.Text
-open Microsoft.FSharp.Collections
-open Internal.Utilities
-open Internal.Utilities.Text.Lexing
-
-let (|KeyValue|) (kvp:KeyValuePair<_,_>) = kvp.Key,kvp.Value
+open System.Globalization
+open FSharp.Text.Lexing
 
 type Ident = string
 type Code = string * Position
 
+
+type ParseContext = {
+    unicode : bool
+    caseInsensitive: bool
+}
+
+type Parser<'t> = ParseContext -> 't
+
 type Alphabet = uint32
 
 let Eof : Alphabet = 0xFFFFFFFEu
 let Epsilon : Alphabet = 0xFFFFFFFFu
 
-
-let unicode = ref false
-
-let unicodeCategories = 
- dict 
-  [| "Pe", System.Globalization.UnicodeCategory.ClosePunctuation; // (Pe)
-    "Pc", System.Globalization.UnicodeCategory.ConnectorPunctuation; // (Pc)
-    "Cc", System.Globalization.UnicodeCategory.Control; // (Cc)
-    "Sc", System.Globalization.UnicodeCategory.CurrencySymbol; // (Sc)
-    "Pd", System.Globalization.UnicodeCategory.DashPunctuation; // (Pd)
-    "Nd", System.Globalization.UnicodeCategory.DecimalDigitNumber; // (Nd)
-    "Me", System.Globalization.UnicodeCategory.EnclosingMark; // (Me)
-    "Pf", System.Globalization.UnicodeCategory.FinalQuotePunctuation; // (Pf)
-    "Cf", enum 15; //System.Globalization.UnicodeCategory.Format; // (Cf)
-    "Pi", System.Globalization.UnicodeCategory.InitialQuotePunctuation; // (Pi)
-    "Nl", System.Globalization.UnicodeCategory.LetterNumber; // (Nl)
-    "Zl", System.Globalization.UnicodeCategory.LineSeparator; // (Zl)
-    "Ll", System.Globalization.UnicodeCategory.LowercaseLetter; // (Ll)
-    "Sm", System.Globalization.UnicodeCategory.MathSymbol; // (Sm)
-    "Lm", System.Globalization.UnicodeCategory.ModifierLetter; // (Lm)
-    "Sk", System.Globalization.UnicodeCategory.ModifierSymbol; // (Sk)
-    "Mn", System.Globalization.UnicodeCategory.NonSpacingMark; // (Mn)
-    "Ps", System.Globalization.UnicodeCategory.OpenPunctuation; // (Ps)
-    "Lo", System.Globalization.UnicodeCategory.OtherLetter; // (Lo)
-    "Cn", System.Globalization.UnicodeCategory.OtherNotAssigned; // (Cn)
-    "No", System.Globalization.UnicodeCategory.OtherNumber; // (No)
-    "Po", System.Globalization.UnicodeCategory.OtherPunctuation; // (Po)
-    "So", System.Globalization.UnicodeCategory.OtherSymbol; // (So)
-    "Zp", System.Globalization.UnicodeCategory.ParagraphSeparator; // (Zp)
-    "Co", System.Globalization.UnicodeCategory.PrivateUse; // (Co)
-    "Zs", System.Globalization.UnicodeCategory.SpaceSeparator; // (Zs)
-    "Mc", System.Globalization.UnicodeCategory.SpacingCombiningMark; // (Mc)
-    "Cs", System.Globalization.UnicodeCategory.Surrogate; // (Cs)
-    "Lt", System.Globalization.UnicodeCategory.TitlecaseLetter; // (Lt)
-    "Lu", System.Globalization.UnicodeCategory.UppercaseLetter; // (Lu)
+let unicodeCategories =
+ dict
+  [| "Pe", UnicodeCategory.ClosePunctuation; // (Pe)
+    "Pc", UnicodeCategory.ConnectorPunctuation; // (Pc)
+    "Cc", UnicodeCategory.Control; // (Cc)
+    "Sc", UnicodeCategory.CurrencySymbol; // (Sc)
+    "Pd", UnicodeCategory.DashPunctuation; // (Pd)
+    "Nd", UnicodeCategory.DecimalDigitNumber; // (Nd)
+    "Me", UnicodeCategory.EnclosingMark; // (Me)
+    "Pf", UnicodeCategory.FinalQuotePunctuation; // (Pf)
+    "Cf", UnicodeCategory.Format; // (Cf)
+    "Pi", UnicodeCategory.InitialQuotePunctuation; // (Pi)
+    "Nl", UnicodeCategory.LetterNumber; // (Nl)
+    "Zl", UnicodeCategory.LineSeparator; // (Zl)
+    "Ll", UnicodeCategory.LowercaseLetter; // (Ll)
+    "Sm", UnicodeCategory.MathSymbol; // (Sm)
+    "Lm", UnicodeCategory.ModifierLetter; // (Lm)
+    "Sk", UnicodeCategory.ModifierSymbol; // (Sk)
+    "Mn", UnicodeCategory.NonSpacingMark; // (Mn)
+    "Ps", UnicodeCategory.OpenPunctuation; // (Ps)
+    "Lo", UnicodeCategory.OtherLetter; // (Lo)
+    "Cn", UnicodeCategory.OtherNotAssigned; // (Cn)
+    "No", UnicodeCategory.OtherNumber; // (No)
+    "Po", UnicodeCategory.OtherPunctuation; // (Po)
+    "So", UnicodeCategory.OtherSymbol; // (So)
+    "Zp", UnicodeCategory.ParagraphSeparator; // (Zp)
+    "Co", UnicodeCategory.PrivateUse; // (Co)
+    "Zs", UnicodeCategory.SpaceSeparator; // (Zs)
+    "Mc", UnicodeCategory.SpacingCombiningMark; // (Mc)
+    "Cs", UnicodeCategory.Surrogate; // (Cs)
+    "Lt", UnicodeCategory.TitlecaseLetter; // (Lt)
+    "Lu", UnicodeCategory.UppercaseLetter; // (Lu)
   |]
 
 let NumUnicodeCategories = unicodeCategories.Count
-let _ = assert (NumUnicodeCategories = 30) // see table interpreter
+assert (NumUnicodeCategories = 30) // see table interpreter
 let encodedUnicodeCategoryBase = 0xFFFFFF00u
+
 let EncodeUnicodeCategoryIndex(idx:int) = encodedUnicodeCategoryBase + uint32 idx
-let EncodeUnicodeCategory(s:string) = 
-    if not (!unicode) then 
-         failwith "unicode category classes may only be used if --unicode is specified";
-    if unicodeCategories.ContainsKey(s) then 
+let EncodeUnicodeCategory s: Parser<uint32> = fun ctx ->
+    if not ctx.unicode then
+        failwith "unicode category classes may only be used if --unicode is specified"
+    if unicodeCategories.ContainsKey(s) then
         EncodeUnicodeCategoryIndex (int32 unicodeCategories.[s])
     else
         failwithf "invalid Unicode category: '%s'" s
 
+let TryDecodeUnicodeCategory(x:Alphabet) : UnicodeCategory option =
+    let maybeUnicodeCategory = x - encodedUnicodeCategoryBase |> int32 |> enum<UnicodeCategory>
+    if UnicodeCategory.IsDefined(typeof<UnicodeCategory>, maybeUnicodeCategory) then
+        Some maybeUnicodeCategory
+    else
+        None
+
+let (|UnicodeCategoryAP|_|) (x:Alphabet) = TryDecodeUnicodeCategory x
+
 let IsUnicodeCategory(x:Alphabet) = (encodedUnicodeCategoryBase <= x) && (x < encodedUnicodeCategoryBase + uint32 NumUnicodeCategories)
 let UnicodeCategoryIndex(x:Alphabet) = (x - encodedUnicodeCategoryBase)
 
 let numLowUnicodeChars = 128
-let _ = assert (numLowUnicodeChars = 128) // see table interpreter
-let specificUnicodeChars = new Dictionary<_,_>()
-let specificUnicodeCharsDecode = new Dictionary<_,_>()
-let EncodeChar(c:char) = 
+assert (numLowUnicodeChars = 128) // see table interpreter
+let specificUnicodeChars = Dictionary()
+let specificUnicodeCharsDecode = Dictionary()
+
+let TryEncodeChar(c:char): Parser<uint32 option> = fun ctx ->
      let x = System.Convert.ToUInt32 c
-     if !unicode then 
-         if x < uint32 numLowUnicodeChars then x 
-         else 
+     if ctx.unicode then
+         if x < uint32 numLowUnicodeChars then Some x
+         else
              if not(specificUnicodeChars.ContainsKey(c)) then
-                 let idx = uint32 numLowUnicodeChars + uint32 specificUnicodeChars.Count  
+                 let idx = uint32 numLowUnicodeChars + uint32 specificUnicodeChars.Count
                  specificUnicodeChars.[c] <- idx
                  specificUnicodeCharsDecode.[idx] <- c
-             specificUnicodeChars.[c]
-     else         
-         if x >= 256u then failwithf "the Unicode character '%c' may not be used unless --unicode is specified" c;
-         x
-let DecodeChar(x:Alphabet) = 
-     if !unicode then 
+             Some specificUnicodeChars.[c]
+     else
+         if x >= 256u
+         then None
+         else Some x
+
+let EncodeChar(c:char) : Parser<uint32> = fun ctx ->
+    TryEncodeChar c ctx
+    |> Option.defaultWith (fun () -> failwithf "the Unicode character '0x%x' may not be used unless --unicode is specified" <| int c)
+
+let DecodeChar(x:Alphabet): Parser<char> = fun ctx ->
+     if ctx.unicode then
          if x < uint32 numLowUnicodeChars then System.Convert.ToChar x
          else specificUnicodeCharsDecode.[x]
      else
-         if x >= 256u then failwithf "the Unicode character '%x' may not be used unless --unicode is specified" x;
+         if x >= 256u then failwithf "the Unicode character '0x%x' may not be used unless --unicode is specified" x
          System.Convert.ToChar x
-         
-         
+
+
 
 let NumSpecificUnicodeChars() = specificUnicodeChars.Count
-let GetSpecificUnicodeChars() = 
-    specificUnicodeChars 
-        |> Seq.sortBy (fun (KeyValue(k,v)) -> v) 
-        |> Seq.map (fun (KeyValue(k,v)) -> k) 
-
-let GetSingleCharAlphabet() = 
-    if !unicode 
-    then Set.ofList [ for c in 0..numLowUnicodeChars-1 do yield (char c)
-                      for c in GetSpecificUnicodeChars() do yield c ]
-    else Set.ofList [ for x in 0..255 ->  (char x) ]
-         
-let GetAlphabet() = 
-    if !unicode 
-    then Set.ofList [ for c in GetSingleCharAlphabet() do yield EncodeChar c
+let GetSpecificUnicodeChars() =
+    specificUnicodeChars
+        |> Seq.sortBy (fun (KeyValue(_,v)) -> v)
+        |> Seq.map (fun (KeyValue(k,_)) -> k)
+
+let GetSingleCharAlphabet: Parser<Set<char>> = fun ctx ->
+    if ctx.unicode
+    then Set.ofList [ yield! { char 0 .. char <| numLowUnicodeChars-1 }
+                      yield! GetSpecificUnicodeChars() ]
+    else Set.ofList [ char 0 .. char 255 ]
+
+let GetAlphabet: Parser<Set<uint32>> = fun ctx ->
+    if ctx.unicode
+    then Set.ofList [ for c in GetSingleCharAlphabet ctx do yield EncodeChar c ctx
                       for uc in 0 .. NumUnicodeCategories-1 do yield EncodeUnicodeCategoryIndex uc ]
-    else Set.ofList [ for c in GetSingleCharAlphabet() do yield EncodeChar c ]
+    else GetSingleCharAlphabet ctx |> Seq.map (fun c -> EncodeChar c ctx) |> set
+
 
-         
 //let DecodeAlphabet (x:Alphabet) = System.Convert.ToChar(x)
 
 (*
-for i in 0 .. 65535 do 
+for i in 0 .. 65535 do
     let c = char i
-    if System.Char.GetUnicodeCategory c = System.Globalization.UnicodeCategory.PrivateUse then 
+    if System.Char.GetUnicodeCategory c = System.Globalization.UnicodeCategory.PrivateUse then
         printfn "i = %x" i
 *)
 
-type Spec = 
-    { TopCode: Code;
-      Macros: (Ident * Regexp) list;
-      Rules: (Ident * Ident list * Clause list) list;
-      BottomCode: Code }
-and Clause = Regexp * Code
-and Regexp = 
-  | Alt of Regexp list
+type Input =
+  | Alphabet of Parser<Alphabet>
+  | UnicodeCategory of string
+  | Any
+  | NotCharSet of Parser<Set<Alphabet>>
+type Regexp =
+  | Alt of Parser<Regexp list>
   | Seq of Regexp list
   | Inp of Input
   | Star of Regexp
   | Macro of Ident
-and Input =
-  | Alphabet of Alphabet
-  | UnicodeCategory of string 
-  | Any 
-  | NotCharSet of Set<Alphabet>
-
-type NodeId = int   
-
-type NfaNode = 
-    { Id: NodeId;
-      Name: string;
-      Transitions: Dictionary<Alphabet, NfaNode list>;
+type Clause = Regexp * Code
+
+type Rule = Ident * Ident list * Clause list
+type Macro = Ident * Regexp
+
+type Spec =
+    { TopCode: Code
+      Macros: Macro list
+      Rules: Rule list
+      BottomCode: Code }
+
+type NodeId = int
+
+type NfaNode =
+    { Id: NodeId
+      Name: string
+      Transitions: Dictionary<Alphabet, NfaNode list>
       Accepted: (int * int) list }
 
-type DfaNode = 
-    { Id: int;
-      Name: string;
-      mutable Transitions: (Alphabet * DfaNode) list;
+type DfaNode =
+    { Id: int
+      Name: string
+      mutable Transitions: (Alphabet * DfaNode) list
       Accepted: (int * int) list }
 
 type MultiMap<'a,'b> = Dictionary<'a,'b list>
@@ -163,246 +185,254 @@ let LookupMultiMap (trDict:MultiMap<_,_>) a  =
 
 let AddToMultiMap (trDict:MultiMap<_,_>) a b =
     let prev = LookupMultiMap trDict a
-    trDict.[a] <- b :: prev
+    trDict.[a] <- b::prev
 
-type NfaNodeMap() = 
-    let map = new Dictionary<int,NfaNode>(100)
-    member x.Item with get(nid) = map.[nid]
+type NfaNodeMap() =
+    let map = Dictionary<int,NfaNode>(100)
+    member x.Item with get nid = map.[nid]
     member x.Count = map.Count
 
-    member x.NewNfaNode(trs,ac) = 
+    member x.NewNfaNode(trs,ac) =
         let nodeId = map.Count+1 // ID zero is reserved
-        let trDict = new Dictionary<_,_>(List.length trs)
-        for (a,b) in trs do
+        let trDict = Dictionary<_,_>(List.length trs)
+        for a,b in trs do
            AddToMultiMap trDict a b
-           
+
         let node : NfaNode = {Id=nodeId; Name=string nodeId; Transitions=trDict; Accepted=ac}
-        map.[nodeId] <-node;
+        map.[nodeId] <-node
         node
 
-let LexerStateToNfa (macros: Map<string,_>) (clauses: Clause list) = 
+let LexerStateToNfa ctx (macros: Map<string,_>) (clauses: Clause list) =
+
+    /// Table allocating node ids
+    let nfaNodeMap = NfaNodeMap()
 
-    /// Table allocating node ids 
-    let nfaNodeMap = new NfaNodeMap()
-    
     /// Compile a regular expression into the NFA
-    let rec CompileRegexp re dest = 
-        match re with 
-        | Alt res -> 
-            let trs = res |> List.map (fun re -> (Epsilon,CompileRegexp re dest)) 
+    let rec CompileRegexp re dest =
+        match re with
+        | Alt res ->
+            let trs = res ctx |> List.map (fun re -> (Epsilon,CompileRegexp re dest))
             nfaNodeMap.NewNfaNode(trs,[])
-        | Seq res -> 
-            List.foldBack (CompileRegexp) res dest 
-        | Inp (Alphabet c) -> 
-            nfaNodeMap.NewNfaNode([(c, dest)],[])
-            
-        | Star re -> 
+        | Seq res ->
+            List.foldBack CompileRegexp res dest
+        | Inp (Alphabet c) ->
+            let c = c ctx
+            match c with
+            | c when not ctx.caseInsensitive || c = Eof ->
+                nfaNodeMap.NewNfaNode([(c, dest)],[])
+            | UnicodeCategoryAP uc ->
+                let allCasedCategories = [UnicodeCategory.UppercaseLetter; UnicodeCategory.LowercaseLetter; UnicodeCategory.TitlecaseLetter]
+                let isCasedLetterCategory = allCasedCategories |> Seq.contains uc
+                if isCasedLetterCategory then
+                    let trs = allCasedCategories |> List.map (fun x -> (EncodeUnicodeCategoryIndex (int32 x) ,dest))
+                    nfaNodeMap.NewNfaNode(trs,[])
+                else
+                    nfaNodeMap.NewNfaNode([(c, dest)],[])
+            | c ->
+                let decodedChar = DecodeChar c ctx
+                let trs =
+                    [
+                        System.Char.ToLowerInvariant decodedChar
+                        System.Char.ToUpperInvariant decodedChar
+                    ]
+                    |> List.distinct
+                    |> List.choose (fun letter -> TryEncodeChar letter ctx)
+                    |> List.map (fun encodedLetter -> (encodedLetter, dest))
+                nfaNodeMap.NewNfaNode(trs,[])
+        | Star re ->
             let nfaNode = nfaNodeMap.NewNfaNode([(Epsilon, dest)],[])
             let sre = CompileRegexp re nfaNode
             AddToMultiMap nfaNode.Transitions Epsilon sre
             nfaNodeMap.NewNfaNode([(Epsilon,sre); (Epsilon,dest)],[])
-        | Macro m -> 
-            if not (macros.ContainsKey(m)) then failwith ("The macro "+m+" is not defined");
-            CompileRegexp (macros.[m]) dest 
+        | Macro m ->
+            if not <| macros.ContainsKey(m) then failwithf "The macro %s is not defined" m
+            CompileRegexp macros.[m] dest
 
         // These cases unwind the difficult cases in the syntax that rely on knowing the
         // entire alphabet.
         //
         // Note we've delayed the expension of these until we've worked out all the 'special' Unicode characters
         // mentioned in the entire lexer spec, i.e. we wait until GetAlphabet returns a reliable and stable answer.
-        | Inp (UnicodeCategory uc) -> 
-            let re = Alt([ yield Inp(Alphabet(EncodeUnicodeCategory uc))
-                           // Also include any specific characters in this category
-                           for c in GetSingleCharAlphabet() do 
-                               if System.Char.GetUnicodeCategory(c) = unicodeCategories.[uc] then 
-                                    yield Inp(Alphabet(EncodeChar(c))) ])
+        | Inp (UnicodeCategory uc) ->
+            let re = Alt(fun ctx -> 
+                [ yield Inp(Alphabet(EncodeUnicodeCategory uc))
+                  // Also include any specific characters in this category
+                  for c in GetSingleCharAlphabet ctx do
+                       if System.Char.GetUnicodeCategory(c) = unicodeCategories.[uc] then
+                            yield Inp(Alphabet(EncodeChar c)) ])
             CompileRegexp re dest
 
-        | Inp Any -> 
-            let re = Alt([ for n in GetAlphabet() do yield Inp(Alphabet(n)) ])
+        | Inp Any ->
+            let re = Alt(fun ctx ->
+                [ for n in GetAlphabet ctx do yield Inp(Alphabet(fun _ -> n)) ]
+            )
             CompileRegexp re dest
 
-        | Inp (NotCharSet chars) -> 
-            let re = Alt [ // Include any characters from those in the alphabet besides those that are not immediately excluded
-                           for c in GetSingleCharAlphabet() do 
-                               let ec = EncodeChar c
-                               if not (chars.Contains(ec)) then 
-                                   yield Inp(Alphabet(ec))
-
-                           // Include all unicode categories 
-                           // That is, negations _only_ exclude precisely the given set of characters. You can't
-                           // exclude whole classes of characters as yet
-                           if !unicode then 
-                               let ucs = chars |> Set.map(DecodeChar >> System.Char.GetUnicodeCategory)  
-                               for KeyValue(nm,uc) in unicodeCategories do
-                                   //if ucs.Contains(uc) then 
-                                   //    do printfn "warning: the unicode category '\\%s' ('%s') is automatically excluded by this character set negation. Consider adding this to the negation." nm  (uc.ToString())
-                                   //    yield! []
-                                   //else
-                                       yield Inp(Alphabet(EncodeUnicodeCategory nm)) 
-                         ]
+        | Inp (NotCharSet chars) ->
+            let chars = chars ctx
+            let re = Alt(fun ctx -> 
+                [ // Include any characters from those in the alphabet besides those that are not immediately excluded
+                   for c in GetSingleCharAlphabet ctx do
+                       let ec = EncodeChar c ctx
+                       if not (chars.Contains(ec)) then
+                           yield Inp(Alphabet(fun _ -> ec))
+
+                   // Include all unicode categories
+                   // That is, negations _only_ exclude precisely the given set of characters. You can't
+                   // exclude whole classes of characters as yet
+                   if ctx.unicode then
+                       let _ = chars |> Set.map(fun c -> DecodeChar c ctx |> System.Char.GetUnicodeCategory)
+                       for KeyValue(nm,_) in unicodeCategories do
+                           //if ucs.Contains(uc) then
+                           //    printfn "warning: the unicode category '\\%s' ('%O') is automatically excluded by this character set negation. Consider adding this to the negation." nm uc
+                           //else
+                               yield Inp(Alphabet(EncodeUnicodeCategory nm))
+                 ]
+             )
             CompileRegexp re dest
 
-    let actions = new System.Collections.Generic.List<_>()
-    
+    let actions = List()
+
     /// Compile an acceptance of a regular expression into the NFA
-    let sTrans macros nodeId (regexp,code) = 
+    let sTrans _ nodeId (regexp,code) =
         let actionId = actions.Count
         actions.Add(code)
         let sAccept = nfaNodeMap.NewNfaNode([],[(nodeId,actionId)])
-        CompileRegexp regexp sAccept 
+        CompileRegexp regexp sAccept
 
-    let trs = clauses |> List.mapi (fun n x -> (Epsilon,sTrans macros n x)) 
+    let trs = clauses |> List.mapi (fun n x -> (Epsilon,sTrans macros n x))
     let nfaStartNode = nfaNodeMap.NewNfaNode(trs,[])
     nfaStartNode,(actions |> Seq.readonly), nfaNodeMap
 
 // TODO: consider a better representation here.
-type internal NfaNodeIdSetBuilder = HashSet<NodeId>
+type NfaNodeIdSetBuilder = HashSet<NodeId>
 
-type internal NfaNodeIdSet(nodes: NfaNodeIdSetBuilder) = 
+type NfaNodeIdSet(nodes: NfaNodeIdSetBuilder) =
     // BEWARE: the next line is performance critical
-    let s = nodes |> Seq.toArray |> (fun arr -> Array.sortInPlaceWith compare arr; arr) // 19
+    let s = nodes |> Seq.toArray
+    do Array.sortInPlaceWith compare s // 19
 
-    // These are all surprisingly slower:
-    //let s = nodes |> Seq.toArray |> Array.sort 
+    // These are all surprisingly slower (because they create two arrays):
+    //let s = nodes |> Seq.toArray |> Array.sort
     //let s = nodes |> Seq.toArray |> Array.sortWith compare // 76
     //let s = nodes |> Seq.toArray |> (fun arr -> Array.sortInPlace arr; arr) // 76
 
     member x.Representation = s
-    member x.Elements = s 
+    member x.Elements = s
     member x.Fold f z = Array.fold f z s
     interface System.IComparable with 
-        member x.CompareTo(y:obj) = 
-            let y = (y :?> NfaNodeIdSet)
-            let xr = x.Representation
-            let yr = y.Representation
-            let c = compare xr.Length yr.Length
-            if c <> 0 then c else 
-            let n = yr.Length
-            let rec go i = 
-                if i >= n then 0 else
-                let c = compare xr.[i] yr.[i]
-                if c <> 0 then c else
-                go (i+1) 
-            go 0
+        member x.CompareTo(y:obj) =
+            Array.compareWith compare x.Representation (y :?> NfaNodeIdSet).Representation
 
     override x.Equals(y:obj) = 
         match y with 
-        | :? NfaNodeIdSet as y -> 
+        | :? NfaNodeIdSet as y ->
             let xr = x.Representation
             let yr = y.Representation
             let n = yr.Length
-            xr.Length = n && 
-            (let rec go i = (i < n) && xr.[i] = yr.[i] && go (i+1) 
-             go 0)
+            let rec go i = (i >= n) || (xr.[i] = yr.[i] && go (i+1))
+            xr.Length = n && go 0
         | _ -> false
 
     override x.GetHashCode() = hash s
 
     member x.IsEmpty = (s.Length = 0)
-    member x.Iterate f = s |> Array.iter f
+    member x.Iterate f = Array.iter f s
 
 type NodeSetSet = Set<NfaNodeIdSet>
 
-let newDfaNodeId = 
-    let i = ref 0 
+let newDfaNodeId =
+    let i = ref 0
     fun () -> let res = !i in incr i; res
-   
-let NfaToDfa (nfaNodeMap:NfaNodeMap) nfaStartNode = 
-    let numNfaNodes = nfaNodeMap.Count
-    let rec EClosure1 (acc:NfaNodeIdSetBuilder) (n:NfaNode) = 
-        if not (acc.Contains n.Id) then 
-            acc.Add n.Id |> ignore;
+
+let NfaToDfa (nfaNodeMap:NfaNodeMap) nfaStartNode =
+    let rec EClosure1 (acc:NfaNodeIdSetBuilder) (n:NfaNode) =
+        if not (acc.Contains(n.Id)) then
+            acc.Add(n.Id) |> ignore
             if n.Transitions.ContainsKey(Epsilon) then
-                match n.Transitions.[Epsilon] with 
+                match n.Transitions.[Epsilon] with
                 | [] -> () // this Clause is an optimization - the list is normally empty
-                | tr -> 
+                | tr ->
                     //printfn "n.Id = %A, #Epsilon = %d" n.Id tr.Length
-                    tr |> List.iter (EClosure1 acc) 
+                    tr |> List.iter (EClosure1 acc)
 
-    let EClosure (moves:list<NodeId>) = 
-        let acc = new NfaNodeIdSetBuilder(HashIdentity.Structural)
+    let EClosure (moves:list<NodeId>) =
+        let acc = NfaNodeIdSetBuilder(HashIdentity.Structural)
         for i in moves do
-            EClosure1 acc nfaNodeMap.[i];
-        new NfaNodeIdSet(acc)
+            EClosure1 acc nfaNodeMap.[i]
+        NfaNodeIdSet(acc)
 
     // Compute all the immediate one-step moves for a set of NFA states, as a dictionary
     // mapping inputs to destination lists
-    let ComputeMoves (nset:NfaNodeIdSet) = 
-        let moves = new MultiMap<_,_>()
-        nset.Iterate(fun nodeId -> 
-            for (KeyValue(inp,dests)) in nfaNodeMap.[nodeId].Transitions do
-                if inp <> Epsilon then 
-                    match dests with 
+    let ComputeMoves (nset:NfaNodeIdSet) =
+        let moves = MultiMap<_,_>()
+        nset.Iterate(fun nodeId ->
+            for KeyValue(inp,dests) in nfaNodeMap.[nodeId].Transitions do
+                if inp <> Epsilon then
+                    match dests with
                     | [] -> ()  // this Clause is an optimization - the list is normally empty
                     | tr -> tr |> List.iter(fun dest -> AddToMultiMap moves inp dest.Id))
         moves
 
-    let acc = new NfaNodeIdSetBuilder(HashIdentity.Structural)
-    EClosure1 acc nfaStartNode;
-    let nfaSet0 = new NfaNodeIdSet(acc)
+    let acc = NfaNodeIdSetBuilder(HashIdentity.Structural)
+    EClosure1 acc nfaStartNode
+    let nfaSet0 = NfaNodeIdSet(acc)
 
-    let dfaNodes = ref (Map.empty<NfaNodeIdSet,DfaNode>)
+    let dfaNodes = Dictionary<NfaNodeIdSet,DfaNode>()
 
-    let GetDfaNode nfaSet = 
-        if (!dfaNodes).ContainsKey(nfaSet) then 
-            (!dfaNodes).[nfaSet]
-        else 
+    let GetDfaNode nfaSet =
+        if dfaNodes.ContainsKey(nfaSet) then
+            dfaNodes.[nfaSet]
+        else
             let dfaNode =
-                { Id= newDfaNodeId(); 
-                  Name = nfaSet.Fold (fun s nid -> nfaNodeMap.[nid].Name+"-"+s) ""; 
-                  Transitions=[];
-                  Accepted= nfaSet.Elements 
+                { Id = newDfaNodeId()
+                  Name = nfaSet.Fold (fun s nid -> nfaNodeMap.[nid].Name+"-"+s) ""
+                  Transitions = []
+                  Accepted= nfaSet.Elements
                             |> Seq.map (fun nid -> nfaNodeMap.[nid].Accepted)
                             |> List.concat }
-            //Printf.printfn "id = %d" dfaNode.Id;
+            //printfn "id = %d" dfaNode.Id
 
-            dfaNodes := (!dfaNodes).Add(nfaSet,dfaNode); 
+            dfaNodes.Add(nfaSet,dfaNode)
             dfaNode
-            
-    let workList = ref [nfaSet0]
-    let doneSet = ref Set.empty
-
-    //let count = ref 0 
-    let rec Loop () = 
-        match !workList with 
-        | [] -> ()
-        | nfaSet :: t -> 
-            workList := t;
-            if (!doneSet).Contains(nfaSet) then 
-                Loop () 
-            else
-                let moves = ComputeMoves nfaSet
-                for (KeyValue(inp,movesForInput)) in moves do
-                    assert (inp <> Epsilon);
-                    let moveSet = EClosure movesForInput;
-                    if not moveSet.IsEmpty then 
-                        //incr count
-                        let dfaNode = GetDfaNode nfaSet
-                        dfaNode.Transitions <- (inp, GetDfaNode moveSet) :: dfaNode.Transitions;
-                        (* Printf.printf "%d (%s) : %s --> %d (%s)\n" dfaNode.Id dfaNode.Name (match inp with EncodeChar c -> String.make 1 c | LEof -> "eof") moveSetDfaNode.Id moveSetDfaNode.Name;*)
-                        workList := moveSet :: !workList;
-
-                doneSet := (!doneSet).Add(nfaSet);
-
-
-                Loop()
-    Loop();
-    //Printf.printfn "count = %d" !count;
+
+    let workList = Stack()
+    workList.Push nfaSet0
+    let doneSet = HashSet()
+
+    //let count = ref 0
+    while workList.Count <> 0 do
+        let nfaSet = workList.Pop()
+        if not <| doneSet.Contains(nfaSet) then
+            let moves = ComputeMoves nfaSet
+            for KeyValue(inp,movesForInput) in moves do
+                assert (inp <> Epsilon)
+                let moveSet = EClosure movesForInput
+                if not moveSet.IsEmpty then
+                    //incr count
+                    let dfaNode = GetDfaNode nfaSet
+                    dfaNode.Transitions <- (inp, GetDfaNode moveSet) :: dfaNode.Transitions
+                    // printf "%d (%s) : %s --> %d (%s)\n" dfaNode.Id dfaNode.Name (match inp with EncodeChar c -> String.make 1 c | LEof -> "eof") moveSetDfaNode.Id moveSetDfaNode.Name
+                    workList.Push(moveSet)
+
+            doneSet.Add(nfaSet) |> ignore
+
+    //printfn "count = %d" !count
     let ruleStartNode = GetDfaNode nfaSet0
-    let ruleNodes = 
-        (!dfaNodes) 
-        |> Seq.map (fun kvp -> kvp.Value) 
+    let ruleNodes =
+        dfaNodes
+        |> Seq.map (fun kvp -> kvp.Value)
         |> Seq.toList
         |> List.sortBy (fun s -> s.Id)
     ruleStartNode,ruleNodes
 
-let Compile spec = 
+let Compile ctx spec =
+    let macros = Map.ofList spec.Macros
     List.foldBack
-        (fun (name,args,clauses) (perRuleData,dfaNodes) -> 
-            let nfa, actions, nfaNodeMap = LexerStateToNfa (Map.ofList spec.Macros) clauses
+        (fun (_,_,clauses) (perRuleData,dfaNodes) ->
+            let nfa, actions, nfaNodeMap = LexerStateToNfa ctx macros clauses
             let ruleStartNode, ruleNodes = NfaToDfa nfaNodeMap nfa
-            //Printf.printfn "name = %s, ruleStartNode = %O" name ruleStartNode.Id;
+            //printfn "name = %s, ruleStartNode = %O" name ruleStartNode.Id
             (ruleStartNode,actions) :: perRuleData, ruleNodes @ dfaNodes)
         spec.Rules
         ([],[])
diff --git a/buildtools/fslex/fslexdriver.fs b/buildtools/fslex/fslexdriver.fs
new file mode 100644
index 00000000000..b0b24e78524
--- /dev/null
+++ b/buildtools/fslex/fslexdriver.fs
@@ -0,0 +1,205 @@
+module FsLexYacc.FsLex.Driver 
+
+open FsLexYacc.FsLex.AST
+open System
+open System.IO
+open FSharp.Text.Lexing
+open System.Collections.Generic
+
+type Domain = Unicode | ASCII
+
+/// Wraps the inputs to the code generator
+type GeneratorState =
+    { inputFileName: string
+      outputFileName: string
+      inputCodePage: System.Text.Encoding
+      generatedModuleName: string option
+      disableLightMode: bool option
+      generateInternalModule: bool
+      lexerLibraryName: string
+      domain : Domain }
+
+type PerRuleData = list<DfaNode * seq<Code>>
+type DfaNodes = list<DfaNode>
+
+type Writer(fileName) =
+    let os = File.CreateText fileName
+    let mutable lineCount = 0
+    let incr () =
+        lineCount <- lineCount + 1
+
+    member x.writeLine fmt =
+        Printf.kfprintf (fun () -> incr(); os.WriteLine()) os fmt
+
+    member x.write fmt =
+        Printf.fprintf os fmt
+
+    member x.writeCode (code, pos: Position) =
+        if pos <> Position.Empty  // If bottom code is unspecified, then position is empty.
+        then
+            x.writeLine "# %d \"%s\"" pos.Line pos.FileName
+            x.writeLine "%s" code
+            let numLines = code.Replace("\r","").Split([| '\n' |]).Length
+            lineCount  <- lineCount + numLines
+            x.writeLine "# %d \"%s\"" lineCount fileName
+
+    member x.LineCount = lineCount
+
+    member x.WriteUint16 (n: int) =
+        os.Write n;
+        os.Write "us;"
+
+    interface IDisposable with
+        member x.Dispose() = os.Dispose()
+
+let sentinel = 255 * 256 + 255
+
+let readSpecFromFile fileName codePage =
+  let stream,reader,lexbuf = UnicodeFileAsLexbuf(fileName, codePage)
+  use stream = stream
+  use reader = reader
+  try
+      let spec = Parser.spec Lexer.token lexbuf
+      Ok spec
+  with e ->
+      (e, lexbuf.StartPos.Line, lexbuf.StartPos.Column)
+      |> Error
+
+let writeLightMode lightModeDisabled (fileName: string) (writer: Writer) =
+    if lightModeDisabled = Some false || (lightModeDisabled = None && (Path.HasExtension(fileName) && Path.GetExtension(fileName) = ".ml"))
+    then
+        writer.write "#light \"off\""
+
+let writeModuleExpression genModuleName isInternal (writer: Writer) =
+    match genModuleName with
+    | None -> ()
+    | Some s ->
+        let internal_tag = if isInternal then "internal " else ""
+        writer.writeLine "module %s%s" internal_tag s
+
+let writeTopCode code (writer: Writer) = writer.writeCode code
+
+let writeUnicodeTranslationArray dfaNodes domain (writer: Writer) =
+    let parseContext = 
+        { unicode = match domain with | Unicode -> true | ASCII -> false
+          caseInsensitive = false }
+    writer.writeLine "let trans : uint16[] array = "
+    writer.writeLine "    [| "
+    match domain with
+    | Unicode ->
+        let specificUnicodeChars = GetSpecificUnicodeChars()
+        // This emits a (numLowUnicodeChars+NumUnicodeCategories+(2*#specificUnicodeChars)+1) * #states array of encoded UInt16 values
+
+        // Each row for the Unicode table has format
+        //      128 entries for ASCII characters
+        //      A variable number of 2*UInt16 entries for SpecificUnicodeChars
+        //      30 entries, one for each UnicodeCategory
+        //      1 entry for EOF
+        //
+        // Each entry is an encoded UInt16 value indicating the next state to transition to for this input.
+        //
+        // For the SpecificUnicodeChars the entries are char/next-state pairs.
+        for state in dfaNodes do
+            writer.writeLine "    (* State %d *)" state.Id
+            writer.write  "     [| "
+            let trans =
+                let dict = Dictionary()
+                state.Transitions |> List.iter dict.Add
+                dict
+            let emit n =
+                if trans.ContainsKey(n) then
+                  writer.WriteUint16 trans.[n].Id
+                else
+                  writer.WriteUint16 sentinel
+            for i = 0 to numLowUnicodeChars-1 do
+                let c = char i
+                emit (EncodeChar c parseContext)
+            for c in specificUnicodeChars do
+                writer.WriteUint16 (int c)
+                emit (EncodeChar c parseContext)
+            for i = 0 to NumUnicodeCategories-1 do
+                emit (EncodeUnicodeCategoryIndex i)
+            emit Eof
+            writer.writeLine  "|];"
+        done
+
+    | ASCII ->
+        // Each row for the ASCII table has format
+        //      256 entries for ASCII characters
+        //      1 entry for EOF
+        //
+        // Each entry is an encoded UInt16 value indicating the next state to transition to for this input.
+
+        // This emits a (256+1) * #states array of encoded UInt16 values
+        for state in dfaNodes do
+            writer.writeLine "   (* State %d *)" state.Id
+            writer.write " [|"
+            let trans =
+                let dict = Dictionary()
+                state.Transitions |> List.iter dict.Add
+                dict
+            let emit n =
+                if trans.ContainsKey(n) then
+                  writer.WriteUint16 trans.[n].Id
+                else
+                  writer.WriteUint16 sentinel
+            for i = 0 to 255 do
+                let c = char i
+                emit (EncodeChar c parseContext)
+            emit Eof
+            writer.writeLine "|];"
+        done
+
+    writer.writeLine "    |] "
+
+let writeUnicodeActionsArray dfaNodes (writer: Writer) =
+    writer.write "let actions : uint16[] = [|"
+    for state in dfaNodes do
+        if state.Accepted.Length > 0 then
+          writer.WriteUint16 (snd state.Accepted.Head)
+        else
+          writer.WriteUint16 sentinel
+    done
+    writer.writeLine  "|]"
+
+let writeUnicodeTables lexerLibraryName domain dfaNodes (writer: Writer) =
+    writeUnicodeTranslationArray dfaNodes domain writer
+    writeUnicodeActionsArray dfaNodes writer
+    writer.writeLine  "let _fslex_tables = %s.%sTables.Create(trans,actions)" lexerLibraryName (match domain with | Unicode -> "Unicode" | ASCII -> "Ascii")
+
+let writeRules (rules: Rule list) (perRuleData: PerRuleData) outputFileName (writer: Writer) =
+    writer.writeLine  "let rec _fslex_dummy () = _fslex_dummy() "
+
+    // These actions push the additional start state and come first, because they are then typically inlined into later
+    // rules. This means more tailcalls are taken as direct branches, increasing efficiency and
+    // improving stack usage on platforms that do not take tailcalls.
+    for (startNode, actions),(ident,args,_) in List.zip perRuleData rules do
+        writer.writeLine "// Rule %s" ident
+        writer.writeLine "and %s %s lexbuf =" ident (String.Join(" ", Array.ofList args))
+        writer.writeLine "  match _fslex_tables.Interpret(%d,lexbuf) with" startNode.Id
+        actions |> Seq.iteri (fun i (code:string, pos) ->
+            writer.writeLine "  | %d -> ( " i
+            writer.writeLine "# %d \"%s\"" pos.Line pos.FileName
+            let lines = code.Split([| '\r'; '\n' |], StringSplitOptions.RemoveEmptyEntries)
+            for line in lines do
+                writer.writeLine "               %s" line
+            writer.writeLine "# %d \"%s\"" writer.LineCount outputFileName
+            writer.writeLine "          )")
+        writer.writeLine "  | _ -> failwith \"%s\"" ident
+
+    writer.writeLine ""
+
+let writeBottomCode code (writer: Writer) = writer.writeCode code
+
+let writeFooter outputFileName (writer: Writer) = writer.writeLine "# 3000000 \"%s\"" outputFileName
+
+let writeSpecToFile (state: GeneratorState) (spec: Spec) (perRuleData: PerRuleData) (dfaNodes: DfaNodes) =
+    use writer = new Writer(state.outputFileName)
+    writeLightMode state.disableLightMode state.outputFileName writer
+    writeModuleExpression state.generatedModuleName state.generateInternalModule writer
+    writeTopCode spec.TopCode writer
+    writeUnicodeTables state.lexerLibraryName state.domain dfaNodes writer
+    writeRules spec.Rules perRuleData state.outputFileName writer
+    writeBottomCode spec.BottomCode writer
+    writeFooter state.outputFileName writer
+    ()
\ No newline at end of file
diff --git a/buildtools/fslex/fslexlex.fs b/buildtools/fslex/fslexlex.fs
index b29bd10f84c..6738cdb1224 100644
--- a/buildtools/fslex/fslexlex.fs
+++ b/buildtools/fslex/fslexlex.fs
@@ -2,12 +2,12 @@
  
 (* (c) Microsoft Corporation 2005-2008.  *)
   
-module internal FsLexYacc.FsLex.Lexer
+module FsLexYacc.FsLex.Lexer
   
 open FsLexYacc.FsLex.AST
 open FsLexYacc.FsLex.Parser
-open Internal.Utilities
-open Internal.Utilities.Text.Lexing
+open FSharp.Text
+open FSharp.Text.Lexing
 open System.Text
 
 let escape c = 
@@ -340,69 +340,59 @@ let trans : uint16[] array =
      [| 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 92us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 65535us; 65535us; 65535us; 65535us; 92us; 65535us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 92us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; |];
     |] 
 let actions : uint16[] = [|65535us; 7us; 1us; 7us; 3us; 7us; 7us; 5us; 6us; 7us; 6us; 4us; 3us; 2us; 65535us; 65535us; 0us; 65535us; 5us; 1us; 2us; 5us; 3us; 4us; 5us; 3us; 2us; 0us; 65535us; 0us; 1us; 8us; 3us; 4us; 8us; 5us; 8us; 7us; 8us; 6us; 6us; 5us; 4us; 2us; 65535us; 7us; 3us; 4us; 7us; 5us; 6us; 7us; 5us; 4us; 0us; 65535us; 1us; 65535us; 65535us; 2us; 65535us; 15us; 15us; 15us; 15us; 15us; 31us; 11us; 12us; 13us; 14us; 31us; 15us; 16us; 17us; 18us; 19us; 20us; 21us; 22us; 23us; 24us; 25us; 26us; 27us; 28us; 31us; 31us; 32us; 30us; 30us; 29us; 15us; 14us; 13us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 10us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 9us; 65535us; 65535us; 65535us; 65535us; 8us; 65535us; 65535us; 7us; 65535us; 65535us; 6us; 5us; 15us; 4us; 15us; 3us; 15us; 2us; 15us; 15us; 15us; 1us; 15us; 15us; 0us; |]
-let _fslex_tables = Internal.Utilities.Text.Lexing.UnicodeTables.Create(trans,actions)
+let _fslex_tables = FSharp.Text.Lexing.UnicodeTables.Create(trans,actions)
 let rec _fslex_dummy () = _fslex_dummy() 
-(* Rule token *)
-and token  (lexbuf : Internal.Utilities.Text.Lexing.LexBuffer<_>) = _fslex_token  60 lexbuf
-(* Rule string *)
-and string p buff (lexbuf : Internal.Utilities.Text.Lexing.LexBuffer<_>) = _fslex_string p buff 44 lexbuf
-(* Rule code *)
-and code p buff (lexbuf : Internal.Utilities.Text.Lexing.LexBuffer<_>) = _fslex_code p buff 28 lexbuf
-(* Rule codestring *)
-and codestring buff (lexbuf : Internal.Utilities.Text.Lexing.LexBuffer<_>) = _fslex_codestring buff 17 lexbuf
-(* Rule comment *)
-and comment p (lexbuf : Internal.Utilities.Text.Lexing.LexBuffer<_>) = _fslex_comment p 0 lexbuf
-(* Rule token *)
-and _fslex_token  _fslex_state lexbuf =
-  match _fslex_tables.Interpret(_fslex_state,lexbuf) with
+// Rule token
+and token  lexbuf =
+  match _fslex_tables.Interpret(60,lexbuf) with
   | 0 -> ( 
 # 76 "fslexlex.fsl"
                           RULE 
-# 361 "fslexlex.fs"
+# 351 "fslexlex.fs"
           )
   | 1 -> ( 
 # 77 "fslexlex.fsl"
                            PARSE 
-# 366 "fslexlex.fs"
+# 356 "fslexlex.fs"
           )
   | 2 -> ( 
 # 78 "fslexlex.fsl"
                          EOF 
-# 371 "fslexlex.fs"
+# 361 "fslexlex.fs"
           )
   | 3 -> ( 
 # 79 "fslexlex.fsl"
                          LET 
-# 376 "fslexlex.fs"
+# 366 "fslexlex.fs"
           )
   | 4 -> ( 
 # 80 "fslexlex.fsl"
                          AND 
-# 381 "fslexlex.fs"
+# 371 "fslexlex.fs"
           )
   | 5 -> ( 
 # 82 "fslexlex.fsl"
                     let s = lexeme lexbuf in 
                     CHAR (if s.[1] = '\\' then escape s.[2] else s.[1])  
-# 387 "fslexlex.fs"
+# 377 "fslexlex.fs"
           )
   | 6 -> ( 
 # 86 "fslexlex.fsl"
                     let s = lexeme lexbuf in 
                     CHAR (trigraph s.[2] s.[3] s.[4]) 
-# 393 "fslexlex.fs"
+# 383 "fslexlex.fs"
           )
   | 7 -> ( 
 # 90 "fslexlex.fsl"
                     let s = lexeme lexbuf in 
                     CHAR (hexgraph s.[3] s.[4]) 
-# 399 "fslexlex.fs"
+# 389 "fslexlex.fs"
           )
   | 8 -> ( 
 # 94 "fslexlex.fsl"
                     let s = lexeme lexbuf in 
                     CHAR (unicodegraph_short s.[3..6]) 
-# 405 "fslexlex.fs"
+# 395 "fslexlex.fs"
           )
   | 9 -> ( 
 # 98 "fslexlex.fsl"
@@ -410,13 +400,13 @@ and _fslex_token  _fslex_state lexbuf =
                     match (unicodegraph_long s.[3..10]) with 
                     | None, c -> CHAR(c)
                     | Some _ , _ -> failwith "Unicode characters needing surrogate pairs are not yet supported by this tool" 
-# 413 "fslexlex.fs"
+# 403 "fslexlex.fs"
           )
   | 10 -> ( 
 # 104 "fslexlex.fsl"
                     let s = (lexeme lexbuf).[2..3] in 
                     UNICODE_CATEGORY (s) 
-# 419 "fslexlex.fs"
+# 409 "fslexlex.fs"
           )
   | 11 -> ( 
 # 107 "fslexlex.fsl"
@@ -425,172 +415,172 @@ and _fslex_token  _fslex_state lexbuf =
                         // adjust the first line to get even indentation for all lines w.r.t. the left hand margin
                         buff.Append (String.replicate (lexbuf.StartPos.Column+1) " ") |> ignore;
                         code p buff lexbuf 
-# 428 "fslexlex.fs"
+# 418 "fslexlex.fs"
           )
   | 12 -> ( 
 # 113 "fslexlex.fsl"
                         string  lexbuf.StartPos (new StringBuilder 100) lexbuf 
-# 433 "fslexlex.fs"
+# 423 "fslexlex.fs"
           )
   | 13 -> ( 
 # 115 "fslexlex.fsl"
                                  token lexbuf 
-# 438 "fslexlex.fs"
+# 428 "fslexlex.fs"
           )
   | 14 -> ( 
 # 116 "fslexlex.fsl"
                             newline lexbuf; token lexbuf 
-# 443 "fslexlex.fs"
+# 433 "fslexlex.fs"
           )
   | 15 -> ( 
 # 117 "fslexlex.fsl"
                                                  IDENT (lexeme lexbuf) 
-# 448 "fslexlex.fs"
+# 438 "fslexlex.fs"
           )
   | 16 -> ( 
 # 118 "fslexlex.fsl"
                         BAR 
-# 453 "fslexlex.fs"
+# 443 "fslexlex.fs"
           )
   | 17 -> ( 
 # 119 "fslexlex.fsl"
                         DOT 
-# 458 "fslexlex.fs"
+# 448 "fslexlex.fs"
           )
   | 18 -> ( 
 # 120 "fslexlex.fsl"
                         PLUS 
-# 463 "fslexlex.fs"
+# 453 "fslexlex.fs"
           )
   | 19 -> ( 
 # 121 "fslexlex.fsl"
                         STAR 
-# 468 "fslexlex.fs"
+# 458 "fslexlex.fs"
           )
   | 20 -> ( 
 # 122 "fslexlex.fsl"
                         QMARK 
-# 473 "fslexlex.fs"
+# 463 "fslexlex.fs"
           )
   | 21 -> ( 
 # 123 "fslexlex.fsl"
                         EQUALS 
-# 478 "fslexlex.fs"
+# 468 "fslexlex.fs"
           )
   | 22 -> ( 
 # 124 "fslexlex.fsl"
                         LBRACK 
-# 483 "fslexlex.fs"
+# 473 "fslexlex.fs"
           )
   | 23 -> ( 
 # 125 "fslexlex.fsl"
                         RBRACK 
-# 488 "fslexlex.fs"
+# 478 "fslexlex.fs"
           )
   | 24 -> ( 
 # 126 "fslexlex.fsl"
                         LPAREN 
-# 493 "fslexlex.fs"
+# 483 "fslexlex.fs"
           )
   | 25 -> ( 
 # 127 "fslexlex.fsl"
                         RPAREN 
-# 498 "fslexlex.fs"
+# 488 "fslexlex.fs"
           )
   | 26 -> ( 
 # 128 "fslexlex.fsl"
                         UNDERSCORE 
-# 503 "fslexlex.fs"
+# 493 "fslexlex.fs"
           )
   | 27 -> ( 
 # 129 "fslexlex.fsl"
                         HAT 
-# 508 "fslexlex.fs"
+# 498 "fslexlex.fs"
           )
   | 28 -> ( 
 # 130 "fslexlex.fsl"
                         DASH 
-# 513 "fslexlex.fs"
+# 503 "fslexlex.fs"
           )
   | 29 -> ( 
 # 131 "fslexlex.fsl"
                          ignore(comment lexbuf.StartPos lexbuf); token lexbuf 
-# 518 "fslexlex.fs"
+# 508 "fslexlex.fs"
           )
   | 30 -> ( 
 # 132 "fslexlex.fsl"
                                       token lexbuf 
-# 523 "fslexlex.fs"
+# 513 "fslexlex.fs"
           )
   | 31 -> ( 
 # 133 "fslexlex.fsl"
                       unexpected_char lexbuf 
-# 528 "fslexlex.fs"
+# 518 "fslexlex.fs"
           )
   | 32 -> ( 
 # 134 "fslexlex.fsl"
                         EOF  
-# 533 "fslexlex.fs"
+# 523 "fslexlex.fs"
           )
   | _ -> failwith "token"
-(* Rule string *)
-and _fslex_string p buff _fslex_state lexbuf =
-  match _fslex_tables.Interpret(_fslex_state,lexbuf) with
+// Rule string
+and string p buff lexbuf =
+  match _fslex_tables.Interpret(44,lexbuf) with
   | 0 -> ( 
 # 136 "fslexlex.fsl"
                                   newline lexbuf; string p buff lexbuf 
-# 542 "fslexlex.fs"
+# 532 "fslexlex.fs"
           )
   | 1 -> ( 
 # 138 "fslexlex.fsl"
                     let _ = buff.Append (escape (lexeme lexbuf).[1]) in
                     string p buff lexbuf 
-# 548 "fslexlex.fs"
+# 538 "fslexlex.fs"
           )
   | 2 -> ( 
 # 141 "fslexlex.fsl"
                     let s = lexeme lexbuf in 
                     let _ = buff.Append (trigraph s.[1] s.[2] s.[3]) in
                     string p buff lexbuf  
-# 555 "fslexlex.fs"
+# 545 "fslexlex.fs"
           )
   | 3 -> ( 
 # 144 "fslexlex.fsl"
                         STRING (buff.ToString()) 
-# 560 "fslexlex.fs"
+# 550 "fslexlex.fs"
           )
   | 4 -> ( 
 # 145 "fslexlex.fsl"
                             newline lexbuf; 
                             let _ = buff.Append System.Environment.NewLine in
                             string p buff lexbuf 
-# 567 "fslexlex.fs"
+# 557 "fslexlex.fs"
           )
   | 5 -> ( 
 # 149 "fslexlex.fsl"
                     let _ = buff.Append (lexeme lexbuf) in 
                     string p buff lexbuf 
-# 573 "fslexlex.fs"
+# 563 "fslexlex.fs"
           )
   | 6 -> ( 
 # 151 "fslexlex.fsl"
                         failwith (Printf.sprintf "end of file in string started at (%d,%d)" p.pos_lnum (p.pos_cnum - p.pos_bol))  
-# 578 "fslexlex.fs"
+# 568 "fslexlex.fs"
           )
   | 7 -> ( 
 # 152 "fslexlex.fsl"
                       let _ = buff.Append (lexeme lexbuf).[0] in
                       string p buff lexbuf 
-# 584 "fslexlex.fs"
+# 574 "fslexlex.fs"
           )
   | _ -> failwith "string"
-(* Rule code *)
-and _fslex_code p buff _fslex_state lexbuf =
-  match _fslex_tables.Interpret(_fslex_state,lexbuf) with
+// Rule code
+and code p buff lexbuf =
+  match _fslex_tables.Interpret(28,lexbuf) with
   | 0 -> ( 
 # 155 "fslexlex.fsl"
                         CODE (buff.ToString(), p) 
-# 593 "fslexlex.fs"
+# 583 "fslexlex.fs"
           )
   | 1 -> ( 
 # 156 "fslexlex.fsl"
@@ -598,137 +588,137 @@ and _fslex_code p buff _fslex_state lexbuf =
                         ignore(code p buff lexbuf); 
                         let _ = buff.Append "}" in
                         code p buff lexbuf 
-# 601 "fslexlex.fs"
+# 591 "fslexlex.fs"
           )
   | 2 -> ( 
 # 161 "fslexlex.fsl"
                     let _ = buff.Append (lexeme lexbuf) in 
                     code p buff lexbuf 
-# 607 "fslexlex.fs"
+# 597 "fslexlex.fs"
           )
   | 3 -> ( 
 # 163 "fslexlex.fsl"
                          let _ = buff.Append (lexeme lexbuf) in 
                          ignore(codestring buff lexbuf); 
                          code p buff lexbuf 
-# 614 "fslexlex.fs"
+# 604 "fslexlex.fs"
           )
   | 4 -> ( 
 # 166 "fslexlex.fsl"
                             newline lexbuf; 
                             let _ = buff.Append System.Environment.NewLine in
                             code p buff lexbuf 
-# 621 "fslexlex.fs"
+# 611 "fslexlex.fs"
           )
   | 5 -> ( 
 # 170 "fslexlex.fsl"
                     let _ = buff.Append (lexeme lexbuf) in 
                     code p buff lexbuf 
-# 627 "fslexlex.fs"
+# 617 "fslexlex.fs"
           )
   | 6 -> ( 
 # 173 "fslexlex.fsl"
                     let _ = buff.Append (lexeme lexbuf) in
                     code p buff lexbuf 
-# 633 "fslexlex.fs"
+# 623 "fslexlex.fs"
           )
   | 7 -> ( 
 # 175 "fslexlex.fsl"
                         EOF 
-# 638 "fslexlex.fs"
+# 628 "fslexlex.fs"
           )
   | 8 -> ( 
 # 176 "fslexlex.fsl"
                       let _ = buff.Append (lexeme lexbuf).[0] in
                       code p buff lexbuf 
-# 644 "fslexlex.fs"
+# 634 "fslexlex.fs"
           )
   | _ -> failwith "code"
-(* Rule codestring *)
-and _fslex_codestring buff _fslex_state lexbuf =
-  match _fslex_tables.Interpret(_fslex_state,lexbuf) with
+// Rule codestring
+and codestring buff lexbuf =
+  match _fslex_tables.Interpret(17,lexbuf) with
   | 0 -> ( 
 # 181 "fslexlex.fsl"
                     let _ = buff.Append (lexeme lexbuf) in 
                     codestring buff lexbuf 
-# 654 "fslexlex.fs"
+# 644 "fslexlex.fs"
           )
   | 1 -> ( 
 # 183 "fslexlex.fsl"
                         let _ = buff.Append (lexeme lexbuf) in 
                         buff.ToString() 
-# 660 "fslexlex.fs"
+# 650 "fslexlex.fs"
           )
   | 2 -> ( 
 # 185 "fslexlex.fsl"
                             newline lexbuf; 
                             let _ = buff.Append System.Environment.NewLine in
                             codestring buff lexbuf 
-# 667 "fslexlex.fs"
+# 657 "fslexlex.fs"
           )
   | 3 -> ( 
 # 189 "fslexlex.fsl"
                     let _ = buff.Append (lexeme lexbuf) in 
                     codestring buff lexbuf 
-# 673 "fslexlex.fs"
+# 663 "fslexlex.fs"
           )
   | 4 -> ( 
 # 191 "fslexlex.fsl"
                         failwith "unterminated string in code" 
-# 678 "fslexlex.fs"
+# 668 "fslexlex.fs"
           )
   | 5 -> ( 
 # 192 "fslexlex.fsl"
                       let _ = buff.Append (lexeme lexbuf).[0] in
                       codestring buff lexbuf 
-# 684 "fslexlex.fs"
+# 674 "fslexlex.fs"
           )
   | _ -> failwith "codestring"
-(* Rule comment *)
-and _fslex_comment p _fslex_state lexbuf =
-  match _fslex_tables.Interpret(_fslex_state,lexbuf) with
+// Rule comment
+and comment p lexbuf =
+  match _fslex_tables.Interpret(0,lexbuf) with
   | 0 -> ( 
 # 196 "fslexlex.fsl"
                           comment p lexbuf 
-# 693 "fslexlex.fs"
+# 683 "fslexlex.fs"
           )
   | 1 -> ( 
 # 197 "fslexlex.fsl"
                         ignore(try string lexbuf.StartPos (new StringBuilder 100) lexbuf 
                                with Failure s -> failwith (s + "\n" + Printf.sprintf "error while processing string nested in comment started at (%d,%d)" p.pos_lnum (p.pos_cnum - p.pos_bol))); 
                         comment p lexbuf 
-# 700 "fslexlex.fs"
+# 690 "fslexlex.fs"
           )
   | 2 -> ( 
 # 200 "fslexlex.fsl"
                          ignore(try comment p lexbuf with Failure s -> failwith (s + "\n" + Printf.sprintf "error while processing nested comment started at (%d,%d)" p.pos_lnum (p.pos_cnum - p.pos_bol))); 
                          comment p lexbuf 
-# 706 "fslexlex.fs"
+# 696 "fslexlex.fs"
           )
   | 3 -> ( 
 # 202 "fslexlex.fsl"
                             newline lexbuf; comment p lexbuf 
-# 711 "fslexlex.fs"
+# 701 "fslexlex.fs"
           )
   | 4 -> ( 
 # 203 "fslexlex.fsl"
                          () 
-# 716 "fslexlex.fs"
+# 706 "fslexlex.fs"
           )
   | 5 -> ( 
 # 204 "fslexlex.fsl"
                         failwith (Printf.sprintf "end of file in comment started at (%d,%d)" p.pos_lnum (p.pos_cnum - p.pos_bol))  
-# 721 "fslexlex.fs"
+# 711 "fslexlex.fs"
           )
   | 6 -> ( 
 # 205 "fslexlex.fsl"
                                                           comment p lexbuf 
-# 726 "fslexlex.fs"
+# 716 "fslexlex.fs"
           )
   | 7 -> ( 
 # 206 "fslexlex.fsl"
                        comment p lexbuf 
-# 731 "fslexlex.fs"
+# 721 "fslexlex.fs"
           )
   | _ -> failwith "comment"
 
diff --git a/buildtools/fslex/fslexpars.fs b/buildtools/fslex/fslexpars.fs
index 87268dcb7fc..55b628b47ee 100644
--- a/buildtools/fslex/fslexpars.fs
+++ b/buildtools/fslex/fslexpars.fs
@@ -1,8 +1,8 @@
 // Implementation file for parser generated by fsyacc
-module internal FsLexYacc.FsLex.Parser
+module FsLexYacc.FsLex.Parser
 #nowarn "64";; // turn off warnings that type variables used in production annotations are instantiated to concrete type
-open Internal.Utilities.Text.Lexing
-open Internal.Utilities.Text.Parsing.ParseHelpers
+open FSharp.Text.Lexing
+open FSharp.Text.Parsing.ParseHelpers
 # 1 "fslexpars.fsy"
 
 (* (c) Microsoft Corporation 2005-2008.  *)
@@ -244,389 +244,394 @@ let _fsyacc_productionToNonTerminalTable = [|0us; 1us; 2us; 2us; 3us; 3us; 4us;
 let _fsyacc_immediateActions = [|65535us; 49152us; 65535us; 65535us; 65535us; 65535us; 16385us; 16386us; 65535us; 16389us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 16391us; 65535us; 65535us; 65535us; 65535us; 65535us; 16393us; 65535us; 16395us; 16397us; 65535us; 65535us; 16398us; 65535us; 16400us; 16401us; 16402us; 16403us; 16404us; 16405us; 16406us; 65535us; 65535us; 65535us; 16408us; 16409us; 16410us; 65535us; 65535us; 16412us; 65535us; 65535us; 16413us; 65535us; 65535us; 16414us; 65535us; 65535us; 16416us; 65535us; |]
 let _fsyacc_reductions ()  =    [| 
 # 246 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : AST.Spec)) in
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> AST.Spec in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-                      raise (Internal.Utilities.Text.Parsing.Accept(Microsoft.FSharp.Core.Operators.box _1))
+                      raise (FSharp.Text.Parsing.Accept(Microsoft.FSharp.Core.Operators.box _1))
                    )
-                 : '_startspec));
+                 : 'gentype__startspec));
 # 255 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : 'codeopt)) in
-            let _2 = (let data = parseState.GetInput(2) in (Microsoft.FSharp.Core.Operators.unbox data : 'Macros)) in
-            let _4 = (let data = parseState.GetInput(4) in (Microsoft.FSharp.Core.Operators.unbox data : 'Rules)) in
-            let _5 = (let data = parseState.GetInput(5) in (Microsoft.FSharp.Core.Operators.unbox data : 'codeopt)) in
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> 'gentype_codeopt in
+            let _2 = parseState.GetInput(2) :?> 'gentype_Macros in
+            let _4 = parseState.GetInput(4) :?> 'gentype_Rules in
+            let _5 = parseState.GetInput(5) :?> 'gentype_codeopt in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 24 "fslexpars.fsy"
-                                                               { TopCode=_1;Macros=_2;Rules=_4;BottomCode=_5 } 
+# 25 "fslexpars.fsy"
+                                                          
+                         { TopCode=_1;Macros=_2;Rules=_4;BottomCode=_5 }
                    )
-# 24 "fslexpars.fsy"
+# 25 "fslexpars.fsy"
                  : AST.Spec));
-# 269 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : AST.Code)) in
+# 270 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> AST.Code in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 25 "fslexpars.fsy"
-                                     _1 
+# 30 "fslexpars.fsy"
+                              _1 
                    )
-# 25 "fslexpars.fsy"
-                 : 'codeopt));
-# 280 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
+# 30 "fslexpars.fsy"
+                 : 'gentype_codeopt));
+# 281 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 25 "fslexpars.fsy"
-                                              "", (parseState.ResultRange |> fst) 
+# 31 "fslexpars.fsy"
+                         "", (parseState.ResultRange |> fst) 
                    )
-# 25 "fslexpars.fsy"
-                 : 'codeopt));
-# 290 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
+# 31 "fslexpars.fsy"
+                 : 'gentype_codeopt));
+# 291 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 26 "fslexpars.fsy"
-                                [] 
+# 34 "fslexpars.fsy"
+                         [] 
                    )
-# 26 "fslexpars.fsy"
-                 : 'Macros));
-# 300 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : 'macro)) in
-            let _2 = (let data = parseState.GetInput(2) in (Microsoft.FSharp.Core.Operators.unbox data : 'Macros)) in
+# 34 "fslexpars.fsy"
+                 : 'gentype_Macros));
+# 301 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> 'gentype_macro in
+            let _2 = parseState.GetInput(2) :?> 'gentype_Macros in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 26 "fslexpars.fsy"
-                                                      _1 :: _2 
+# 35 "fslexpars.fsy"
+                                     
+                         _1 :: _2
                    )
-# 26 "fslexpars.fsy"
-                 : 'Macros));
-# 312 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _2 = (let data = parseState.GetInput(2) in (Microsoft.FSharp.Core.Operators.unbox data : string)) in
-            let _4 = (let data = parseState.GetInput(4) in (Microsoft.FSharp.Core.Operators.unbox data : 'regexp)) in
+# 35 "fslexpars.fsy"
+                 : 'gentype_Macros));
+# 314 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _2 = parseState.GetInput(2) :?> string in
+            let _4 = parseState.GetInput(4) :?> 'gentype_regexp in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 27 "fslexpars.fsy"
-                                                      (_2, _4) 
+# 40 "fslexpars.fsy"
+                                                
+                         (_2, _4)
                    )
-# 27 "fslexpars.fsy"
-                 : 'macro));
-# 324 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : 'rule)) in
-            let _3 = (let data = parseState.GetInput(3) in (Microsoft.FSharp.Core.Operators.unbox data : 'Rules)) in
+# 40 "fslexpars.fsy"
+                 : 'gentype_macro));
+# 327 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> 'gentype_rule in
+            let _3 = parseState.GetInput(3) :?> 'gentype_Rules in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 28 "fslexpars.fsy"
-                                             _1 :: _3 
+# 45 "fslexpars.fsy"
+                                       
+                         _1 :: _3
                    )
-# 28 "fslexpars.fsy"
-                 : 'Rules));
-# 336 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : 'rule)) in
+# 45 "fslexpars.fsy"
+                 : 'gentype_Rules));
+# 340 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> 'gentype_rule in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 28 "fslexpars.fsy"
-                                                                 [_1] 
+# 48 "fslexpars.fsy"
+                              [_1] 
                    )
-# 28 "fslexpars.fsy"
-                 : 'Rules));
-# 347 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : string)) in
-            let _2 = (let data = parseState.GetInput(2) in (Microsoft.FSharp.Core.Operators.unbox data : 'args)) in
-            let _5 = (let data = parseState.GetInput(5) in (Microsoft.FSharp.Core.Operators.unbox data : 'optbar)) in
-            let _6 = (let data = parseState.GetInput(6) in (Microsoft.FSharp.Core.Operators.unbox data : 'clauses)) in
+# 48 "fslexpars.fsy"
+                 : 'gentype_Rules));
+# 351 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> string in
+            let _2 = parseState.GetInput(2) :?> 'gentype_args in
+            let _5 = parseState.GetInput(5) :?> 'gentype_optbar in
+            let _6 = parseState.GetInput(6) :?> 'gentype_clauses in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 29 "fslexpars.fsy"
-                                                                    (_1,_2,_6) 
+# 51 "fslexpars.fsy"
+                                                               
+                         (_1,_2,_6)
                    )
-# 29 "fslexpars.fsy"
-                 : 'rule));
-# 361 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
+# 51 "fslexpars.fsy"
+                 : 'gentype_rule));
+# 366 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 30 "fslexpars.fsy"
-                             [] 
+# 56 "fslexpars.fsy"
+                          [] 
                    )
-# 30 "fslexpars.fsy"
-                 : 'args));
-# 371 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : string)) in
-            let _2 = (let data = parseState.GetInput(2) in (Microsoft.FSharp.Core.Operators.unbox data : 'args)) in
+# 56 "fslexpars.fsy"
+                 : 'gentype_args));
+# 376 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> string in
+            let _2 = parseState.GetInput(2) :?> 'gentype_args in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 30 "fslexpars.fsy"
-                                                 _1 :: _2 
+# 57 "fslexpars.fsy"
+                                    _1 :: _2 
                    )
-# 30 "fslexpars.fsy"
-                 : 'args));
-# 383 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
+# 57 "fslexpars.fsy"
+                 : 'gentype_args));
+# 388 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 31 "fslexpars.fsy"
-                               
+# 60 "fslexpars.fsy"
+                         
                    )
-# 31 "fslexpars.fsy"
-                 : 'optbar));
-# 393 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
+# 60 "fslexpars.fsy"
+                 : 'gentype_optbar));
+# 398 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 31 "fslexpars.fsy"
-                                         
+# 61 "fslexpars.fsy"
+                             
                    )
-# 31 "fslexpars.fsy"
-                 : 'optbar));
-# 403 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : 'clause)) in
-            let _3 = (let data = parseState.GetInput(3) in (Microsoft.FSharp.Core.Operators.unbox data : 'clauses)) in
+# 61 "fslexpars.fsy"
+                 : 'gentype_optbar));
+# 408 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> 'gentype_clause in
+            let _3 = parseState.GetInput(3) :?> 'gentype_clauses in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 32 "fslexpars.fsy"
-                                                  _1 :: _3 
+# 64 "fslexpars.fsy"
+                                           _1 :: _3 
                    )
-# 32 "fslexpars.fsy"
-                 : 'clauses));
-# 415 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : 'clause)) in
+# 64 "fslexpars.fsy"
+                 : 'gentype_clauses));
+# 420 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> 'gentype_clause in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 32 "fslexpars.fsy"
-                                                                        [_1] 
+# 65 "fslexpars.fsy"
+                                [_1] 
                    )
-# 32 "fslexpars.fsy"
-                 : 'clauses));
-# 426 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : 'regexp)) in
-            let _2 = (let data = parseState.GetInput(2) in (Microsoft.FSharp.Core.Operators.unbox data : AST.Code)) in
+# 65 "fslexpars.fsy"
+                 : 'gentype_clauses));
+# 431 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> 'gentype_regexp in
+            let _2 = parseState.GetInput(2) :?> AST.Code in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 33 "fslexpars.fsy"
-                                           _1, _2 
+# 68 "fslexpars.fsy"
+                                     _1, _2 
                    )
-# 33 "fslexpars.fsy"
-                 : 'clause));
-# 438 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : char)) in
+# 68 "fslexpars.fsy"
+                 : 'gentype_clause));
+# 443 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> char in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 35 "fslexpars.fsy"
-                              Inp(Alphabet(EncodeChar _1)) 
+# 71 "fslexpars.fsy"
+                              Inp(Alphabet(EncodeChar _1))
                    )
-# 35 "fslexpars.fsy"
-                 : 'regexp));
-# 449 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : string)) in
+# 71 "fslexpars.fsy"
+                 : 'gentype_regexp));
+# 454 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> string in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 36 "fslexpars.fsy"
-                                          Inp(UnicodeCategory _1) 
+# 72 "fslexpars.fsy"
+                                          Inp(UnicodeCategory _1)
                    )
-# 36 "fslexpars.fsy"
-                 : 'regexp));
-# 460 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
+# 72 "fslexpars.fsy"
+                 : 'gentype_regexp));
+# 465 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 37 "fslexpars.fsy"
-                             Inp(Alphabet(Eof)) 
+# 73 "fslexpars.fsy"
+                             Inp(Alphabet(fun ctx -> Eof))
                    )
-# 37 "fslexpars.fsy"
-                 : 'regexp));
-# 470 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
+# 73 "fslexpars.fsy"
+                 : 'gentype_regexp));
+# 475 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 38 "fslexpars.fsy"
+# 74 "fslexpars.fsy"
                                     Inp Any 
                    )
-# 38 "fslexpars.fsy"
-                 : 'regexp));
-# 480 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : string)) in
+# 74 "fslexpars.fsy"
+                 : 'gentype_regexp));
+# 485 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> string in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 39 "fslexpars.fsy"
-                                Seq([ for n in 0 .. _1.Length - 1 -> Inp(Alphabet(EncodeChar _1.[n]))]) 
+# 75 "fslexpars.fsy"
+                                Seq([ for n in 0 .. _1.Length - 1 -> Inp(Alphabet(EncodeChar _1.[n]))])
                    )
-# 39 "fslexpars.fsy"
-                 : 'regexp));
-# 491 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : string)) in
+# 75 "fslexpars.fsy"
+                 : 'gentype_regexp));
+# 496 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> string in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 40 "fslexpars.fsy"
+# 76 "fslexpars.fsy"
                                Macro(_1) 
                    )
-# 40 "fslexpars.fsy"
-                 : 'regexp));
-# 502 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : 'regexp)) in
-            let _2 = (let data = parseState.GetInput(2) in (Microsoft.FSharp.Core.Operators.unbox data : 'regexp)) in
+# 76 "fslexpars.fsy"
+                 : 'gentype_regexp));
+# 507 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> 'gentype_regexp in
+            let _2 = parseState.GetInput(2) :?> 'gentype_regexp in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 41 "fslexpars.fsy"
+# 77 "fslexpars.fsy"
                                                          Seq[_1;_2] 
                    )
-# 41 "fslexpars.fsy"
-                 : 'regexp));
-# 514 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : 'regexp)) in
+# 77 "fslexpars.fsy"
+                 : 'gentype_regexp));
+# 519 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> 'gentype_regexp in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 42 "fslexpars.fsy"
+# 78 "fslexpars.fsy"
                                                         Seq[_1;Star _1] 
                    )
-# 42 "fslexpars.fsy"
-                 : 'regexp));
-# 525 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : 'regexp)) in
+# 78 "fslexpars.fsy"
+                 : 'gentype_regexp));
+# 530 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> 'gentype_regexp in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 43 "fslexpars.fsy"
+# 79 "fslexpars.fsy"
                                                         Star _1 
                    )
-# 43 "fslexpars.fsy"
-                 : 'regexp));
-# 536 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : 'regexp)) in
+# 79 "fslexpars.fsy"
+                 : 'gentype_regexp));
+# 541 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> 'gentype_regexp in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 44 "fslexpars.fsy"
-                                                        Alt[Seq[];_1] 
+# 80 "fslexpars.fsy"
+                                                        Alt(fun ctx -> [Seq[];_1])
                    )
-# 44 "fslexpars.fsy"
-                 : 'regexp));
-# 547 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : 'regexp)) in
-            let _3 = (let data = parseState.GetInput(3) in (Microsoft.FSharp.Core.Operators.unbox data : 'regexp)) in
+# 80 "fslexpars.fsy"
+                 : 'gentype_regexp));
+# 552 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> 'gentype_regexp in
+            let _3 = parseState.GetInput(3) :?> 'gentype_regexp in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 45 "fslexpars.fsy"
-                                                             Alt[_1;_3] 
+# 81 "fslexpars.fsy"
+                                                            Alt(fun ctx -> [_1;_3])
                    )
-# 45 "fslexpars.fsy"
-                 : 'regexp));
-# 559 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _2 = (let data = parseState.GetInput(2) in (Microsoft.FSharp.Core.Operators.unbox data : 'regexp)) in
+# 81 "fslexpars.fsy"
+                 : 'gentype_regexp));
+# 564 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _2 = parseState.GetInput(2) :?> 'gentype_regexp in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 46 "fslexpars.fsy"
+# 82 "fslexpars.fsy"
                                                _2 
                    )
-# 46 "fslexpars.fsy"
-                 : 'regexp));
-# 570 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _2 = (let data = parseState.GetInput(2) in (Microsoft.FSharp.Core.Operators.unbox data : 'charset)) in
+# 82 "fslexpars.fsy"
+                 : 'gentype_regexp));
+# 575 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _2 = parseState.GetInput(2) :?> 'gentype_charset in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 47 "fslexpars.fsy"
-                                                 Alt [ for c in _2 -> Inp(Alphabet(c)) ] 
+# 83 "fslexpars.fsy"
+                                                 Alt (fun ctx -> [ for c in (_2 ctx) -> Inp(Alphabet(fun ctx -> c)) ])
                    )
-# 47 "fslexpars.fsy"
-                 : 'regexp));
-# 581 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _3 = (let data = parseState.GetInput(3) in (Microsoft.FSharp.Core.Operators.unbox data : 'charset)) in
+# 83 "fslexpars.fsy"
+                 : 'gentype_regexp));
+# 586 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _3 = parseState.GetInput(3) :?> 'gentype_charset in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 48 "fslexpars.fsy"
-                                                     Inp(NotCharSet(_3)) 
+# 84 "fslexpars.fsy"
+                                                     Inp(NotCharSet(fun ctx -> _3 ctx))
                    )
-# 48 "fslexpars.fsy"
-                 : 'regexp));
-# 592 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : char)) in
+# 84 "fslexpars.fsy"
+                 : 'gentype_regexp));
+# 597 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> char in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 51 "fslexpars.fsy"
-                               Set.singleton(EncodeChar _1) 
+# 87 "fslexpars.fsy"
+                               fun ctx -> Set.singleton(EncodeChar _1 ctx)
                    )
-# 51 "fslexpars.fsy"
-                 : 'charset));
-# 603 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : char)) in
-            let _3 = (let data = parseState.GetInput(3) in (Microsoft.FSharp.Core.Operators.unbox data : char)) in
+# 87 "fslexpars.fsy"
+                 : 'gentype_charset));
+# 608 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> char in
+            let _3 = parseState.GetInput(3) :?> char in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 52 "fslexpars.fsy"
-                                         Set.ofSeq [ for c in _1 .. _3 -> EncodeChar c ] 
+# 88 "fslexpars.fsy"
+                                         fun ctx -> Set.ofSeq [ for c in _1 .. _3 -> EncodeChar c ctx ]
                    )
-# 52 "fslexpars.fsy"
-                 : 'charset));
-# 615 "fslexpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : 'charset)) in
-            let _2 = (let data = parseState.GetInput(2) in (Microsoft.FSharp.Core.Operators.unbox data : 'charset)) in
+# 88 "fslexpars.fsy"
+                 : 'gentype_charset));
+# 620 "fslexpars.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> 'gentype_charset in
+            let _2 = parseState.GetInput(2) :?> 'gentype_charset in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 53 "fslexpars.fsy"
-                                          Set.union _1 _2  
+# 89 "fslexpars.fsy"
+                                          fun ctx -> Set.union (_1 ctx) (_2 ctx)
                    )
-# 53 "fslexpars.fsy"
-                 : 'charset));
+# 89 "fslexpars.fsy"
+                 : 'gentype_charset));
 |]
-# 628 "fslexpars.fs"
-let tables () : Internal.Utilities.Text.Parsing.Tables<_> = 
+# 633 "fslexpars.fs"
+let tables : FSharp.Text.Parsing.Tables<_> = 
   { reductions= _fsyacc_reductions ();
     endOfInputTag = _fsyacc_endOfInputTag;
     tagOfToken = tagOfToken;
@@ -640,12 +645,12 @@ let tables () : Internal.Utilities.Text.Parsing.Tables<_> =
     gotos = _fsyacc_gotos;
     sparseGotoTableRowOffsets = _fsyacc_sparseGotoTableRowOffsets;
     tagOfErrorTerminal = _fsyacc_tagOfErrorTerminal;
-    parseError = (fun (ctxt:Internal.Utilities.Text.Parsing.ParseErrorContext<_>) -> 
+    parseError = (fun (ctxt:FSharp.Text.Parsing.ParseErrorContext<_>) -> 
                               match parse_error_rich with 
                               | Some f -> f ctxt
                               | None -> parse_error ctxt.Message);
     numTerminals = 26;
     productionToNonTerminalTable = _fsyacc_productionToNonTerminalTable  }
-let engine lexer lexbuf startState = (tables ()).Interpret(lexer, lexbuf, startState)
+let engine lexer lexbuf startState = tables.Interpret(lexer, lexbuf, startState)
 let spec lexer lexbuf : AST.Spec =
-    Microsoft.FSharp.Core.Operators.unbox ((tables ()).Interpret(lexer, lexbuf, 0))
+    engine lexer lexbuf 0 :?> _
diff --git a/buildtools/fsyacc/Arg.fs b/buildtools/fsyacc/Arg.fs
index b1131625cf3..d6f8ed790e3 100644
--- a/buildtools/fsyacc/Arg.fs
+++ b/buildtools/fsyacc/Arg.fs
@@ -1,11 +1,6 @@
 // (c) Microsoft Corporation 2005-2009. 
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-namespace Internal.Utilities
-#else
-namespace Microsoft.FSharp.Text
-#endif
-
+namespace FSharp.Text
 
 type ArgType = 
   | ClearArg of bool ref
@@ -35,17 +30,17 @@ exception HelpText of string
 [<Sealed>]
 type ArgParser() = 
     static let getUsage specs u =  
-      let sbuf = new System.Text.StringBuilder 100  
+      let sbuf = System.Text.StringBuilder 100  
       let pstring (s:string) = sbuf.Append s |> ignore 
       let pendline s = pstring s; pstring "\n" 
       pendline u;
       List.iter (fun (arg:ArgInfo) -> 
         match arg.Name, arg.ArgType, arg.HelpText with
-        | (s, (UnitArg _ | SetArg _ | ClearArg _), helpText) -> pstring "\t"; pstring s; pstring ": "; pendline helpText
-        | (s, StringArg _, helpText) -> pstring "\t"; pstring s; pstring " <string>: "; pendline helpText
-        | (s, IntArg _, helpText) -> pstring "\t"; pstring s; pstring " <int>: "; pendline helpText
-        | (s, FloatArg _, helpText) ->  pstring "\t"; pstring s; pstring " <float>: "; pendline helpText
-        | (s, RestArg _, helpText) -> pstring "\t"; pstring s; pstring " ...: "; pendline helpText)
+        | s, (UnitArg _ | SetArg _ | ClearArg _), helpText -> pstring "\t"; pstring s; pstring ": "; pendline helpText
+        | s, StringArg _, helpText -> pstring "\t"; pstring s; pstring " <string>: "; pendline helpText
+        | s, IntArg _, helpText -> pstring "\t"; pstring s; pstring " <int>: "; pendline helpText
+        | s, FloatArg _, helpText ->  pstring "\t"; pstring s; pstring " <float>: "; pendline helpText
+        | s, RestArg _, helpText -> pstring "\t"; pstring s; pstring " ...: "; pendline helpText)
         specs;
       pstring "\t"; pstring "--help"; pstring ": "; pendline "display this list of options";
       pstring "\t"; pstring "-help"; pstring ": "; pendline "display this list of options";
@@ -53,20 +48,20 @@ type ArgParser() =
 
 
     static member ParsePartial(cursor,argv,arguments:seq<ArgInfo>,?otherArgs,?usageText) =
-        let otherArgs = defaultArg otherArgs (fun _ -> ())
+        let other = defaultArg otherArgs (fun _ -> ())
         let usageText = defaultArg usageText ""
         let nargs = Array.length argv 
         incr cursor;
-        let arguments = arguments |> Seq.toList
-        let specs = arguments |> List.map (fun (arg:ArgInfo) -> arg.Name, arg.ArgType)
+        let argSpecs = arguments |> Seq.toList
+        let specs = argSpecs |> List.map (fun (arg:ArgInfo) -> arg.Name, arg.ArgType)
         while !cursor < nargs do
           let arg = argv.[!cursor] 
           let rec findMatchingArg args = 
             match args with
-            | ((s, action) :: _) when s = arg -> 
+            | (s, action) :: _ when s = arg -> 
                let getSecondArg () = 
                    if !cursor + 1 >= nargs then 
-                     raise(Bad("option "+s+" needs an argument.\n"+getUsage arguments usageText));
+                     raise(Bad("option "+s+" needs an argument.\n"+getUsage argSpecs usageText));
                    argv.[!cursor+1] 
                  
                match action with 
@@ -85,40 +80,40 @@ type ArgParser() =
                  cursor := !cursor + 2
                | IntArg f -> 
                  let arg2 = getSecondArg () 
-                 let arg2 = try int32 arg2 with _ -> raise(Bad(getUsage arguments usageText)) in  
+                 let arg2 = try int32 arg2 with _ -> raise(Bad(getUsage argSpecs usageText)) in  
                  f arg2;
                  cursor := !cursor + 2;
                | FloatArg f -> 
                  let arg2 = getSecondArg() 
-                 let arg2 = try float arg2 with _ -> raise(Bad(getUsage arguments usageText)) in 
+                 let arg2 = try float arg2 with _ -> raise(Bad(getUsage argSpecs usageText)) in 
                  f arg2; 
                  cursor := !cursor + 2;
                | RestArg f -> 
                  incr cursor;
                  while !cursor < nargs do
-                     f (argv.[!cursor]);
+                     f argv.[!cursor];
                      incr cursor;
 
-            | (_ :: more)  -> findMatchingArg more 
+            | _ :: more  -> findMatchingArg more 
             | [] -> 
                 if arg = "-help" || arg = "--help" || arg = "/help" || arg = "/help" || arg = "/?" then
-                    raise (HelpText (getUsage arguments usageText))
+                    raise (HelpText (getUsage argSpecs usageText))
                 // Note: for '/abc/def' does not count as an argument
                 // Note: '/abc' does
-                elif arg.Length>0 && (arg.[0] = '-' || (arg.[0] = '/' && not (arg.Length > 1 && arg.[1..].Contains ("/")))) then
-                    raise (Bad ("unrecognized argument: "+ arg + "\n" + getUsage arguments usageText))
+                elif arg.Length>0 && (arg.[0] = '-' || (arg.[0] = '/' && not (arg.Length > 1 && arg.[1..].Contains "/"))) then
+                    raise (Bad ("unrecognized argument: "+ arg + "\n" + getUsage argSpecs usageText))
                 else 
-                   otherArgs arg;
+                   other arg;
                    incr cursor
           findMatchingArg specs 
 
-    static member Usage (arguments,?usage) = 
+    static member Usage (arguments, ?usage) = 
         let usage = defaultArg usage ""
         System.Console.Error.WriteLine (getUsage (Seq.toList arguments) usage)
 
     #if FX_NO_COMMAND_LINE_ARGS
     #else
-    static member Parse (arguments,?otherArgs,?usageText) = 
+    static member Parse (arguments, ?otherArgs,?usageText) = 
         let current = ref 0
         let argv = System.Environment.GetCommandLineArgs() 
         try ArgParser.ParsePartial (current, argv, arguments, ?otherArgs=otherArgs, ?usageText=usageText)
@@ -128,6 +123,6 @@ type ArgParser() =
               System.Console.Error.WriteLine h; 
               System.Console.Error.Flush();  
               System.Environment.Exit(1); 
-          | e -> 
+          | _ -> 
               reraise()
     #endif
diff --git a/buildtools/fsyacc/Arg.fsi b/buildtools/fsyacc/Arg.fsi
index 367f69f959f..b5203999928 100644
--- a/buildtools/fsyacc/Arg.fsi
+++ b/buildtools/fsyacc/Arg.fsi
@@ -1,11 +1,7 @@
 // (c) Microsoft Corporation 2005-2009. 
 
 /// A simple command-line argument processor.
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-namespace Internal.Utilities
-#else
-namespace Microsoft.FSharp.Text
-#endif
+namespace FSharp.Text
 
 /// The spec value describes the action of the argument,
 /// and whether it expects a following parameter.
@@ -37,7 +33,7 @@ type ArgParser =
     [<System.Obsolete("This method should not be used directly as it will be removed in a future revision of this library")>]
     static member ParsePartial: cursor: int ref * argv: string[] * arguments:seq<ArgInfo> * ?otherArgs: (string -> unit) * ?usageText:string -> unit
 
-    /// Parse the arguments given by System.Environment.GetEnvironmentVariables()
+    /// Parse the arguments given by System.Environment.GetCommandLineArgs()
     /// according to the argument processing specifications "specs".
     /// Args begin with "-". Non-arguments are passed to "f" in
     /// order.  "use" is printed as part of the usage line if an error occurs.
diff --git a/buildtools/fsyacc/Lexing.fs b/buildtools/fsyacc/Lexing.fs
index 760ace5a932..40aacdcac96 100644
--- a/buildtools/fsyacc/Lexing.fs
+++ b/buildtools/fsyacc/Lexing.fs
@@ -1,423 +1,456 @@
 // (c) Microsoft Corporation 2005-2009.
+module FSharp.Text.Lexing
 
 #nowarn "47" // recursive initialization of LexBuffer
 
+open System.Collections.Generic
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-namespace Internal.Utilities.Text.Lexing
-
-#else
-namespace Microsoft.FSharp.Text.Lexing 
-#endif
-
-    open System.Collections.Generic
-
-    // REVIEW: This type showed up on a parsing-intensive performance measurement. Consider whether it can be a struct-record later when we have this feature. -jomo
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-    type internal Position = 
-#else
-    type Position = 
-#endif
-        { pos_fname : string;
-          pos_lnum : int;
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-          pos_orig_lnum : int;
-#endif
-          pos_bol : int;
-          pos_cnum : int; }
-        member x.FileName = x.pos_fname
-        member x.Line = x.pos_lnum
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-        member x.OriginalLine = x.pos_orig_lnum
-#endif
-        member x.Char = x.pos_cnum
-        member x.AbsoluteOffset = x.pos_cnum
-        member x.StartOfLine = x.pos_bol
-        member x.StartOfLineAbsoluteOffset = x.pos_bol
-        member x.Column = x.pos_cnum - x.pos_bol
-        member pos.NextLine = 
-            { pos with 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-                    pos_orig_lnum = pos.OriginalLine + 1;
-#endif
-                    pos_lnum = pos.Line+1; 
-                    pos_bol = pos.AbsoluteOffset }
-        member pos.EndOfToken(n) = {pos with pos_cnum=pos.pos_cnum + n }
-        member pos.AsNewLinePos() = pos.NextLine
-        member pos.ShiftColumnBy(by) = {pos with pos_cnum = pos.pos_cnum + by}
-        static member Empty = 
-            { pos_fname=""; 
-              pos_lnum= 0; 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-              pos_orig_lnum = 0;
-#endif
-              pos_bol= 0; 
-              pos_cnum=0 }
-        static member FirstLine(filename) = 
-            { pos_fname=filename; 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-              pos_orig_lnum = 1;
-#endif
-              pos_lnum= 1; 
-              pos_bol= 0; 
-              pos_cnum=0 }
-
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-    type internal LexBufferFiller<'char> = 
-#else
-    type LexBufferFiller<'char> = 
-#endif
-        { fillSync : (LexBuffer<'char> -> unit) option
-          fillAsync : (LexBuffer<'char> -> Async<unit>) option } 
-        
-    and [<Sealed>]
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-        internal LexBuffer<'char>(filler: LexBufferFiller<'char>) as this = 
-#else
-        LexBuffer<'char>(filler: LexBufferFiller<'char>) as this = 
-#endif
-        let context = new Dictionary<string,obj>(1) in 
-        let extendBufferSync = (fun () -> match filler.fillSync with Some refill -> refill this | None -> invalidOp "attempt to read synchronously from an asynchronous lex buffer")
-        let extendBufferAsync = (fun () -> match filler.fillAsync with Some refill -> refill this | None -> invalidOp "attempt to read asynchronously from a synchronous lex buffer")
-        let mutable buffer=[||];
-        /// number of valid charactes beyond bufferScanStart 
-        let mutable bufferMaxScanLength=0;
-        /// count into the buffer when scanning 
-        let mutable bufferScanStart=0;
-        /// number of characters scanned so far 
-        let mutable bufferScanLength=0;
-        /// length of the scan at the last accepting state 
-        let mutable lexemeLength=0;
-        /// action related to the last accepting state 
-        let mutable bufferAcceptAction=0;
-        let mutable eof = false;
-        let mutable startPos = Position.Empty ;
-        let mutable endPos = Position.Empty
-
-        // Throw away all the input besides the lexeme 
-              
-        let discardInput () = 
-            let keep = Array.sub buffer bufferScanStart bufferScanLength
-            let nkeep = keep.Length 
-            Array.blit keep 0 buffer 0 nkeep;
-            bufferScanStart <- 0;
-            bufferMaxScanLength <- nkeep
-                 
-              
-        member lexbuf.EndOfScan () : int =
-            // Printf.eprintf "endOfScan, lexBuffer.lexemeLength = %d\n" lexBuffer.lexemeLength;
-            if bufferAcceptAction < 0 then 
-                failwith "unrecognized input"
-
-            //  Printf.printf "endOfScan %d state %d on unconsumed input '%c' (%d)\n" a s (Char.chr inp) inp;
-            //   Printf.eprintf "accept, lexeme = %s\n" (lexeme lexBuffer); 
-            lexbuf.StartPos <- endPos;
-            lexbuf.EndPos <- endPos.EndOfToken(lexbuf.LexemeLength);
-            bufferAcceptAction
-
-        member lexbuf.StartPos
-           with get() = startPos
-           and  set(b) =  startPos <- b
-           
-        member lexbuf.EndPos 
-           with get() = endPos
-           and  set(b) =  endPos <- b
-
-        member lexbuf.Lexeme         = Array.sub buffer bufferScanStart lexemeLength
-        member lexbuf.LexemeChar(n)  = buffer.[n+bufferScanStart]
-        
-        member lexbuf.BufferLocalStore = (context :> IDictionary<_,_>)
-        member lexbuf.LexemeLength        with get() : int = lexemeLength    and set v = lexemeLength <- v
-        member internal lexbuf.Buffer              with get() : 'char[] = buffer              and set v = buffer <- v
-        member internal lexbuf.BufferMaxScanLength with get() = bufferMaxScanLength and set v = bufferMaxScanLength <- v
-        member internal lexbuf.BufferScanLength    with get() = bufferScanLength    and set v = bufferScanLength <- v
-        member internal lexbuf.BufferScanStart     with get() : int = bufferScanStart     and set v = bufferScanStart <- v
-        member internal lexbuf.BufferAcceptAction  with get() = bufferAcceptAction  and set v = bufferAcceptAction <- v
-        member internal lexbuf.RefillBuffer = extendBufferSync
-        member internal lexbuf.AsyncRefillBuffer = extendBufferAsync
-
-        static member LexemeString(lexbuf:LexBuffer<char>) = 
-            new System.String(lexbuf.Buffer,lexbuf.BufferScanStart,lexbuf.LexemeLength)
-
-        member lexbuf.IsPastEndOfStream 
-           with get() = eof
-           and  set(b) =  eof <- b
-
-        member lexbuf.DiscardInput() = discardInput ()
-
-        member x.BufferScanPos = bufferScanStart + bufferScanLength
-
-        member lexbuf.EnsureBufferSize n = 
-            if lexbuf.BufferScanPos + n >= buffer.Length then 
-                let repl = Array.zeroCreate (lexbuf.BufferScanPos + n) 
-                Array.blit buffer bufferScanStart repl bufferScanStart bufferScanLength;
-                buffer <- repl
-
-        static member FromReadFunctions (syncRead : ('char[] * int * int -> int) option, asyncRead : ('char[] * int * int -> Async<int>) option) : LexBuffer<'char> = 
-            let extension= Array.zeroCreate 4096
-            let fillers = 
-                { fillSync = 
-                    match syncRead with 
-                    | None -> None
-                    | Some read -> 
-                         Some (fun lexBuffer -> 
-                             let n = read(extension,0,extension.Length)
-                             lexBuffer.EnsureBufferSize n;
-                             Array.blit extension 0 lexBuffer.Buffer lexBuffer.BufferScanPos n;
-                             lexBuffer.BufferMaxScanLength <- lexBuffer.BufferScanLength + n); 
-                  fillAsync = 
-                    match asyncRead with 
-                    | None -> None
-                    | Some read -> 
-                         Some (fun lexBuffer -> 
-                                  async { 
-                                      let! n = read(extension,0,extension.Length)
-                                      lexBuffer.EnsureBufferSize n;
-                                      Array.blit extension 0 lexBuffer.Buffer lexBuffer.BufferScanPos n;
-                                      lexBuffer.BufferMaxScanLength <- lexBuffer.BufferScanLength + n }) }
-            new LexBuffer<_>(fillers)
-
-        // A full type signature is required on this method because it is used at more specific types within its own scope
-        static member FromFunction (f : 'char[] * int * int -> int) : LexBuffer<'char> =  LexBuffer<_>.FromReadFunctions(Some(f),None)
-        static member FromAsyncFunction (f : 'char[] * int * int -> Async<int>) : LexBuffer<'char> =  LexBuffer<_>.FromReadFunctions(None,Some(f))
-              
-        static member FromCharFunction f : LexBuffer<char> = 
-            LexBuffer<char>.FromFunction(fun (buff,start,len) -> 
-                let buff2 = Array.zeroCreate len
-                let n = f buff2 len 
-                Array.blit buff2 0 buff start len
-                n)
-        static member FromByteFunction f : LexBuffer<byte> = 
-            LexBuffer<byte>.FromFunction(fun (buff,start,len) -> 
-                let buff2 = Array.zeroCreate len
-                let n = f buff2 len 
-                Array.blit buff2 0 buff start len
-                n)
-
-        // A full type signature is required on this method because it is used at more specific types within its own scope
-        static member FromArray (s: 'char[]) : LexBuffer<'char> = 
-            let lexBuffer = 
-                new LexBuffer<_> 
-                    { fillSync = Some (fun _ -> ()); 
-                      fillAsync = Some (fun _ -> async { return () }) }
-            let buffer = Array.copy s 
-            lexBuffer.Buffer <- buffer;
-            lexBuffer.BufferMaxScanLength <- buffer.Length;
-            lexBuffer
-
-        static member FromBytes    (arr) = LexBuffer<byte>.FromArray(arr)
-        static member FromChars    (arr) = LexBuffer<char>.FromArray(arr) 
-        static member FromString (s:string) = LexBuffer<char>.FromChars (s.ToCharArray())
-
-        static member FromTextReader (tr:System.IO.TextReader)  : LexBuffer<char> = 
-           LexBuffer<char>.FromFunction(tr.Read) 
-
-        static member FromBinaryReader (br:System.IO.BinaryReader)  : LexBuffer<byte> = 
-           LexBuffer<byte>.FromFunction(br.Read) 
-
-        static member FromStream (stream:System.IO.Stream)  : LexBuffer<byte> = 
-           LexBuffer<byte>.FromReadFunctions(Some(stream.Read),Some(fun (buf,offset,len) -> stream.AsyncRead(buf,offset=offset,count=len))) 
-
-    module GenericImplFragments = 
-        let startInterpret(lexBuffer:LexBuffer<_>)= 
-            lexBuffer.BufferScanStart <- lexBuffer.BufferScanStart + lexBuffer.LexemeLength;
-            lexBuffer.BufferMaxScanLength <- lexBuffer.BufferMaxScanLength - lexBuffer.LexemeLength;
-            lexBuffer.BufferScanLength <- 0;
-            lexBuffer.LexemeLength <- 0;
-            lexBuffer.BufferAcceptAction <- -1;
-
-        let afterRefill (trans: uint16[] array,sentinel,lexBuffer:LexBuffer<_>,scanUntilSentinel,endOfScan,state,eofPos) = 
-            // end of file occurs if we couldn't extend the buffer 
-            if lexBuffer.BufferScanLength = lexBuffer.BufferMaxScanLength then  
-                let snew = int trans.[state].[eofPos] // == EOF 
-                if snew = sentinel then 
-                    endOfScan()
-                else 
-                    if lexBuffer.IsPastEndOfStream then failwith "End of file on lexing stream";
-                    lexBuffer.IsPastEndOfStream <- true;
-                    // Printf.printf "state %d --> %d on eof\n" state snew;
-                    scanUntilSentinel(lexBuffer,snew)
-            else 
-                scanUntilSentinel(lexBuffer, state)
+// REVIEW: This type showed up on a parsing-intensive performance measurement. Consider whether it can be a struct-record later when we have this feature. -jomo
+[<Struct>]
+type Position = 
+    { pos_fname : string
+      pos_lnum : int
+      pos_orig_lnum : int
+      pos_bol : int
+      pos_cnum : int }
 
-        let onAccept (lexBuffer:LexBuffer<_>,a) = 
-            lexBuffer.LexemeLength <- lexBuffer.BufferScanLength;
-            lexBuffer.BufferAcceptAction <- a;
+    member pos.FileName = pos.pos_fname
 
-    open GenericImplFragments
+    member pos.Line = pos.pos_lnum
 
-    [<Sealed>]
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-    type internal AsciiTables(trans: uint16[] array, accept: uint16[]) =
-#else
-    type AsciiTables(trans: uint16[] array, accept: uint16[]) =
-#endif
-        let rec scanUntilSentinel(lexBuffer, state) =
-            let sentinel = 255 * 256 + 255 
-            // Return an endOfScan after consuming the input 
-            let a = int accept.[state] 
-            if a <> sentinel then 
-                onAccept (lexBuffer,a)
-            
-            if lexBuffer.BufferScanLength = lexBuffer.BufferMaxScanLength then 
-                lexBuffer.DiscardInput();
-                lexBuffer.RefillBuffer ();
-              // end of file occurs if we couldn't extend the buffer 
-                afterRefill (trans,sentinel,lexBuffer,scanUntilSentinel,lexBuffer.EndOfScan,state,256 (* == EOF *) )
-            else
-                // read a character - end the scan if there are no further transitions 
-                let inp = int(lexBuffer.Buffer.[lexBuffer.BufferScanPos])
-                let snew = int trans.[state].[inp] 
-                if snew = sentinel then 
-                    lexBuffer.EndOfScan()
-                else 
-                    lexBuffer.BufferScanLength <- lexBuffer.BufferScanLength + 1;
-                    // Printf.printf "state %d --> %d on '%c' (%d)\n" state snew (Char.chr inp) inp;
-                    scanUntilSentinel(lexBuffer, snew)
-            
-        /// Interpret tables for an ascii lexer generated by fslex. 
-        member tables.Interpret(initialState,lexBuffer : LexBuffer<byte>) = 
-            startInterpret(lexBuffer)
-            scanUntilSentinel(lexBuffer, initialState)
+    member pos.OriginalLine = pos.pos_orig_lnum
 
-        /// Interpret tables for an ascii lexer generated by fslex. 
-        member tables.AsyncInterpret(initialState,lexBuffer : LexBuffer<byte>) = 
-        
-            let rec scanUntilSentinel(lexBuffer,state) : Async<int> = 
-                async {  
-                    let sentinel = 255 * 256 + 255 
-                    // Return an endOfScan after consuming the input 
-                    let a = int accept.[state] 
-                    if a <> sentinel then 
-                        onAccept (lexBuffer,a)
-                    
-                    if lexBuffer.BufferScanLength = lexBuffer.BufferMaxScanLength then 
-                        lexBuffer.DiscardInput();
-                        do! lexBuffer.AsyncRefillBuffer ();
-                       // end of file occurs if we couldn't extend the buffer 
-                        return! afterRefill (trans,sentinel,lexBuffer,scanUntilSentinel,endOfScan,state,256 (* == EOF *) )
-                    else
-                        // read a character - end the scan if there are no further transitions 
-                        let inp = int(lexBuffer.Buffer.[lexBuffer.BufferScanPos])
-                        let snew = int trans.[state].[inp] 
-                        if snew = sentinel then 
-                            return! endOfScan()
-                        else 
-                            lexBuffer.BufferScanLength <- lexBuffer.BufferScanLength + 1;
-                            return! scanUntilSentinel(lexBuffer,snew)
-                }
-            and endOfScan() = 
-                async { return lexBuffer.EndOfScan() }
-            startInterpret(lexBuffer)
-            scanUntilSentinel(lexBuffer, initialState)
-
-
-        static member Create(trans,accept) = new AsciiTables(trans,accept)
-
-    [<Sealed>]
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-    type internal UnicodeTables(trans: uint16[] array, accept: uint16[]) = 
-#else
-    type UnicodeTables(trans: uint16[] array, accept: uint16[]) = 
-#endif
+    member pos.Char = pos.pos_cnum
+
+    member pos.AbsoluteOffset = pos.pos_cnum
+
+    member pos.StartOfLine = pos.pos_bol
+
+    member pos.StartOfLineAbsoluteOffset = pos.pos_bol
+
+    member pos.Column = pos.pos_cnum - pos.pos_bol
+
+    member pos.NextLine = 
+        let pos = pos
+        { pos with 
+                pos_orig_lnum = pos.OriginalLine + 1
+                pos_lnum = pos.Line+1 
+                pos_bol = pos.AbsoluteOffset }
+
+    member pos.EndOfToken(n) = 
+        let pos = pos
+        {pos with pos_cnum=pos.pos_cnum + n }
+
+    member pos.AsNewLinePos() = pos.NextLine
+
+    member pos.ShiftColumnBy(by) = 
+        let pos = pos
+        {pos with pos_cnum = pos.pos_cnum + by}
+
+    static member Empty = 
+        { pos_fname="" 
+          pos_lnum= 0 
+          pos_orig_lnum = 0
+          pos_bol= 0 
+          pos_cnum=0 }
+
+    static member FirstLine(filename) = 
+        { pos_fname=filename 
+          pos_orig_lnum = 1
+          pos_lnum= 1 
+          pos_bol= 0 
+          pos_cnum=0 }
+
+type LexBufferFiller<'char> = 
+    { fillSync : (LexBuffer<'char> -> unit) option
+      fillAsync : (LexBuffer<'char> -> Async<unit>) option } 
+    
+and [<Sealed>]
+    LexBuffer<'char>(filler: LexBufferFiller<'char>) as this = 
+    let context = Dictionary<string, obj>(1) in 
+    let extendBufferSync = (fun () -> match filler.fillSync with Some refill -> refill this | None -> invalidOp "attempt to read synchronously from an asynchronous lex buffer")
+    let extendBufferAsync = (fun () -> match filler.fillAsync with Some refill -> refill this | None -> invalidOp "attempt to read asynchronously from a synchronous lex buffer")
+    let mutable buffer=[||]
+
+    /// number of valid charactes beyond bufferScanStart 
+    let mutable bufferMaxScanLength=0
+
+    /// count into the buffer when scanning 
+    let mutable bufferScanStart=0
+
+    /// number of characters scanned so far 
+    let mutable bufferScanLength=0
+
+    /// length of the scan at the last accepting state 
+    let mutable lexemeLength=0
+
+    /// action related to the last accepting state 
+    let mutable bufferAcceptAction=0
+
+    let mutable eof = false
+
+    let mutable startPos = Position.Empty 
+
+    let mutable endPos = Position.Empty
+
+    /// Throw away all the input besides the lexeme      
+    let discardInput () = 
+        Array.blit buffer bufferScanStart buffer 0 bufferScanLength
+        bufferScanStart <- 0
+        bufferMaxScanLength <- bufferScanLength
+             
+    member lexbuf.EndOfScan () : int =
+        // Printf.eprintf "endOfScan, lexBuffer.lexemeLength = %d\n" lexBuffer.lexemeLength
+        if bufferAcceptAction < 0 then 
+            failwith "unrecognized input"
+
+        // Printf.printf "endOfScan %d state %d on unconsumed input '%c' (%d)\n" a s (Char.chr inp) inp
+        // Printf.eprintf "accept, lexeme = %s\n" (lexeme lexBuffer) 
+        lexbuf.StartPos <- endPos
+        lexbuf.EndPos <- endPos.EndOfToken(lexbuf.LexemeLength)
+        bufferAcceptAction
+
+    member _.StartPos
+       with get() = startPos
+       and  set b = startPos <- b
+       
+    member _.EndPos 
+       with get() = endPos
+       and  set b = endPos <- b
+
+    member _.Lexeme = Array.sub buffer bufferScanStart lexemeLength
+
+    member _.LexemeChar n = buffer.[n+bufferScanStart]
+    
+    member _.BufferLocalStore = (context :> IDictionary<_, _>)
+
+    member _.LexemeLength
+        with get() : int = lexemeLength
+        and set v = lexemeLength <- v
+
+    member internal _.Buffer
+        with get() : 'char[] = buffer
+        and set v = buffer <- v
+
+    member internal _.BufferMaxScanLength
+        with get() = bufferMaxScanLength
+        and set v = bufferMaxScanLength <- v
+
+    member internal _.BufferScanLength
+        with get() = bufferScanLength    
+        and set v = bufferScanLength <- v
+
+    member internal _.BufferScanStart
+        with get() : int = bufferScanStart     
+        and set v = bufferScanStart <- v
+
+    member internal _.BufferAcceptAction 
+        with get() = bufferAcceptAction  
+        and set v = bufferAcceptAction <- v
+
+    member internal _.RefillBuffer = extendBufferSync
+
+    member internal _.AsyncRefillBuffer = extendBufferAsync
+
+    static member LexemeString(lexbuf:LexBuffer<char>) = 
+        System.String(lexbuf.Buffer, lexbuf.BufferScanStart, lexbuf.LexemeLength)
+
+    member _.IsPastEndOfStream 
+       with get() = eof
+       and  set b = eof <- b
+
+    member _.DiscardInput() = discardInput ()
+
+    member _.BufferScanPos = bufferScanStart + bufferScanLength
+
+    member lexbuf.EnsureBufferSize n = 
+        if lexbuf.BufferScanPos + n >= buffer.Length then 
+            let repl = Array.zeroCreate (lexbuf.BufferScanPos + n) 
+            Array.blit buffer bufferScanStart repl bufferScanStart bufferScanLength
+            buffer <- repl
+
+    static member FromReadFunctions (syncRead : ('char[] * int * int -> int) option, asyncRead : ('char[] * int * int -> Async<int>) option) : LexBuffer<'char> = 
+        let extension= Array.zeroCreate 4096
+        let fillers = 
+            { fillSync = 
+                match syncRead with 
+                | None -> None
+                | Some read -> 
+                     Some (fun lexBuffer -> 
+                         let n = read(extension, 0, extension.Length)
+                         lexBuffer.EnsureBufferSize n
+                         Array.blit extension 0 lexBuffer.Buffer lexBuffer.BufferScanPos n
+                         lexBuffer.BufferMaxScanLength <- lexBuffer.BufferScanLength + n) 
+              fillAsync = 
+                match asyncRead with 
+                | None -> None
+                | Some read -> 
+                     Some (fun lexBuffer -> 
+                              async { 
+                                  let! n = read(extension, 0, extension.Length)
+                                  lexBuffer.EnsureBufferSize n
+                                  Array.blit extension 0 lexBuffer.Buffer lexBuffer.BufferScanPos n
+                                  lexBuffer.BufferMaxScanLength <- lexBuffer.BufferScanLength + n }) }
+        LexBuffer<_>(fillers)
+
+    // A full type signature is required on this method because it is used at more specific types within its own scope
+    static member FromFunction (f : 'char[] * int * int -> int) : LexBuffer<'char> = 
+        LexBuffer<_>.FromReadFunctions(Some(f), None)
+
+    static member FromAsyncFunction (f : 'char[] * int * int -> Async<int>) : LexBuffer<'char> = 
+        LexBuffer<_>.FromReadFunctions(None, Some(f))
+          
+    static member FromCharFunction f : LexBuffer<char> = 
+        LexBuffer<char>.FromFunction(fun (buff, start, len) -> 
+            let buff2 = Array.zeroCreate len
+            let n = f buff2 len 
+            Array.blit buff2 0 buff start len
+            n)
+
+    static member FromByteFunction f : LexBuffer<byte> = 
+        LexBuffer<byte>.FromFunction(fun (buff, start, len) -> 
+            let buff2 = Array.zeroCreate len
+            let n = f buff2 len 
+            Array.blit buff2 0 buff start len
+            n)
+
+    // A full type signature is required on this method because it is used at more specific types within its own scope
+    static member FromArray (s: 'char[]) : LexBuffer<'char> = 
+        let lexBuffer = 
+            LexBuffer<_> 
+                { fillSync = Some (fun _ -> ()) 
+                  fillAsync = Some (fun _ -> async { return () }) }
+        lexBuffer.Buffer <- s
+        lexBuffer.BufferMaxScanLength <- s.Length
+        lexBuffer
+
+    static member FromBytes arr =
+        LexBuffer<byte>.FromArray(Array.copy arr)
+
+    static member FromChars arr =
+        LexBuffer<char>.FromArray(Array.copy arr)
+
+    static member FromString (s:string) =
+        LexBuffer<char>.FromArray (s.ToCharArray())
+
+    static member FromTextReader (tr:System.IO.TextReader) : LexBuffer<char> = 
+       LexBuffer<char>.FromReadFunctions(Some tr.Read, Some (tr.ReadAsync >> Async.AwaitTask))
+
+    static member FromBinaryReader (br:System.IO.BinaryReader) : LexBuffer<byte> = 
+       LexBuffer<byte>.FromFunction(br.Read)
+
+    static member FromStream (stream:System.IO.Stream) : LexBuffer<byte> = 
+       LexBuffer<byte>.FromReadFunctions(Some(stream.Read), Some(fun (buf, offset, len) -> stream.AsyncRead(buf, offset=offset, count=len))) 
+
+module GenericImplFragments = 
+    let startInterpret(lexBuffer:LexBuffer<_>)= 
+        lexBuffer.BufferScanStart <- lexBuffer.BufferScanStart + lexBuffer.LexemeLength
+        lexBuffer.BufferMaxScanLength <- lexBuffer.BufferMaxScanLength - lexBuffer.LexemeLength
+        lexBuffer.BufferScanLength <- 0
+        lexBuffer.LexemeLength <- 0
+        lexBuffer.BufferAcceptAction <- -1
+
+    let afterRefill (trans: uint16[] array, sentinel, lexBuffer:LexBuffer<_>, scanUntilSentinel, endOfScan, state, eofPos) = 
+        // end of file occurs if we couldn't extend the buffer 
+        if lexBuffer.BufferScanLength = lexBuffer.BufferMaxScanLength then  
+            let snew = int trans.[state].[eofPos] // == EOF 
+            if snew = sentinel then 
+                endOfScan()
+            else 
+                if lexBuffer.IsPastEndOfStream then failwith "End of file on lexing stream"
+                lexBuffer.IsPastEndOfStream <- true
+                // Printf.printf "state %d --> %d on eof\n" state snew
+                scanUntilSentinel(lexBuffer, snew)
+        else 
+            scanUntilSentinel(lexBuffer, state)
+
+    let onAccept (lexBuffer:LexBuffer<_>, a) = 
+        lexBuffer.LexemeLength <- lexBuffer.BufferScanLength
+        lexBuffer.BufferAcceptAction <- a
+
+open GenericImplFragments
+
+[<Sealed>]
+type AsciiTables(trans: uint16[] array, accept: uint16[]) =
+    let rec scanUntilSentinel(lexBuffer, state) =
         let sentinel = 255 * 256 + 255 
-        let numUnicodeCategories = 30 
-        let numLowUnicodeChars = 128 
-        let numSpecificUnicodeChars = (trans.[0].Length - 1 - numLowUnicodeChars - numUnicodeCategories)/2
-        let lookupUnicodeCharacters (state,inp: char) = 
-            let inpAsInt = int inp
-            // Is it a fast ASCII character?
-            if inpAsInt < numLowUnicodeChars then 
-                int trans.[state].[inpAsInt]
+        // Return an endOfScan after consuming the input 
+        let a = int accept.[state] 
+        if a <> sentinel then 
+            onAccept (lexBuffer, a)
+        
+        if lexBuffer.BufferScanLength = lexBuffer.BufferMaxScanLength then 
+            lexBuffer.DiscardInput()
+            lexBuffer.RefillBuffer ()
+          // end of file occurs if we couldn't extend the buffer 
+            afterRefill (trans, sentinel, lexBuffer, scanUntilSentinel, lexBuffer.EndOfScan, state, 256 (* == EOF *) )
+        else
+            // read a character - end the scan if there are no further transitions 
+            let inp = int(lexBuffer.Buffer.[lexBuffer.BufferScanPos])
+            let snew = int trans.[state].[inp] 
+            if snew = sentinel then 
+                lexBuffer.EndOfScan()
             else 
-                // Search for a specific unicode character
-                let baseForSpecificUnicodeChars = numLowUnicodeChars
-                let rec loop i = 
-                    if i >= numSpecificUnicodeChars then 
-                        // OK, if we failed then read the 'others' entry in the alphabet,
-                        // which covers all Unicode characters not covered in other
-                        // ways
-                        let baseForUnicodeCategories = numLowUnicodeChars+numSpecificUnicodeChars*2
-                        let unicodeCategory = System.Globalization.CharUnicodeInfo.GetUnicodeCategory(inp)
-                        //System.Console.WriteLine("inp = {0}, unicodeCategory = {1}", [| box inp; box unicodeCategory |]);
-                        int trans.[state].[baseForUnicodeCategories + int32 unicodeCategory]
-                    else 
-                        // This is the specific unicode character
-                        let c = char (int trans.[state].[baseForSpecificUnicodeChars+i*2])
-                        //System.Console.WriteLine("c = {0}, inp = {1}, i = {2}", [| box c; box inp; box i |]);
-                        // OK, have we found the entry for a specific unicode character?
-                        if c = inp
-                        then int trans.[state].[baseForSpecificUnicodeChars+i*2+1]
-                        else loop(i+1)
+                lexBuffer.BufferScanLength <- lexBuffer.BufferScanLength + 1
+                // Printf.printf "state %d --> %d on '%c' (%d)\n" state snew (Char.chr inp) inp
+                scanUntilSentinel(lexBuffer, snew)
+        
+    /// Interpret tables for an ascii lexer generated by fslex. 
+    member tables.Interpret(initialState, lexBuffer : LexBuffer<byte>) = 
+        startInterpret(lexBuffer)
+        scanUntilSentinel(lexBuffer, initialState)
+
+    /// Interpret tables for an ascii lexer generated by fslex. 
+    member tables.AsyncInterpret(initialState, lexBuffer : LexBuffer<byte>) = 
+    
+        let rec scanUntilSentinel(lexBuffer, state) : Async<int> = 
+            async { 
+                let sentinel = 255 * 256 + 255 
+                // Return an endOfScan after consuming the input 
+                let a = int accept.[state] 
+                if a <> sentinel then 
+                    onAccept (lexBuffer, a)
                 
-                loop 0
-        let eofPos    = numLowUnicodeChars + 2*numSpecificUnicodeChars + numUnicodeCategories 
+                if lexBuffer.BufferScanLength = lexBuffer.BufferMaxScanLength then 
+                    lexBuffer.DiscardInput()
+                    do! lexBuffer.AsyncRefillBuffer ()
+                   // end of file occurs if we couldn't extend the buffer 
+                    return! afterRefill (trans, sentinel, lexBuffer, scanUntilSentinel, endOfScan, state, 256 (* == EOF *) )
+                else
+                    // read a character - end the scan if there are no further transitions 
+                    let inp = int(lexBuffer.Buffer.[lexBuffer.BufferScanPos])
+                    let snew = int trans.[state].[inp] 
+                    if snew = sentinel then 
+                        return! endOfScan()
+                    else 
+                        lexBuffer.BufferScanLength <- lexBuffer.BufferScanLength + 1
+                        return! scanUntilSentinel(lexBuffer, snew)
+            }
+
+        and endOfScan() = 
+            async { return lexBuffer.EndOfScan() }
+
+        startInterpret(lexBuffer)
+
+        scanUntilSentinel(lexBuffer, initialState)
+
+
+    static member Create(trans, accept) = AsciiTables(trans, accept)
+
+[<Sealed>]
+type UnicodeTables(trans: uint16[] array, accept: uint16[]) = 
+    let sentinel = 255 * 256 + 255 
+    let numUnicodeCategories = 30 
+    let numLowUnicodeChars = 128 
+    let numSpecificUnicodeChars = (trans.[0].Length - 1 - numLowUnicodeChars - numUnicodeCategories)/2
+    let lookupUnicodeCharacters (state, inp: char) = 
+        let inpAsInt = int inp
+        // Is it a fast ASCII character?
+        if inpAsInt < numLowUnicodeChars then 
+            int trans.[state].[inpAsInt]
+        else 
+            // Search for a specific unicode character
+            let baseForSpecificUnicodeChars = numLowUnicodeChars
+            let rec loop i = 
+                if i >= numSpecificUnicodeChars then 
+                    // OK, if we failed then read the 'others' entry in the alphabet, 
+                    // which covers all Unicode characters not covered in other
+                    // ways
+                    let baseForUnicodeCategories = numLowUnicodeChars+numSpecificUnicodeChars*2
+                    let unicodeCategory = System.Globalization.CharUnicodeInfo.GetUnicodeCategory(inp)
+                    //System.Console.WriteLine("inp = {0}, unicodeCategory = {1}", [| box inp; box unicodeCategory |])
+                    int trans.[state].[baseForUnicodeCategories + int32 unicodeCategory]
+                else 
+                    // This is the specific unicode character
+                    let c = char (int trans.[state].[baseForSpecificUnicodeChars+i*2])
+                    //System.Console.WriteLine("c = {0}, inp = {1}, i = {2}", [| box c; box inp; box i |])
+                    // OK, have we found the entry for a specific unicode character?
+                    if c = inp
+                    then int trans.[state].[baseForSpecificUnicodeChars+i*2+1]
+                    else loop(i+1)
+            
+            loop 0
+    let eofPos    = numLowUnicodeChars + 2*numSpecificUnicodeChars + numUnicodeCategories 
+    
+    let rec scanUntilSentinel(lexBuffer, state) =
+        // Return an endOfScan after consuming the input 
+        let a = int accept.[state] 
+        if a <> sentinel then 
+            onAccept(lexBuffer, a)
         
-        let rec scanUntilSentinel(lexBuffer,state) =
-            // Return an endOfScan after consuming the input 
-            let a = int accept.[state] 
-            if a <> sentinel then 
-                onAccept(lexBuffer,a)
+        if lexBuffer.BufferScanLength = lexBuffer.BufferMaxScanLength then 
+            lexBuffer.DiscardInput()
+            lexBuffer.RefillBuffer ()
+          // end of file occurs if we couldn't extend the buffer 
+            afterRefill (trans, sentinel, lexBuffer, scanUntilSentinel, lexBuffer.EndOfScan, state, eofPos)
+        else
+            // read a character - end the scan if there are no further transitions 
+            let inp = lexBuffer.Buffer.[lexBuffer.BufferScanPos]
             
-            if lexBuffer.BufferScanLength = lexBuffer.BufferMaxScanLength then 
-                lexBuffer.DiscardInput();
-                lexBuffer.RefillBuffer ();
-              // end of file occurs if we couldn't extend the buffer 
-                afterRefill (trans,sentinel,lexBuffer,scanUntilSentinel,lexBuffer.EndOfScan,state,eofPos)
-            else
-                // read a character - end the scan if there are no further transitions 
-                let inp = lexBuffer.Buffer.[lexBuffer.BufferScanPos]
-                
-                // Find the new state
-                let snew = lookupUnicodeCharacters (state,inp)
+            // Find the new state
+            let snew = lookupUnicodeCharacters (state, inp)
 
-                if snew = sentinel then 
-                    lexBuffer.EndOfScan()
-                else 
-                    lexBuffer.BufferScanLength <- lexBuffer.BufferScanLength + 1;
-                    // Printf.printf "state %d --> %d on '%c' (%d)\n" s snew (char inp) inp;
-                    scanUntilSentinel(lexBuffer,snew)
-                          
-        // Each row for the Unicode table has format 
-        //      128 entries for ASCII characters
-        //      A variable number of 2*UInt16 entries for SpecificUnicodeChars 
-        //      30 entries, one for each UnicodeCategory
-        //      1 entry for EOF
-
-        member tables.Interpret(initialState,lexBuffer : LexBuffer<char>) = 
-            startInterpret(lexBuffer)
-            scanUntilSentinel(lexBuffer, initialState)
-
-        member tables.AsyncInterpret(initialState,lexBuffer : LexBuffer<char>) = 
-
-            let rec scanUntilSentinel(lexBuffer, state) =
-                async {
-                    // Return an endOfScan after consuming the input 
-                    let a = int accept.[state] 
-                    if a <> sentinel then 
-                        onAccept(lexBuffer,a)
+            if snew = sentinel then 
+                lexBuffer.EndOfScan()
+            else 
+                lexBuffer.BufferScanLength <- lexBuffer.BufferScanLength + 1
+                // Printf.printf "state %d --> %d on '%c' (%d)\n" s snew (char inp) inp
+                scanUntilSentinel(lexBuffer, snew)
+                      
+    // Each row for the Unicode table has format 
+    //      128 entries for ASCII characters
+    //      A variable number of 2*UInt16 entries for SpecificUnicodeChars 
+    //      30 entries, one for each UnicodeCategory
+    //      1 entry for EOF
+
+    member tables.Interpret(initialState, lexBuffer : LexBuffer<char>) = 
+        startInterpret(lexBuffer)
+        scanUntilSentinel(lexBuffer, initialState)
+
+    member tables.AsyncInterpret(initialState, lexBuffer : LexBuffer<char>) = 
+
+        let rec scanUntilSentinel(lexBuffer, state) =
+            async {
+                // Return an endOfScan after consuming the input 
+                let a = int accept.[state] 
+                if a <> sentinel then 
+                    onAccept(lexBuffer, a)
+                
+                if lexBuffer.BufferScanLength = lexBuffer.BufferMaxScanLength then 
+                    lexBuffer.DiscardInput()
+                    lexBuffer.RefillBuffer ()
+                    // end of file occurs if we couldn't extend the buffer 
+                    return! afterRefill (trans, sentinel, lexBuffer, scanUntilSentinel, endOfScan, state, eofPos)
+                else
+                    // read a character - end the scan if there are no further transitions 
+                    let inp = lexBuffer.Buffer.[lexBuffer.BufferScanPos]
                     
-                    if lexBuffer.BufferScanLength = lexBuffer.BufferMaxScanLength then 
-                        lexBuffer.DiscardInput();
-                        lexBuffer.RefillBuffer ();
-                        // end of file occurs if we couldn't extend the buffer 
-                        return! afterRefill (trans,sentinel,lexBuffer,scanUntilSentinel,endOfScan,state,eofPos)
-                    else
-                        // read a character - end the scan if there are no further transitions 
-                        let inp = lexBuffer.Buffer.[lexBuffer.BufferScanPos]
-                        
-                        // Find the new state
-                        let snew = lookupUnicodeCharacters (state,inp)
-
-                        if snew = sentinel then 
-                            return! endOfScan()
-                        else 
-                            lexBuffer.BufferScanLength <- lexBuffer.BufferScanLength + 1;
-                            return! scanUntilSentinel(lexBuffer, snew)
-                }
-            and endOfScan() = 
-                async { return lexBuffer.EndOfScan() } 
-            startInterpret(lexBuffer)
-            scanUntilSentinel(lexBuffer, initialState)
-
-        static member Create(trans,accept) = new UnicodeTables(trans,accept)
+                    // Find the new state
+                    let snew = lookupUnicodeCharacters (state, inp)
+
+                    if snew = sentinel then 
+                        return! endOfScan()
+                    else 
+                        lexBuffer.BufferScanLength <- lexBuffer.BufferScanLength + 1
+                        return! scanUntilSentinel(lexBuffer, snew)
+            }
+        and endOfScan() = 
+            async { return lexBuffer.EndOfScan() } 
+        startInterpret(lexBuffer)
+        scanUntilSentinel(lexBuffer, initialState)
+
+    static member Create(trans, accept) = UnicodeTables(trans, accept)
+
+open System.IO
+
+let UnicodeFileAsLexbuf (filename,codePage : int option) : FileStream * StreamReader * LexBuffer<char> =
+    // Use the .NET functionality to auto-detect the unicode encoding
+    // It also presents the bytes read to the lexer in UTF8 decoded form
+    let stream  = new FileStream(filename,FileMode.Open,FileAccess.Read,FileShare.Read)
+    let reader =
+        match codePage with
+        | None -> new  StreamReader(stream,true)
+        | Some n -> new  StreamReader(stream,System.Text.Encoding.GetEncoding(n))
+    let lexbuf = LexBuffer.FromFunction(reader.Read)
+    lexbuf.EndPos <- Position.FirstLine(filename)
+    stream, reader, lexbuf
\ No newline at end of file
diff --git a/buildtools/fsyacc/Lexing.fsi b/buildtools/fsyacc/Lexing.fsi
index e31ad411aa9..866ba6a1e56 100644
--- a/buildtools/fsyacc/Lexing.fsi
+++ b/buildtools/fsyacc/Lexing.fsi
@@ -5,147 +5,160 @@
 // (c) Microsoft Corporation 2005-2008.
 //===========================================================================
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-namespace Internal.Utilities.Text.Lexing
-#else
-namespace Microsoft.FSharp.Text.Lexing 
-#endif
+module FSharp.Text.Lexing
 
 open System.Collections.Generic
 
 /// Position information stored for lexing tokens
-//
-// Note: this is an OCaml compat record type. 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-type internal Position = 
-#else
-type Position = 
-#endif
-    { /// The file name for the position
-      pos_fname: string;
+[<Struct>]
+type Position =
+    { 
+      /// The file name for the position
+      pos_fname: string
+      
       /// The line number for the position
-      pos_lnum: int;
-#if INTERNALIZED_FSLEXYACC_RUNTIME
+      pos_lnum: int
+
       /// The line number for the position in the original source file
-      pos_orig_lnum : int;
-#endif
+      pos_orig_lnum : int
+
       /// The absolute offset of the beginning of the line
-      pos_bol: int;
+      pos_bol: int
+
       /// The absolute offset of the column for the position
-      pos_cnum: int; }
+      pos_cnum: int
+     }
+
      /// The file name associated with the input stream.
      member FileName : string
-     /// The line number in the input stream, assuming fresh positions have been updated 
+
+     /// The line number in the input stream, assuming fresh positions have been updated
      /// using AsNewLinePos() and by modifying the EndPos property of the LexBuffer.
      member Line : int
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-     /// The line number for the position in the input stream, assuming fresh positions have been updated 
+
+     /// The line number for the position in the input stream, assuming fresh positions have been updated
      /// using AsNewLinePos()
      member OriginalLine : int
-#endif
-     [<System.ObsoleteAttribute("Use the AbsoluteOffset property instead")>]
+
+     [<System.Obsolete("Use the AbsoluteOffset property instead")>]
      member Char : int
+
      /// The character number in the input stream
      member AbsoluteOffset : int
+
      /// Return absolute offset of the start of the line marked by the position
      member StartOfLineAbsoluteOffset : int
+
      /// Return the column number marked by the position, i.e. the difference between the AbsoluteOffset and the StartOfLineAbsoluteOffset
      member Column : int
+
      // Given a position just beyond the end of a line, return a position at the start of the next line
-     member NextLine : Position     
-     
+     member NextLine : Position
+
      /// Given a position at the start of a token of length n, return a position just beyond the end of the token
      member EndOfToken: n:int -> Position
+
      /// Gives a position shifted by specified number of characters
      member ShiftColumnBy: by:int -> Position
-     
-     [<System.ObsoleteAttribute("Consider using the NextLine property instead")>]
+
+     [<System.Obsolete("Consider using the NextLine property instead")>]
      member AsNewLinePos : unit -> Position
-     
-     /// Get an arbitrary position, with the empty string as filename, and  
+
+     /// Get an arbitrary position, with the empty string as filename, and
      static member Empty : Position
 
      /// Get a position corresponding to the first line (line number 1) in a given file
      static member FirstLine : filename:string -> Position
-    
+
 [<Sealed>]
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-type internal LexBuffer<'char> =
-#else
 /// Input buffers consumed by lexers generated by <c>fslex.exe </c>
 type LexBuffer<'char> =
-#endif
     /// The start position for the lexeme
     member StartPos: Position with get,set
+
     /// The end position for the lexeme
     member EndPos: Position with get,set
-    /// The matched string 
+
+    /// The matched string
     member Lexeme: 'char array
-    
+
     /// Fast helper to turn the matched characters into a string, avoiding an intermediate array
     static member LexemeString : LexBuffer<char> -> string
-    
-    /// The length of the matched string 
+
+    /// The length of the matched string
     member LexemeLength: int
-    /// Fetch a particular character in the matched string 
+
+    /// Fetch a particular character in the matched string
     member LexemeChar: int -> 'char
 
     /// Dynamically typed, non-lexically scoped parameter table
     member BufferLocalStore : IDictionary<string,obj>
-    
+
     /// True if the refill of the buffer ever failed , or if explicitly set to true.
     member IsPastEndOfStream: bool with get,set
-    /// Remove all input, though don't discard the current lexeme 
+
+    /// Remove all input, though don't discard the current lexeme
     member DiscardInput: unit -> unit
 
     /// Create a lex buffer suitable for byte lexing that reads characters from the given array
     static member FromBytes: byte[] -> LexBuffer<byte>
+
     /// Create a lex buffer suitable for Unicode lexing that reads characters from the given array
     static member FromChars: char[] -> LexBuffer<char>
+
     /// Create a lex buffer suitable for Unicode lexing that reads characters from the given string
     static member FromString: string -> LexBuffer<char>
+
     /// Create a lex buffer that reads character or byte inputs by using the given function
     static member FromFunction: ('char[] * int * int -> int) -> LexBuffer<'char>
+
     /// Create a lex buffer that asynchronously reads character or byte inputs by using the given function
     static member FromAsyncFunction: ('char[] * int * int -> Async<int>) -> LexBuffer<'char>
 
-
     [<System.Obsolete("Use LexBuffer<char>.FromFunction instead")>]
     static member FromCharFunction: (char[] -> int -> int) -> LexBuffer<char>
+
     [<System.Obsolete("Use LexBuffer<byte>.FromFunction instead")>]
     static member FromByteFunction: (byte[] -> int -> int) -> LexBuffer<byte>
 
     /// Create a lex buffer suitable for use with a Unicode lexer that reads character inputs from the given text reader
     static member FromTextReader: System.IO.TextReader -> LexBuffer<char>
+
     /// Create a lex buffer suitable for use with ASCII byte lexing that reads byte inputs from the given binary reader
     static member FromBinaryReader: System.IO.BinaryReader -> LexBuffer<byte>
 
 
-/// The type of tables for an ascii lexer generated by fslex. 
+/// The type of tables for an ascii lexer generated by fslex.
 [<Sealed>]
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-type internal AsciiTables =
-#else
 type AsciiTables =
-#endif
     static member Create : uint16[] array * uint16[] -> AsciiTables
-    /// Interpret tables for an ascii lexer generated by fslex. 
+
+    /// Interpret tables for an ascii lexer generated by fslex.
     member Interpret:  initialState:int * LexBuffer<byte>  -> int
+
+    [<System.Obsolete("Async interretation of lexer tables is now obsolete and will be removed. Please use a background thread if you want async lexing")>]
     /// Interpret tables for an ascii lexer generated by fslex, processing input asynchronously
     member AsyncInterpret:  initialState:int * LexBuffer<byte> -> Async<int>
 
 
-/// The type of tables for an unicode lexer generated by fslex. 
+/// The type of tables for an unicode lexer generated by fslex.
 [<Sealed>]
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-type internal UnicodeTables =
-#else
 type UnicodeTables =
-#endif
+
     static member Create : uint16[] array * uint16[] -> UnicodeTables
-    /// Interpret tables for a unicode lexer generated by fslex. 
+
+    /// Interpret tables for a unicode lexer generated by fslex.
     member Interpret:  initialState:int * LexBuffer<char> -> int
 
+    [<System.Obsolete("Async interretation of lexer tables is now obsolete and will be removed. Please use a background thread if you want async lexing")>]
     /// Interpret tables for a unicode lexer generated by fslex, processing input asynchronously
     member AsyncInterpret:  initialState:int * LexBuffer<char> -> Async<int>
 
+
+/// Standard utility to create a Unicode LexBuffer
+///
+/// One small annoyance is that LexBuffers and not IDisposable. This means
+/// we can't just return the LexBuffer object, since the file it wraps wouldn't
+/// get closed when we're finished with the LexBuffer. Hence we return the stream,
+/// the reader and the LexBuffer. The caller should dispose the first two when done.
+val UnicodeFileAsLexbuf: string * int option -> System.IO.FileStream * System.IO.StreamReader * LexBuffer<char>
\ No newline at end of file
diff --git a/buildtools/fsyacc/Parsing.fs b/buildtools/fsyacc/Parsing.fs
index 01dccfb6101..f66aa7a77f4 100644
--- a/buildtools/fsyacc/Parsing.fs
+++ b/buildtools/fsyacc/Parsing.fs
@@ -1,87 +1,76 @@
 // (c) Microsoft Corporation 2005-2009. 
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
+namespace FSharp.Text.Parsing
+open FSharp.Text.Lexing
 
-namespace  Internal.Utilities.Text.Parsing
-open Internal.Utilities
-open Internal.Utilities.Text.Lexing
-
-#else
-namespace Microsoft.FSharp.Text.Parsing
-open Microsoft.FSharp.Text.Lexing
-#endif
-
-
-
-open System
 open System.Collections.Generic
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-type internal IParseState = 
-#else
 type IParseState = 
-#endif
     abstract InputRange: int -> Position * Position
+
     abstract InputEndPosition: int -> Position 
+
     abstract InputStartPosition: int -> Position 
+
     abstract ResultRange: Position * Position
+
     abstract GetInput: int -> obj 
+
     abstract ParserLocalStore : IDictionary<string,obj>
+
     abstract RaiseError<'b> : unit -> 'b 
 
 //-------------------------------------------------------------------------
 // This context is passed to the error reporter when a syntax error occurs
 
 [<Sealed>]
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-type internal ParseErrorContext<'tok>
-#else
 type ParseErrorContext<'tok>
-#endif
          (//lexbuf: LexBuffer<_>,
           stateStack:int list,
           parseState: IParseState, 
           reduceTokens: int list, 
           currentToken: 'tok option, 
           reducibleProductions: int list list, 
-          shiftableTokens: int list , 
+          shiftableTokens: int list, 
           message : string) =
-      //member x.LexBuffer = lexbuf
-      member x.StateStack  = stateStack
-      member x.ReduceTokens = reduceTokens
-      member x.CurrentToken = currentToken
-      member x.ParseState = parseState
-      member x.ReducibleProductions = reducibleProductions
-      member x.ShiftTokens = shiftableTokens
-      member x.Message = message
+
+      member _.StateStack  = stateStack
+
+      member _.ReduceTokens = reduceTokens
+
+      member _.CurrentToken = currentToken
+
+      member _.ParseState = parseState
+
+      member _.ReducibleProductions = reducibleProductions
+
+      member _.ShiftTokens = shiftableTokens
+
+      member _.Message = message
 
 
 //-------------------------------------------------------------------------
 // This is the data structure emitted as code by FSYACC.  
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-type internal Tables<'tok> = 
-#else
 type Tables<'tok> = 
-#endif
-    { reductions: (IParseState -> obj) array;
-      endOfInputTag: int;
-      tagOfToken: 'tok -> int;
-      dataOfToken: 'tok -> obj; 
-      actionTableElements: uint16[];  
-      actionTableRowOffsets: uint16[];
-      reductionSymbolCounts: uint16[];
-      immediateActions: uint16[];
-      gotos: uint16[];
-      sparseGotoTableRowOffsets: uint16[];
-      stateToProdIdxsTableElements: uint16[];  
-      stateToProdIdxsTableRowOffsets: uint16[];  
-      productionToNonTerminalTable: uint16[];
+    { reductions: (IParseState -> obj)[]
+      endOfInputTag: int
+      tagOfToken: 'tok -> int
+      dataOfToken: 'tok -> obj 
+      actionTableElements: uint16[]  
+      actionTableRowOffsets: uint16[]
+      reductionSymbolCounts: uint16[]
+      immediateActions: uint16[]
+      gotos: uint16[]
+      sparseGotoTableRowOffsets: uint16[]
+      stateToProdIdxsTableElements: uint16[]  
+      stateToProdIdxsTableRowOffsets: uint16[]  
+      productionToNonTerminalTable: uint16[]
       /// For fsyacc.exe, this entry is filled in by context from the generated parser file. If no 'parse_error' function
       /// is defined by the user then ParseHelpers.parse_error is used by default (ParseHelpers is opened
       /// at the top of the generated parser file)
-      parseError:  ParseErrorContext<'tok> -> unit;
-      numTerminals: int;
+      parseError:  ParseErrorContext<'tok> -> unit
+      numTerminals: int
       tagOfErrorTerminal: int }
 
 //-------------------------------------------------------------------------
@@ -90,11 +79,7 @@ type Tables<'tok> =
 // This type is in System.dll so for the moment we can't use it in FSharp.Core.dll
 //type Stack<'a> = System.Collections.Generic.Stack<'a>
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-type Stack<'a>(n)  = 
-#else
 type internal Stack<'a>(n)  = 
-#endif
     let mutable contents = Array.zeroCreate<'a>(n)
     let mutable count = 0
 
@@ -102,16 +87,16 @@ type internal Stack<'a>(n)  =
         let oldSize = Array.length contents
         if newSize > oldSize then 
             let old = contents
-            contents <- Array.zeroCreate (max newSize (oldSize * 2));
-            Array.blit old 0 contents 0 count;
+            contents <- Array.zeroCreate (max newSize (oldSize * 2))
+            Array.blit old 0 contents 0 count
     
     member buf.Count = count
     member buf.Pop() = count <- count - 1
     member buf.Peep() = contents.[count - 1]
     member buf.Top(n) = [ for x in contents.[max 0 (count-n)..count - 1] -> x ] |> List.rev
     member buf.Push(x) =
-        buf.Ensure(count + 1); 
-        contents.[count] <- x; 
+        buf.Ensure(count + 1) 
+        contents.[count] <- x 
         count <- count + 1
         
     member buf.IsEmpty = (count = 0)
@@ -132,11 +117,7 @@ module Flags =
     let mutable debug = false
 #endif
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-module internal Implementation = 
-#else
 module Implementation = 
-#endif
     
     // Definitions shared with fsyacc 
     let anyMarker = 0xffff
@@ -153,7 +134,7 @@ module Implementation =
     // Read the tables written by FSYACC.  
 
     type AssocTable(elemTab:uint16[], offsetTab:uint16[]) =
-        let cache = new Dictionary<_,_>(2000)
+        let cache = Dictionary<_,_>(2000)
 
         member t.readAssoc (minElemNum,maxElemNum,defaultValueOfAssoc,keyToFind) =     
             // do a binary chop on the table 
@@ -164,10 +145,12 @@ module Implementation =
                 let x = int elemTab.[elemNumber*2]
                 if keyToFind = x then 
                     int elemTab.[elemNumber*2+1]
-                elif keyToFind < x then t.readAssoc (minElemNum ,elemNumber,defaultValueOfAssoc,keyToFind)
-                else                    t.readAssoc (elemNumber+1,maxElemNum,defaultValueOfAssoc,keyToFind)
+                elif keyToFind < x then
+                    t.readAssoc (minElemNum,elemNumber,defaultValueOfAssoc,keyToFind)
+                else
+                    t.readAssoc (elemNumber+1,maxElemNum,defaultValueOfAssoc,keyToFind)
 
-        member t.Read(rowNumber ,keyToFind) =
+        member t.Read(rowNumber,keyToFind) =
         
             // First check the sparse lookaside table
             // Performance note: without this lookaside table the binary chop in readAssoc
@@ -191,7 +174,7 @@ module Implementation =
 
         // Read all entries in the association table
         // Used during error recovery to find all valid entries in the table
-        member x.ReadAll(n) =       
+        member _.ReadAll(n) =       
             let headOfTable = int offsetTab.[n]
             let firstElemNumber = headOfTable + 1           
             let numberOfElementsInAssoc = int32 elemTab.[headOfTable*2]           
@@ -202,7 +185,7 @@ module Implementation =
     type IdxToIdxListTable(elemTab:uint16[], offsetTab:uint16[]) =
 
         // Read all entries in a row of the table
-        member x.ReadAll(n) =       
+        member _.ReadAll(n) =       
             let headOfTable = int offsetTab.[n]
             let firstElemNumber = headOfTable + 1           
             let numberOfElements = int32 elemTab.[headOfTable]           
@@ -217,22 +200,31 @@ module Implementation =
         val value: obj
         val startPos: Position
         val endPos: Position
-        new(value,startPos,endPos) = { value=value; startPos=startPos;endPos=endPos }
+
+        new(value,startPos,endPos) = { value=value; startPos=startPos; endPos=endPos }
 
     let interpret (tables: Tables<'tok>) lexer (lexbuf : LexBuffer<_>) initialState =                                                                      
-        let localStore = new Dictionary<string,obj>() in
-        localStore.["LexBuffer"] <- lexbuf;
+        let localStore = Dictionary<string,obj>() in
+        localStore.["LexBuffer"] <- lexbuf
 #if __DEBUG
-        if Flags.debug then System.Console.WriteLine("\nParser: interpret tables");
+        if Flags.debug then System.Console.WriteLine("\nParser: interpret tables")
 #endif
-        let stateStack : Stack<int> = new Stack<_>(100)
-        stateStack.Push(initialState);
-        let valueStack = new Stack<ValueInfo>(100)
+        let stateStack : Stack<int> = Stack<_>(100)
+
+        stateStack.Push(initialState)
+
+        let valueStack = Stack<ValueInfo>(100)
+
         let mutable haveLookahead = false                                                                              
+
         let mutable lookaheadToken = Unchecked.defaultof<'tok>
+
         let mutable lookaheadEndPos = Unchecked.defaultof<Position>
+
         let mutable lookaheadStartPos = Unchecked.defaultof<Position>
+
         let mutable finished = false
+
         // After an error occurs, we suppress errors until we've shifted three tokens in a row.
         let mutable errorSuppressionCountDown = 0
         
@@ -243,27 +235,31 @@ module Implementation =
         // where consuming one EOF to trigger an error doesn't result in overall parse failure 
         // catastrophe and the loss of intermediate results.
         //
+
         let mutable inEofCountDown = false
+
         let mutable eofCountDown = 20 // Number of EOFs to supply at the end for error recovery
+
         // The 100 here means a maximum of 100 elements for each rule
-        let ruleStartPoss = (Array.zeroCreate 100 : Position array)              
-        let ruleEndPoss   = (Array.zeroCreate 100 : Position array)              
-        let ruleValues    = (Array.zeroCreate 100 : obj array)              
-        let lhsPos        = (Array.zeroCreate 2 : Position array)                                            
+        let ruleStartPoss = (Array.zeroCreate 100 : Position[])              
+        let ruleEndPoss   = (Array.zeroCreate 100 : Position[])              
+        let ruleValues    = (Array.zeroCreate 100 : obj[])              
+        let lhsPos        = (Array.zeroCreate 2 : Position[])                                            
+
         let reductions = tables.reductions
-        let actionTable = new AssocTable(tables.actionTableElements, tables.actionTableRowOffsets)
-        let gotoTable = new AssocTable(tables.gotos, tables.sparseGotoTableRowOffsets)
-        let stateToProdIdxsTable = new IdxToIdxListTable(tables.stateToProdIdxsTableElements, tables.stateToProdIdxsTableRowOffsets)
+        let actionTable = AssocTable(tables.actionTableElements, tables.actionTableRowOffsets)
+        let gotoTable = AssocTable(tables.gotos, tables.sparseGotoTableRowOffsets)
+        let stateToProdIdxsTable = IdxToIdxListTable(tables.stateToProdIdxsTableElements, tables.stateToProdIdxsTableRowOffsets)
 
         let parseState =                                                                                            
             { new IParseState with 
-                member p.InputRange(n) = ruleStartPoss.[n-1], ruleEndPoss.[n-1]; 
-                member p.InputStartPosition(n) = ruleStartPoss.[n-1]
-                member p.InputEndPosition(n) = ruleEndPoss.[n-1]; 
-                member p.GetInput(n)    = ruleValues.[n-1];        
-                member p.ResultRange    = (lhsPos.[0], lhsPos.[1]);  
-                member p.ParserLocalStore = (localStore :> IDictionary<_,_>); 
-                member p.RaiseError()  = raise RecoverableParseError  (* NOTE: this binding tests the fairly complex logic associated with an object expression implementing a generic abstract method *)
+                member _.InputRange(n) = ruleStartPoss.[n-1], ruleEndPoss.[n-1] 
+                member _.InputStartPosition(n) = ruleStartPoss.[n-1]
+                member _.InputEndPosition(n) = ruleEndPoss.[n-1] 
+                member _.GetInput(n)    = ruleValues.[n-1]        
+                member _.ResultRange    = (lhsPos.[0], lhsPos.[1])  
+                member _.ParserLocalStore = (localStore :> IDictionary<_,_>) 
+                member _.RaiseError()  = raise RecoverableParseError  (* NOTE: this binding tests the fairly complex logic associated with an object expression implementing a generic abstract method *)
             }       
 
 #if __DEBUG
@@ -275,22 +271,22 @@ module Implementation =
         // Pop the stack until we can shift the 'error' token. If 'tokenOpt' is given
         // then keep popping until we can shift both the 'error' token and the token in 'tokenOpt'.
         // This is used at end-of-file to make sure we can shift both the 'error' token and the 'EOF' token.
-        let rec popStackUntilErrorShifted(tokenOpt) =
+        let rec popStackUntilErrorShifted tokenOpt =
             // Keep popping the stack until the "error" terminal is shifted
 #if __DEBUG
-            if Flags.debug then System.Console.WriteLine("popStackUntilErrorShifted");
+            if Flags.debug then System.Console.WriteLine("popStackUntilErrorShifted")
 #endif
             if stateStack.IsEmpty then 
 #if __DEBUG
                 if Flags.debug then 
-                    System.Console.WriteLine("state stack empty during error recovery - generating parse error");
+                    System.Console.WriteLine("state stack empty during error recovery - generating parse error")
 #endif
-                failwith "parse error";
+                failwith "parse error"
             
             let currState = stateStack.Peep()
 #if __DEBUG
             if Flags.debug then 
-                System.Console.WriteLine("In state {0} during error recovery", currState);
+                System.Console.WriteLine("In state {0} during error recovery", currState)
 #endif
             
             let action = actionTable.Read(currState, tables.tagOfErrorTerminal)
@@ -303,22 +299,22 @@ module Implementation =
                     actionKind (actionTable.Read(nextState, tables.tagOfToken(token))) = shiftFlag) then
 
 #if __DEBUG
-                if Flags.debug then System.Console.WriteLine("shifting error, continuing with error recovery");
+                if Flags.debug then System.Console.WriteLine("shifting error, continuing with error recovery")
 #endif
                 let nextState = actionValue action 
                 // The "error" non terminal needs position information, though it tends to be unreliable.
                 // Use the StartPos/EndPos from the lex buffer
-                valueStack.Push(ValueInfo(box (), lexbuf.StartPos, lexbuf.EndPos));
+                valueStack.Push(ValueInfo(box (), lexbuf.StartPos, lexbuf.EndPos))
                 stateStack.Push(nextState)
             else
                 if valueStack.IsEmpty then 
-                    failwith "parse error";
+                    failwith "parse error"
 #if __DEBUG
                 if Flags.debug then 
-                    System.Console.WriteLine("popping stack during error recovery");
+                    System.Console.WriteLine("popping stack during error recovery")
 #endif
-                valueStack.Pop();
-                stateStack.Pop();
+                valueStack.Pop()
+                stateStack.Pop()
                 popStackUntilErrorShifted(tokenOpt)
 
         while not finished do                                                                                    
@@ -350,7 +346,7 @@ module Implementation =
                                 lookaheadToken <- lexer lexbuf
                                 lookaheadStartPos <- lexbuf.StartPos
                                 lookaheadEndPos <- lexbuf.EndPos
-                                haveLookahead <- true;
+                                haveLookahead <- true
 
                         let tag = 
                             if haveLookahead then tables.tagOfToken lookaheadToken 
@@ -362,17 +358,17 @@ module Implementation =
                 let kind = actionKind action 
                 if kind = shiftFlag then (
                     if errorSuppressionCountDown > 0 then 
-                        errorSuppressionCountDown <- errorSuppressionCountDown - 1;
+                        errorSuppressionCountDown <- errorSuppressionCountDown - 1
 #if __DEBUG
-                        if Flags.debug then Console.WriteLine("shifting, reduced errorRecoverylevel to {0}\n", errorSuppressionCountDown);
+                        if Flags.debug then Console.WriteLine("shifting, reduced errorRecoverylevel to {0}\n", errorSuppressionCountDown)
 #endif
                     let nextState = actionValue action                                     
-                    if not haveLookahead then failwith "shift on end of input!";
+                    if not haveLookahead then failwith "shift on end of input!"
                     let data = tables.dataOfToken lookaheadToken
-                    valueStack.Push(ValueInfo(data, lookaheadStartPos, lookaheadEndPos));
-                    stateStack.Push(nextState);                                                                
+                    valueStack.Push(ValueInfo(data, lookaheadStartPos, lookaheadEndPos))
+                    stateStack.Push(nextState)                                                                
 #if __DEBUG
-                    if Flags.debug then Console.WriteLine("shift/consume input {0}, shift to state {1}", report haveLookahead lookaheadToken, nextState);
+                    if Flags.debug then Console.WriteLine("shift/consume input {0}, shift to state {1}", report haveLookahead lookaheadToken, nextState)
 #endif
                     haveLookahead <- false
 
@@ -382,27 +378,27 @@ module Implementation =
                     let n = int tables.reductionSymbolCounts.[prod]
                        // pop the symbols, populate the values and populate the locations                              
 #if __DEBUG
-                    if Flags.debug then Console.Write("reduce popping {0} values/states, lookahead {1}", n, report haveLookahead lookaheadToken);
+                    if Flags.debug then Console.Write("reduce popping {0} values/states, lookahead {1}", n, report haveLookahead lookaheadToken)
 #endif
                     
-                    lhsPos.[0] <- Position.Empty;                                                                     
-                    lhsPos.[1] <- Position.Empty;  
+                    lhsPos.[0] <- Position.Empty                                                                     
+                    lhsPos.[1] <- Position.Empty  
                     for i = 0 to n - 1 do                                                                             
-                        if valueStack.IsEmpty then failwith "empty symbol stack";
+                        if valueStack.IsEmpty then failwith "empty symbol stack"
                         let topVal = valueStack.Peep()
-                        valueStack.Pop();
-                        stateStack.Pop();
-                        ruleValues.[(n-i)-1] <- topVal.value;  
-                        ruleStartPoss.[(n-i)-1] <- topVal.startPos;  
-                        ruleEndPoss.[(n-i)-1] <- topVal.endPos;  
-                        if lhsPos.[1] = Position.Empty then lhsPos.[1] <- topVal.endPos;
+                        valueStack.Pop()
+                        stateStack.Pop()
+                        ruleValues.[(n-i)-1] <- topVal.value  
+                        ruleStartPoss.[(n-i)-1] <- topVal.startPos  
+                        ruleEndPoss.[(n-i)-1] <- topVal.endPos  
+                        if lhsPos.[1] = Position.Empty then lhsPos.[1] <- topVal.endPos
                         if not (topVal.startPos = Position.Empty) then lhsPos.[0] <- topVal.startPos
-                    done;                                                                                           
+                    done                                                                                           
                     
                     try                                                                                               
-                          // Printf.printf "reduce %d\n" prod;                                                       
+                          // Printf.printf "reduce %d\n" prod                                                       
                         let redResult = reduction parseState                                                          
-                        valueStack.Push(ValueInfo(redResult, lhsPos.[0], lhsPos.[1]));
+                        valueStack.Push(ValueInfo(redResult, lhsPos.[0], lhsPos.[1]))
                         let currState = stateStack.Peep()
                         let newGotoState = gotoTable.Read(int tables.productionToNonTerminalTable.[prod], currState)
                         stateStack.Push(newGotoState)
@@ -411,23 +407,23 @@ module Implementation =
 #endif
                     with                                                                                              
                     | Accept res ->                                                                            
-                          finished <- true;                                                                             
+                          finished <- true                                                                             
                           valueStack.Push(ValueInfo(res, lhsPos.[0], lhsPos.[1])) 
                     | RecoverableParseError ->
 #if __DEBUG
-                          if Flags.debug then Console.WriteLine("RecoverableParseErrorException...\n");
+                          if Flags.debug then Console.WriteLine("RecoverableParseErrorException...\n")
 #endif
-                          popStackUntilErrorShifted(None);
+                          popStackUntilErrorShifted(None)
                           // User code raised a Parse_error. Don't report errors again until three tokens have been shifted 
                           errorSuppressionCountDown <- 3
                 elif kind = errorFlag then (
 #if __DEBUG
-                    if Flags.debug then Console.Write("ErrorFlag... ");
+                    if Flags.debug then Console.Write("ErrorFlag... ")
 #endif
                     // Silently discard inputs and don't report errors 
                     // until three tokens in a row have been shifted 
 #if __DEBUG
-                    if Flags.debug then printfn "error on token '%A' " (if haveLookahead then Some(lookaheadToken) else None);
+                    if Flags.debug then printfn "error on token '%A' " (if haveLookahead then Some(lookaheadToken) else None)
 #endif
                     if errorSuppressionCountDown > 0 then 
                         // If we're in the end-of-file count down then we're very keen to 'Accept'.
@@ -435,16 +431,16 @@ module Implementation =
                         // and an EOF token. 
                         if inEofCountDown && eofCountDown < 10 then 
 #if __DEBUG
-                            if Flags.debug then printfn "poppin stack, lokking to shift both 'error' and that token, during end-of-file error recovery" ;
+                            if Flags.debug then printfn "poppin stack, lokking to shift both 'error' and that token, during end-of-file error recovery" 
 #endif
-                            popStackUntilErrorShifted(if haveLookahead then Some(lookaheadToken) else None);
+                            popStackUntilErrorShifted(if haveLookahead then Some(lookaheadToken) else None)
 
                         // If we don't haveLookahead then the end-of-file count down is over and we have no further options.
                         if not haveLookahead then 
                             failwith "parse error: unexpected end of file"
                             
 #if __DEBUG
-                        if Flags.debug then printfn "discarding token '%A' during error suppression" (if haveLookahead then Some(lookaheadToken) else None);
+                        if Flags.debug then printfn "discarding token '%A' during error suppression" (if haveLookahead then Some(lookaheadToken) else None)
 #endif
                         // Discard the token
                         haveLookahead <- false
@@ -454,10 +450,10 @@ module Implementation =
 
                         let currentToken = if haveLookahead then Some(lookaheadToken) else None
                         let actions,defaultAction = actionTable.ReadAll(state) 
-                        let explicit = Set.ofList [ for (tag,_action) in actions -> tag ]
+                        let explicit = Set.ofList [ for tag,_action in actions -> tag ]
                         
                         let shiftableTokens = 
-                           [ for (tag,action) in actions do
+                           [ for tag,action in actions do
                                  if (actionKind action) = shiftFlag then 
                                      yield tag
                              if actionKind defaultAction = shiftFlag  then
@@ -471,7 +467,7 @@ module Implementation =
                                yield stateToProdIdxsTable.ReadAll(state)  ]
 
                         let reduceTokens = 
-                           [ for (tag,action) in actions do
+                           [ for tag,action in actions do
                                 if actionKind(action) = reduceFlag then
                                     yield tag
                              if actionKind(defaultAction) = reduceFlag  then
@@ -480,35 +476,27 @@ module Implementation =
                                          yield tag ] in
                         //let activeRules = stateStack |> List.iter (fun state -> 
                         let errorContext = new ParseErrorContext<'tok>(stateStack,parseState, reduceTokens,currentToken,reducibleProductions, shiftableTokens, "syntax error")
-                        tables.parseError(errorContext);
-                        popStackUntilErrorShifted(None);
-                        errorSuppressionCountDown <- 3;
+                        tables.parseError(errorContext)
+                        popStackUntilErrorShifted(None)
+                        errorSuppressionCountDown <- 3
 #if __DEBUG
-                        if Flags.debug then System.Console.WriteLine("generated syntax error and shifted error token, haveLookahead = {0}\n", haveLookahead);
+                        if Flags.debug then System.Console.WriteLine("generated syntax error and shifted error token, haveLookahead = {0}\n", haveLookahead)
 #endif
                     )
                 ) elif kind = acceptFlag then 
                     finished <- true
 #if __DEBUG
                 else
-                  if Flags.debug then System.Console.WriteLine("ALARM!!! drop through case in parser");  
+                  if Flags.debug then System.Console.WriteLine("ALARM!!! drop through case in parser")  
 #endif
-        done;                                                                                                     
+        done                                                                                                     
         // OK, we're done - read off the overall generated value
         valueStack.Peep().value
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-type internal Tables<'tok> with
-#else
 type Tables<'tok> with
-#endif
-    member tables.Interpret (lexer,lexbuf,initialState) = 
-        Implementation.interpret tables lexer lexbuf initialState
+    member tables.Interpret (lexer,lexbuf,startState) = 
+        Implementation.interpret tables lexer lexbuf startState
     
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-module internal ParseHelpers = 
-#else
 module ParseHelpers = 
-#endif
     let parse_error (_s:string) = ()
     let parse_error_rich = (None : (ParseErrorContext<_> -> unit) option)
diff --git a/buildtools/fsyacc/Parsing.fsi b/buildtools/fsyacc/Parsing.fsi
index f4d12606462..e4e7329441a 100644
--- a/buildtools/fsyacc/Parsing.fsi
+++ b/buildtools/fsyacc/Parsing.fsi
@@ -2,129 +2,132 @@
 // (c) Microsoft Corporation 2005-2009.
 //=========================================================================
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-namespace Internal.Utilities.Text.Parsing
-open Internal.Utilities
-open Internal.Utilities.Text.Lexing
-#else
-namespace Microsoft.FSharp.Text.Parsing
-open Microsoft.FSharp.Text.Lexing
-#endif
+namespace FSharp.Text.Parsing
+open FSharp.Text.Lexing
 
 open System.Collections.Generic
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-type internal IParseState = 
-#else
 /// The information accessible via the <c>parseState</c> value within parser actions.
 type IParseState = 
-#endif
     /// Get the start and end position for the terminal or non-terminal at a given index matched by the production
     abstract InputRange: index:int -> Position * Position
+
     /// Get the end position for the terminal or non-terminal at a given index matched by the production
     abstract InputEndPosition: int -> Position 
+
     /// Get the start position for the terminal or non-terminal at a given index matched by the production
     abstract InputStartPosition: int -> Position 
+
     /// Get the full range of positions matched by the production
     abstract ResultRange: Position * Position
+
     /// Get the value produced by the terminal or non-terminal at the given position
     abstract GetInput   : int -> obj 
+
     /// Get the store of local values associated with this parser
     // Dynamically typed, non-lexically scoped local store
     abstract ParserLocalStore : IDictionary<string,obj>
+
     /// Raise an error in this parse context
     abstract RaiseError<'b> : unit -> 'b 
 
 
 [<Sealed>]
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-type internal ParseErrorContext<'tok> =
-#else
 /// The context provided when a parse error occurs
 type ParseErrorContext<'tok> =
-#endif
       /// The stack of state indexes active at the parse error 
       member StateStack  : int list
+
       /// The state active at the parse error 
       member ParseState : IParseState
+
       /// The tokens that would cause a reduction at the parse error 
       member ReduceTokens: int list
+
       /// The stack of productions that would be reduced at the parse error 
       member ReducibleProductions : int list list
+
       /// The token that caused the parse error
       member CurrentToken : 'tok option
+
       /// The token that would cause a shift at the parse error
       member ShiftTokens : int list
+
       /// The message associated with the parse error
       member Message : string
 
 /// Tables generated by fsyacc
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-type internal Tables<'tok> = 
-#else
 /// The type of the tables contained in a file produced by the fsyacc.exe parser generator.
 type Tables<'tok> = 
-#endif
-    { /// The reduction table
+    { 
+      /// The reduction table
       reductions: (IParseState -> obj) array ;
+      
       /// The token number indicating the end of input
       endOfInputTag: int;
+      
       /// A function to compute the tag of a token
       tagOfToken: 'tok -> int;
+      
       /// A function to compute the data carried by a token
       dataOfToken: 'tok -> obj; 
+      
       /// The sparse action table elements
       actionTableElements: uint16[];
+      
       /// The sparse action table row offsets
       actionTableRowOffsets: uint16[];
+      
       /// The number of symbols for each reduction
       reductionSymbolCounts: uint16[];
+      
       /// The immediate action table
       immediateActions: uint16[];      
+      
       /// The sparse goto table
       gotos: uint16[];
+      
       /// The sparse goto table row offsets
       sparseGotoTableRowOffsets: uint16[];
+      
       /// The sparse table for the productions active for each state
       stateToProdIdxsTableElements: uint16[];  
+      
       /// The sparse table offsets for the productions active for each state
       stateToProdIdxsTableRowOffsets: uint16[];  
+      
       /// This table is logically part of the Goto table
       productionToNonTerminalTable: uint16[];
+      
       /// This function is used to hold the user specified "parse_error" or "parse_error_rich" functions
       parseError:  ParseErrorContext<'tok> -> unit;
+      
       /// The total number of terminals 
       numTerminals: int;
+      
       /// The tag of the error terminal
-      tagOfErrorTerminal: int }
+      tagOfErrorTerminal: int 
+    }
 
     /// Interpret the parser table taking input from the given lexer, using the given lex buffer, and the given start state.
     /// Returns an object indicating the final synthesized value for the parse.
-    member Interpret :  lexer:(LexBuffer<'char> -> 'tok) * lexbuf:LexBuffer<'char> * initialState:int -> obj 
+    member Interpret :  lexer:(LexBuffer<'char> -> 'tok) * lexbuf:LexBuffer<'char> * startState:int -> obj 
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-exception internal Accept of obj
-exception internal RecoverableParseError
-#else
 /// Indicates an accept action has occured
 exception Accept of obj
 /// Indicates a parse error has occured and parse recovery is in progress
 exception RecoverableParseError
-#endif
 
 #if __DEBUG
 module internal Flags =
   val mutable debug : bool
 #endif
 
-#if INTERNALIZED_FSLEXYACC_RUNTIME
-module internal ParseHelpers = 
-#else
 /// Helpers used by generated parsers.
 module ParseHelpers = 
-#endif
    /// The default implementation of the parse_error_rich function
    val parse_error_rich: (ParseErrorContext<'tok> -> unit) option
+   
    /// The default implementation of the parse_error function
    val parse_error: string -> unit
 
diff --git a/buildtools/fsyacc/fsyacc.fs b/buildtools/fsyacc/fsyacc.fs
index 41d816794d9..057ac708dfe 100644
--- a/buildtools/fsyacc/fsyacc.fs
+++ b/buildtools/fsyacc/fsyacc.fs
@@ -1,531 +1,88 @@
 (* (c) Microsoft Corporation 2005-2008.  *)
 
-module internal FsLexYacc.FsYacc.Driver 
+module FsLexYacc.FsYacc.Program
 
-open System.IO 
-open System.Collections.Generic
 open Printf
-open Internal.Utilities
-open Internal.Utilities.Text.Lexing
-
-open FsLexYacc.FsYacc
+open FSharp.Text
 open FsLexYacc.FsYacc.AST
-
-//------------------------------------------------------------------
-// This code is duplicated from Microsoft.FSharp.Compiler.UnicodeLexing
-
-type Lexbuf =  LexBuffer<char>
-
-/// Standard utility to create a Unicode LexBuffer
-///
-/// One small annoyance is that LexBuffers and not IDisposable. This means 
-/// we can't just return the LexBuffer object, since the file it wraps wouldn't
-/// get closed when we're finished with the LexBuffer. Hence we return the stream,
-/// the reader and the LexBuffer. The caller should dispose the first two when done.
-let UnicodeFileAsLexbuf (filename,codePage : int option) : FileStream * StreamReader * Lexbuf =
-    // Use the .NET functionality to auto-detect the unicode encoding
-    // It also uses Lexing.from_text_reader to present the bytes read to the lexer in UTF8 decoded form
-    let stream  = new FileStream(filename,FileMode.Open,FileAccess.Read,FileShare.Read) 
-    let reader = 
-        match codePage with 
-        | None -> new  StreamReader(stream,true)
-        | Some n -> new  StreamReader(stream,System.Text.Encoding.GetEncoding(n)) 
-    let lexbuf = LexBuffer<char>.FromFunction(reader.Read) 
-    lexbuf.EndPos <- Position.FirstLine(filename);
-    stream, reader, lexbuf
+open FsLexYacc.FsYacc.Driver
 
 //------------------------------------------------------------------
 // This is the program proper
 
-let input = ref None
-let modname= ref None
-let internal_module = ref false
-let opens= ref []
-let out = ref None
-let tokenize = ref false
-let compat = ref false
-let log = ref false
-let light = ref None
-let inputCodePage = ref None
+let mutable input = None
+let mutable modname = None
+let mutable internal_module = false
+let mutable opens = []
+let mutable out = None
+let mutable tokenize = false
+let mutable compat = false
+let mutable log = false
+let mutable light = None
+let mutable inputCodePage = None
 let mutable lexlib = "FSharp.Text.Lexing"
 let mutable parslib = "FSharp.Text.Parsing"
 
 let usage =
-  [ ArgInfo("-o", ArgType.String (fun s -> out := Some s), "Name the output file.");
-    ArgInfo("-v", ArgType.Unit (fun () -> log := true), "Produce a listing file."); 
-    ArgInfo("--module", ArgType.String (fun s -> modname := Some s), "Define the F# module name to host the generated parser."); 
-    ArgInfo("--internal", ArgType.Unit (fun () -> internal_module := true), "Generate an internal module");
-    ArgInfo("--open", ArgType.String (fun s -> opens := !opens @ [s]), "Add the given module to the list of those to open in both the generated signature and implementation."); 
-    ArgInfo("--light", ArgType.Unit (fun () ->  light := Some true), "(ignored)");
-    ArgInfo("--light-off", ArgType.Unit (fun () ->  light := Some false), "Add #light \"off\" to the top of the generated file");
-    ArgInfo("--ml-compatibility", ArgType.Set compat, "Support the use of the global state from the 'Parsing' module in FSharp.PowerPack.dll."); 
-    ArgInfo("--tokens", ArgType.Set tokenize, "Simply tokenize the specification file itself."); 
+  [ ArgInfo("-o", ArgType.String (fun s -> out <- Some s), "Name the output file.");
+    ArgInfo("-v", ArgType.Unit (fun () -> log <- true), "Produce a listing file."); 
+    ArgInfo("--module", ArgType.String (fun s -> modname <- Some s), "Define the F# module name to host the generated parser."); 
+    ArgInfo("--internal", ArgType.Unit (fun () -> internal_module <- true), "Generate an internal module");
+    ArgInfo("--open", ArgType.String (fun s -> opens <- opens @ [s]), "Add the given module to the list of those to open in both the generated signature and implementation."); 
+    ArgInfo("--light", ArgType.Unit (fun () ->  light <- Some true), "(ignored)");
+    ArgInfo("--light-off", ArgType.Unit (fun () ->  light <- Some false), "Add #light \"off\" to the top of the generated file");
+    ArgInfo("--ml-compatibility", ArgType.Unit (fun _ -> compat <- true), "Support the use of the global state from the 'Parsing' module in FSharp.PowerPack.dll."); 
+    ArgInfo("--tokens", ArgType.Unit (fun _ -> tokenize <- true), "Simply tokenize the specification file itself."); 
     ArgInfo("--lexlib", ArgType.String (fun s ->  lexlib <- s), "Specify the namespace for the implementation of the lexer (default: FSharp.Text.Lexing)");
     ArgInfo("--parslib", ArgType.String (fun s ->  parslib <- s), "Specify the namespace for the implementation of the parser table interpreter (default: FSharp.Text.Parsing)");
-    ArgInfo("--codepage", ArgType.Int (fun i -> inputCodePage := Some i), "Assume input lexer specification file is encoded with the given codepage.");  ]
-
-let _ = ArgParser.Parse(usage,(fun x -> match !input with Some _ -> failwith "more than one input given" | None -> input := Some x),"fsyacc <filename>")
-
-let output_int (os: #TextWriter) (n:int) = os.Write(string n)
+    ArgInfo("--codepage", ArgType.Int (fun i -> inputCodePage <- Some i), "Assume input lexer specification file is encoded with the given codepage.");  ]
 
-let outputCodedUInt16 (os: #TextWriter)  (n:int) = 
-  os.Write n;
-  os.Write "us; ";
-
-let shiftFlag = 0x0000
-let reduceFlag = 0x4000
-let errorFlag = 0x8000
-let acceptFlag = 0xc000
-let actionMask = 0xc000
-
-let anyMarker = 0xffff
-
-let actionCoding action  =
-  match action with 
-  | Accept -> acceptFlag
-  | Shift n -> shiftFlag ||| n
-  | Reduce n -> reduceFlag ||| n
-  | Error -> errorFlag 
+let _ = ArgParser.Parse(usage,(fun x -> match input with Some _ -> failwith "more than one input given" | None -> input <- Some x),"fsyacc <filename>")
 
 let main() = 
-  let filename = (match !input with Some x -> x | None -> failwith "no input given") in 
+  let filename = (match input with Some x -> x | None -> failwith "no input given") in 
+  if tokenize then printTokens filename inputCodePage
+  
   let spec = 
-      let stream,reader,lexbuf = UnicodeFileAsLexbuf(filename, !inputCodePage) 
-      use stream = stream
-      use reader = reader
-
-      try 
-        if !tokenize then begin 
-          while true do 
-            printf "tokenize - getting one token";
-            let t = Lexer.token lexbuf in 
-            (*F# printf "tokenize - got %s" (Parser.token_to_string t); F#*)
-            if t = Parser.EOF then exit 0;
-          done;
-        end;
-    
-        Parser.spec Lexer.token lexbuf 
-      with e -> 
-         eprintf "%s(%d,%d): error: %s" filename lexbuf.StartPos.Line lexbuf.StartPos.Column e.Message;
-         exit 1  in
-
-  let has_extension (s:string) = 
-    (s.Length >= 1 && s.[s.Length - 1] = '.') 
-    || Path.HasExtension(s)
-
-  let chop_extension (s:string) =
-    if not (has_extension s) then invalidArg "s" "the file name does not have an extension"
-    Path.Combine (Path.GetDirectoryName s,Path.GetFileNameWithoutExtension(s)) 
+    match readSpecFromFile filename inputCodePage with
+    | Ok spec -> spec
+    | Result.Error (e, line, col) -> 
+        eprintf "%s(%d,%d): error: %s" filename line col e.Message
+        exit 1
   
-  let checkSuffix (x:string) (y:string) = x.EndsWith(y)
-
-  let output = match !out with Some x -> x | _ -> chop_extension filename + (if checkSuffix filename ".mly" then ".ml" else ".fs") in
-  let outputi = match !out with Some x -> chop_extension x + (if checkSuffix x ".ml" then ".mli" else ".fsi") | _ -> chop_extension filename + (if checkSuffix filename ".mly" then ".mli" else ".fsi") in
-  let outputo = 
-      if !log then Some (match !out with Some x -> chop_extension x + ".fsyacc.output" | _ -> chop_extension filename + ".fsyacc.output") 
-      else None 
-
-  use os = (File.CreateText output :> TextWriter)
-  use osi = (File.CreateText outputi :> TextWriter)
-
-  let lineCountOutput = ref 0
-  let lineCountSignature = ref 0
-  let cos = (os,lineCountOutput)
-  let cosi = (osi,lineCountSignature)
-  let cprintf (os:TextWriter,lineCount) fmt = Printf.fprintf os fmt
-  let cprintfn (os:TextWriter,lineCount) fmt = Printf.kfprintf (fun () -> incr lineCount; os.WriteLine()) os fmt
-
-  let logf = 
-      match outputo with 
-      | None -> (fun f -> ())
-      | Some filename -> 
-          let oso = (File.CreateText filename :> TextWriter) 
-          (fun f -> f oso) 
-
-  logf (fun oso -> fprintfn oso "        Output file describing compiled parser placed in %s and %s" output outputi);
-
-  printfn "        building tables"; 
-  let spec1 = ProcessParserSpecAst spec 
-  let (prods,states, startStates,actionTable,immediateActionTable,gotoTable,endOfInputTerminalIdx,errorTerminalIdx,nonTerminals) = 
-      CompilerLalrParserSpec logf spec1 
-
-  let (code,pos) = spec.Header 
-  printfn "        %d states" states.Length; 
-  printfn "        %d nonterminals" gotoTable.[0].Length; 
-  printfn "        %d terminals" actionTable.[0].Length; 
-  printfn "        %d productions" prods.Length; 
-  printfn "        #rows in action table: %d" actionTable.Length; 
+  use logger = match logFileName(filename, out, log) with
+               | Some outputLogName -> new FileLogger(outputLogName) :> Logger
+               | None -> new NullLogger() :> Logger
+  let compiledSpec = compileSpec spec logger
+  printfn "        building tables"
+  printfn "        %d states" compiledSpec.states.Length; 
+  printfn "        %d nonterminals" compiledSpec.gotoTable.[0].Length; 
+  printfn "        %d terminals" compiledSpec.actionTable.[0].Length; 
+  printfn "        %d productions" compiledSpec.prods.Length; 
+  printfn "        #rows in action table: %d" compiledSpec.actionTable.Length; 
 (*
   printfn "#unique rows in action table: %d" (List.length (Array.foldBack (fun row acc -> insert (Array.to_list row) acc) actionTable [])); 
   printfn "maximum #different actions per state: %d" (Array.foldBack (fun row acc ->max (List.length (List.foldBack insert (Array.to_list row) [])) acc) actionTable 0); 
   printfn "average #different actions per state: %d" ((Array.foldBack (fun row acc -> (List.length (List.foldBack insert (Array.to_list row) [])) + acc) actionTable 0) / (Array.length states)); 
 *)
-
-  cprintfn cos "// Implementation file for parser generated by fsyacc";
-  cprintfn cosi "// Signature file for parser generated by fsyacc";
-
-  if (!light = Some(false)) || (!light = None && checkSuffix output ".ml") then
-      cprintfn cos "#light \"off\"";
-      cprintfn cosi "#light \"off\"";
-
-  match !modname with 
-  | None -> ()
-  | Some s -> 
-      match !internal_module with
-      | true ->
-          cprintfn cos "module internal %s" s;
-          cprintfn cosi "module internal %s" s;
-      | false ->
-          cprintfn cos "module %s" s;
-          cprintfn cosi "module %s" s;
-  
-  cprintfn cos "#nowarn \"64\";; // turn off warnings that type variables used in production annotations are instantiated to concrete type";
-
-  for s in !opens do
-      cprintfn cos "open %s" s;
-      cprintfn cosi "open %s" s;
-
-  cprintfn cos "open %s" lexlib;
-  cprintfn cos "open %s.ParseHelpers" parslib;
-  if !compat then 
-      cprintfn cos "open Microsoft.FSharp.Compatibility.OCaml.Parsing";
-
-  cprintfn cos "# %d \"%s\"" pos.pos_lnum pos.pos_fname;
-  cprintfn cos "%s" code;
-  lineCountOutput := !lineCountOutput + code.Replace("\r","").Split([| '\n' |]).Length;
-
-  cprintfn cos "# %d \"%s\"" !lineCountOutput output;
-  // Print the datatype for the tokens
-  cprintfn cos "// This type is the type of tokens accepted by the parser";
-  for out in [cos;cosi] do
-      cprintfn out "type token = ";
-      for id,typ in spec.Tokens do 
-          match typ with
-          | None -> cprintfn out "  | %s" id
-          | Some ty -> cprintfn out "  | %s of (%s)" id ty; 
-
-  // Print the datatype for the token names
-  cprintfn cos "// This type is used to give symbolic names to token indexes, useful for error messages";
-  for out in [cos;cosi] do
-      cprintfn out "type tokenId = ";
-      for id,typ in spec.Tokens do 
-          cprintfn out "    | TOKEN_%s" id;
-      cprintfn out "    | TOKEN_end_of_input";
-      cprintfn out "    | TOKEN_error";
-
-  cprintfn cos "// This type is used to give symbolic names to token indexes, useful for error messages";
-  for out in [cos;cosi] do
-      cprintfn out "type nonTerminalId = ";
-      for nt in nonTerminals do 
-          cprintfn out "    | NONTERM_%s" nt;
-
-  cprintfn cos "";
-  cprintfn cos "// This function maps tokens to integer indexes";
-  cprintfn cos "let tagOfToken (t:token) = ";
-  cprintfn cos "  match t with";
-  spec.Tokens |> List.iteri (fun i (id,typ) -> 
-      cprintfn cos "  | %s %s -> %d " id (match typ with Some _ -> "_" | None -> "") i);
-  cprintfn cosi "/// This function maps tokens to integer indexes";
-  cprintfn cosi "val tagOfToken: token -> int";
-
-  cprintfn cos "";
-  cprintfn cos "// This function maps integer indexes to symbolic token ids";
-  cprintfn cos "let tokenTagToTokenId (tokenIdx:int) = ";
-  cprintfn cos "  match tokenIdx with";
-  spec.Tokens |> List.iteri (fun i (id,typ) -> 
-      cprintfn cos "  | %d -> TOKEN_%s " i id)
-  cprintfn cos "  | %d -> TOKEN_end_of_input" endOfInputTerminalIdx;
-  cprintfn cos "  | %d -> TOKEN_error" errorTerminalIdx;
-  cprintfn cos "  | _ -> failwith \"tokenTagToTokenId: bad token\""
-
-  cprintfn cosi "";
-  cprintfn cosi "/// This function maps integer indexes to symbolic token ids";
-  cprintfn cosi "val tokenTagToTokenId: int -> tokenId";
-
-  cprintfn cos "";
-  cprintfn cos "/// This function maps production indexes returned in syntax errors to strings representing the non terminal that would be produced by that production";
-  cprintfn cos "let prodIdxToNonTerminal (prodIdx:int) = ";
-  cprintfn cos "  match prodIdx with";
-  prods |> Array.iteri (fun i (nt,ntIdx,syms,code) -> 
-      cprintfn cos "    | %d -> NONTERM_%s " i nt);
-  cprintfn cos "    | _ -> failwith \"prodIdxToNonTerminal: bad production index\""
-
-  cprintfn cosi "";
-  cprintfn cosi "/// This function maps production indexes returned in syntax errors to strings representing the non terminal that would be produced by that production";
-  cprintfn cosi "val prodIdxToNonTerminal: int -> nonTerminalId";
-
-  cprintfn cos "";
-  cprintfn cos "let _fsyacc_endOfInputTag = %d " endOfInputTerminalIdx;
-  cprintfn cos "let _fsyacc_tagOfErrorTerminal = %d" errorTerminalIdx;
-  cprintfn cos "";
-  cprintfn cos "// This function gets the name of a token as a string";
-  cprintfn cos "let token_to_string (t:token) = ";
-  cprintfn cos "  match t with ";
-  spec.Tokens |> List.iteri (fun i (id,typ) -> 
-      cprintfn cos "  | %s %s -> \"%s\" " id (match typ with Some _ -> "_" | None -> "") id);
-
-  cprintfn cosi "";
-  cprintfn cosi "/// This function gets the name of a token as a string";
-  cprintfn cosi "val token_to_string: token -> string";
-
-  cprintfn cos "";
-  cprintfn cos "// This function gets the data carried by a token as an object";
-  cprintfn cos "let _fsyacc_dataOfToken (t:token) = ";
-  cprintfn cos "  match t with ";
-
-  for (id,typ) in spec.Tokens do
-      cprintfn cos "  | %s %s -> %s " 
-        id
-        (match typ with Some _ -> "_fsyacc_x" | None -> "")
-        (match typ with Some _ -> "Microsoft.FSharp.Core.Operators.box _fsyacc_x" | None -> "(null : System.Object)")
-
-  let tychar = "'cty" 
-
-  for (key,_) in spec.Types |> Seq.countBy fst |> Seq.filter (fun (_,n) -> n > 1)  do
-        failwithf "%s is given multiple %%type declarations" key;
-    
-  for (key,_) in spec.Tokens |> Seq.countBy fst |> Seq.filter (fun (_,n) -> n > 1)  do
-        failwithf "%s is given %%token declarations" key
-    
-  let types = Map.ofList spec.Types 
-  let tokens = Map.ofList spec.Tokens 
   
-  let nStates = states.Length 
-  begin 
-      cprintf cos "let _fsyacc_gotos = [| " ;
-      let numGotoNonTerminals = gotoTable.[0].Length 
-      let gotoIndexes = Array.create numGotoNonTerminals 0 
-      let gotoTableCurrIndex = ref 0 in 
-      for j = 0 to numGotoNonTerminals-1 do  
-          gotoIndexes.[j] <- !gotoTableCurrIndex;
-
-          (* Count the number of entries in the association table. *)
-          let count = ref 0 in 
-          for i = 0 to nStates - 1 do 
-            let goto = gotoTable.[i].[j] 
-            match goto with 
-            | None -> ()
-            | Some _ -> incr count
-   
-          (* Write the head of the table (i.e. the number of entries and the default value) *)
-          gotoTableCurrIndex := !gotoTableCurrIndex + 1;
-          outputCodedUInt16 os !count;
-          outputCodedUInt16 os anyMarker;
-          
-          (* Write the pairs of entries in incremental order by key *)
-          (* This lets us implement the lookup by a binary chop. *)
-          for i = 0 to nStates - 1 do 
-            let goto = gotoTable.[i].[j] 
-            match goto with 
-            | None -> ()
-            | Some n -> 
-                gotoTableCurrIndex := !gotoTableCurrIndex + 1;
-                outputCodedUInt16 os i;
-                outputCodedUInt16 os n;
-      cprintfn cos "|]" ;
-      (* Output offsets into gotos table where the gotos for a particular nonterminal begin *)
-      cprintf cos "let _fsyacc_sparseGotoTableRowOffsets = [|" ;
-      for j = 0 to numGotoNonTerminals-1 do  
-          outputCodedUInt16 os gotoIndexes.[j];
-      cprintfn cos "|]" ;
-  end;
-
-  begin 
-      cprintf cos "let _fsyacc_stateToProdIdxsTableElements = [| " ;
-      let indexes = Array.create states.Length 0 
-      let currIndex = ref 0 
-      for j = 0 to states.Length - 1 do
-          let state = states.[j]
-          indexes.[j] <- !currIndex;
-
-          (* Write the head of the table (i.e. the number of entries) *)
-          outputCodedUInt16 os state.Length;
-          currIndex := !currIndex + state.Length + 1;
-          
-          (* Write the pairs of entries in incremental order by key *)
-          (* This lets us implement the lookup by a binary chop. *)
-          for prodIdx in state do
-                outputCodedUInt16 os prodIdx;
-      cprintfn cos "|]" ;
-      (* Output offsets into gotos table where the gotos for a particular nonterminal begin *)
-      cprintf cos "let _fsyacc_stateToProdIdxsTableRowOffsets = [|" ;
-      for idx in indexes do 
-          outputCodedUInt16 os idx;
-      cprintfn cos "|]" ;
-  end;
-
-  begin 
-    let numActionRows = (Array.length actionTable) 
-    let maxActionColumns = Array.length actionTable.[0] 
-    cprintfn cos "let _fsyacc_action_rows = %d" numActionRows;
-    cprintf cos "let _fsyacc_actionTableElements = [|" ;
-    let actionIndexes = Array.create numActionRows 0 
-    
-    let actionTableCurrIndex = ref 0 
-    for i = 0 to nStates-1 do 
-        actionIndexes.[i] <- !actionTableCurrIndex;
-        let actions = actionTable.[i] 
-        let terminalsByAction = new Dictionary<_,int list>(10) 
-        let countPerAction = new Dictionary<_,_>(10) 
-        for terminal = 0 to actions.Length - 1 do  
-              let action = snd actions.[terminal] 
-              if terminalsByAction.ContainsKey action then 
-                  terminalsByAction.[action] <- terminal :: terminalsByAction.[action] ;
-              else
-                  terminalsByAction.[action] <- [terminal];
-              if countPerAction.ContainsKey action then 
-                countPerAction.[action] <- countPerAction.[action]+1
-              else 
-                countPerAction.[action] <- 1
-
-        let mostCommonAction = 
-            let mostCommon = ref Error 
-            let max = ref 0 
-            for (KeyValue(x,y)) in countPerAction do 
-                if y > !max then (mostCommon := x; max := y)
-            !mostCommon 
-
-        (* Count the number of entries in the association table. *)
-        let count = ref 0 
-        for (KeyValue(action,terminals)) in terminalsByAction do 
-            for terminals  in terminals do 
-               if action <> mostCommonAction then  
-                   incr count;
-        
-        (* Write the head of the table (i.e. the number of entries and the default value) *)
-        actionTableCurrIndex := !actionTableCurrIndex + 1;
-        outputCodedUInt16 os !count;
-        outputCodedUInt16 os (actionCoding mostCommonAction);
-        
-        (* Write the pairs of entries in incremental order by key *)
-        (* This lets us implement the lookup by a binary chop. *)
-        for terminal = 0 to Array.length actions-1 do  
-            let action = snd actions.[terminal] in 
-            if action <> mostCommonAction then  (
-                actionTableCurrIndex := !actionTableCurrIndex + 1;
-                outputCodedUInt16 os terminal;
-                outputCodedUInt16 os (actionCoding action);
-            );
-    cprintfn cos "|]" ;
-    (* Output offsets into actions table where the actions for a particular nonterminal begin *)
-    cprintf cos "let _fsyacc_actionTableRowOffsets = [|" ;
-    for j = 0 to numActionRows-1 do  
-        cprintf cos "%a" outputCodedUInt16 actionIndexes.[j];
-    cprintfn cos "|]" ;
-
-  end;
-  begin 
-      cprintf cos "let _fsyacc_reductionSymbolCounts = [|" ;
-      for nt,ntIdx,syms,code in prods do 
-          cprintf cos "%a" outputCodedUInt16 (List.length syms);
-      cprintfn cos "|]" ;
-  end;
-  begin 
-      cprintf cos "let _fsyacc_productionToNonTerminalTable = [|" ;
-      for nt,ntIdx,syms,code in prods do 
-          cprintf cos "%a" outputCodedUInt16 ntIdx;
-      cprintfn cos "|]" ;
-  end;
-  begin 
-      cprintf cos "let _fsyacc_immediateActions = [|" ;
-      for prodIdx in immediateActionTable do 
-          match prodIdx with
-            | None     -> cprintf cos "%a" outputCodedUInt16 anyMarker (* NONE REP *)
-            | Some act -> cprintf cos "%a" outputCodedUInt16 (actionCoding act)
-      cprintfn cos "|]" ;
-  end;
-  
-  let getType nt = if types.ContainsKey nt then  types.[nt] else "'"+nt 
-  begin 
-      cprintf cos "let _fsyacc_reductions ()  =" ;
-      cprintfn cos "    [| " ;
-      for nt,ntIdx,syms,code in prods do 
-          cprintfn cos "# %d \"%s\"" !lineCountOutput output;
-          cprintfn cos "        (fun (parseState : %s.IParseState) ->"  parslib
-          if !compat then 
-              cprintfn cos "            Parsing.set_parse_state parseState;"
-          syms |> List.iteri (fun i sym -> 
-              let tyopt = 
-                  match sym with
-                  | Terminal t -> 
-                      if tokens.ContainsKey t then 
-                        tokens.[t]
-                      else None
-                  | NonTerminal nt -> Some (getType nt) 
-              match tyopt with 
-              | Some ty -> cprintfn cos "            let _%d = (let data = parseState.GetInput(%d) in (Microsoft.FSharp.Core.Operators.unbox data : %s)) in" (i+1) (i+1) ty
-              | None -> ())
-          cprintfn cos "            Microsoft.FSharp.Core.Operators.box" 
-          cprintfn cos "                (";
-          cprintfn cos "                   (";
-          match code with 
-          | Some (_,pos) -> cprintfn cos "# %d \"%s\"" pos.pos_lnum pos.pos_fname
-          | None -> ()
-          match code with 
-          | Some (code,_) -> 
-              let dollar = ref false in 
-              let c = code |> String.collect (fun c -> 
-                  if not !dollar && c = '$' then (dollar := true; "")
-                  elif !dollar && c >= '0' && c <= '9' then (dollar := false; "_"+new System.String(c,1))
-                  elif !dollar then (dollar := false; "$"+new System.String(c,1))
-                  else new System.String(c,1))
-              let lines = c.Split([| '\r'; '\n' |], System.StringSplitOptions.RemoveEmptyEntries);
-              for line in lines do 
-                  cprintfn cos "                     %s" line;
-              if !dollar then os.Write '$'
-          | None -> 
-              cprintfn cos "                      raise (%s.Accept(Microsoft.FSharp.Core.Operators.box _1))" parslib
-          cprintfn cos "                   )";
-          // Place the line count back for the type constraint
-          match code with 
-          | Some (_,pos) -> cprintfn cos "# %d \"%s\"" pos.pos_lnum pos.pos_fname
-          | None -> ()
-          cprintfn cos "                 : %s));" (if types.ContainsKey nt then  types.[nt] else "'"+nt);
-      done;
-      cprintfn cos "|]" ;
-  end;
-  cprintfn cos "# %d \"%s\"" !lineCountOutput output;
-  cprintfn cos "let tables () : %s.Tables<_> = " parslib
-  cprintfn cos "  { reductions= _fsyacc_reductions ();"
-  cprintfn cos "    endOfInputTag = _fsyacc_endOfInputTag;"
-  cprintfn cos "    tagOfToken = tagOfToken;"
-  cprintfn cos "    dataOfToken = _fsyacc_dataOfToken; "
-  cprintfn cos "    actionTableElements = _fsyacc_actionTableElements;"
-  cprintfn cos "    actionTableRowOffsets = _fsyacc_actionTableRowOffsets;"
-  cprintfn cos "    stateToProdIdxsTableElements = _fsyacc_stateToProdIdxsTableElements;"
-  cprintfn cos "    stateToProdIdxsTableRowOffsets = _fsyacc_stateToProdIdxsTableRowOffsets;"
-  cprintfn cos "    reductionSymbolCounts = _fsyacc_reductionSymbolCounts;"
-  cprintfn cos "    immediateActions = _fsyacc_immediateActions;"
-  cprintfn cos "    gotos = _fsyacc_gotos;"
-  cprintfn cos "    sparseGotoTableRowOffsets = _fsyacc_sparseGotoTableRowOffsets;"
-  cprintfn cos "    tagOfErrorTerminal = _fsyacc_tagOfErrorTerminal;"
-  cprintfn cos "    parseError = (fun (ctxt:%s.ParseErrorContext<_>) -> " parslib
-  cprintfn cos "                              match parse_error_rich with "
-  cprintfn cos "                              | Some f -> f ctxt"
-  cprintfn cos "                              | None -> parse_error ctxt.Message);"
-  
-  cprintfn cos "    numTerminals = %d;" (Array.length actionTable.[0]);
-  cprintfn cos "    productionToNonTerminalTable = _fsyacc_productionToNonTerminalTable  }"
-  cprintfn cos "let engine lexer lexbuf startState = (tables ()).Interpret(lexer, lexbuf, startState)"                                                                                                         
-
-  for (id,startState) in List.zip spec.StartSymbols startStates do
-        if not (types.ContainsKey id) then 
-          failwith ("a %type declaration is required for for start token "+id);
-        let ty = types.[id] in 
-        cprintfn cos "let %s lexer lexbuf : %s =" id ty;
-        cprintfn cos "    Microsoft.FSharp.Core.Operators.unbox ((tables ()).Interpret(lexer, lexbuf, %d))" startState
-
-  for id in spec.StartSymbols do
-      if not (types.ContainsKey id) then 
-        failwith ("a %type declaration is required for start token "+id);
-      let ty = types.[id] in 
-      cprintfn cosi "val %s : (%s.LexBuffer<%s> -> token) -> %s.LexBuffer<%s> -> (%s) " id lexlib tychar lexlib tychar ty;
-
-  logf (fun oso -> oso.Close())
+  let generatorState: GeneratorState =
+    { GeneratorState.Default with
+          input = filename
+          output = out
+          logger = logger
+          light = light
+          modname = modname
+          internal_module = internal_module
+          opens = opens
+          lexlib = lexlib
+          parslib = parslib
+          compat = compat }
+  writeSpecToFile generatorState spec compiledSpec
 
 let result = 
     try main()
     with e -> 
-      eprintf "FSYACC: error FSY000: %s" (match e with Failure s -> s | e -> e.Message);
+      eprintf "FSYACC: error FSY000: %s\n%s" (match e with Failure s -> s | e -> e.Message) e.StackTrace;
       exit 1
 
diff --git a/buildtools/fsyacc/fsyacc.fsproj b/buildtools/fsyacc/fsyacc.fsproj
index e3a4b88a3a0..eccbfb76b07 100644
--- a/buildtools/fsyacc/fsyacc.fsproj
+++ b/buildtools/fsyacc/fsyacc.fsproj
@@ -3,7 +3,6 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>net7.0</TargetFramework>
-    <DefineConstants>INTERNALIZED_FSLEXYACC_RUNTIME;$(DefineConstants)</DefineConstants>
     <DisableImplicitFSharpCoreReference>true</DisableImplicitFSharpCoreReference>
     <UseAppHost Condition="'$(DotNetBuildFromSource)' == 'true'">false</UseAppHost>
   </PropertyGroup>
@@ -18,6 +17,7 @@
     <Compile Include="fsyaccast.fs" />
     <Compile Include="fsyaccpars.fs" />
     <Compile Include="fsyacclex.fs" />
+    <Compile Include="fsyaccdriver.fs" />
     <Compile Include="fsyacc.fs" />
   </ItemGroup>
 
diff --git a/buildtools/fsyacc/fsyaccast.fs b/buildtools/fsyacc/fsyaccast.fs
index 4880ca5f0bf..3f81e725556 100644
--- a/buildtools/fsyacc/fsyaccast.fs
+++ b/buildtools/fsyacc/fsyaccast.fs
@@ -1,6 +1,6 @@
 // (c) Microsoft Corporation 2005-2007.
 
-module internal FsLexYacc.FsYacc.AST
+module FsLexYacc.FsYacc.AST
 
 #nowarn "62" // This construct is for ML compatibility.
 
@@ -9,8 +9,7 @@ open System
 open System.Collections.Generic
 open Printf
 open Microsoft.FSharp.Collections
-open Internal.Utilities
-open Internal.Utilities.Text.Lexing
+open FSharp.Text.Lexing
 
 /// An active pattern that should be in the F# standard library
 let (|KeyValue|) (kvp:KeyValuePair<_,_>) = kvp.Key,kvp.Value
@@ -18,17 +17,17 @@ let (|KeyValue|) (kvp:KeyValuePair<_,_>) = kvp.Key,kvp.Value
 
 type Identifier = string
 type Code = string * Position
+type Associativity = LeftAssoc | RightAssoc | NonAssoc
+type Rule = Rule of Identifier list * Identifier option * Code option
 
 type ParserSpec= 
     { Header         : Code;
       Tokens         : (Identifier * string option) list;
       Types          : (Identifier * string) list;
-      Associativities: (Identifier * Associativity) list list;
+      Associativities: (Identifier * Associativity) list list; // suggest to do: (Associativity * Identifier list) list
       StartSymbols   : Identifier list;
       Rules          : (Identifier * Rule list) list }
       
-and Rule = Rule of Identifier list * Identifier option * Code option
-and Associativity = LeftAssoc | RightAssoc | NonAssoc
 
 type Terminal = string
 type NonTerminal = string
@@ -75,17 +74,17 @@ type ProcessedParserSpec =
 let ProcessParserSpecAst (spec: ParserSpec) = 
     let explicitPrecInfo = 
         spec.Associativities 
-        |> List.mapi (fun n precSpecs -> precSpecs |> List.map (fun (precSym, assoc) -> precSym,ExplicitPrec (assoc, 10000 - n)))
+        |> List.mapi (fun n precSpecs -> precSpecs |> List.map (fun (precSym, assoc) -> precSym,ExplicitPrec (assoc, 9999 - n)))
         |> List.concat
     
-    for (key,_) in explicitPrecInfo |> Seq.countBy fst |> Seq.filter (fun (_,n) -> n > 1)  do
+    for key,_ in explicitPrecInfo |> Seq.countBy fst |> Seq.filter (fun (_,n) -> n > 1)  do
         failwithf "%s is given two associativities" key
     
     let explicitPrecInfo = 
         explicitPrecInfo |> Map.ofList
 
     let implicitSymPrecInfo = NoPrecedence
-    let terminals = List.map fst spec.Tokens @ ["error"]in 
+    let terminals = List.map fst spec.Tokens @ ["error"]
     let terminalSet = Set.ofList terminals
     let IsTerminal z = terminalSet.Contains(z)
     let prec_of_terminal sym implicitPrecInfo = 
@@ -94,14 +93,14 @@ let ProcessParserSpecAst (spec: ParserSpec) =
        
     let mkSym s = if IsTerminal s then Terminal s else NonTerminal s
     let prods =  
-        spec.Rules |> List.mapi (fun i (nonterm,rules) -> 
-            rules |> List.mapi (fun j (Rule(syms,precsym,code)) -> 
+        spec.Rules |> List.mapi (fun _ (nonterm,rules) -> 
+            rules |> List.mapi (fun _ (Rule(syms,precsym,code)) -> 
                 let precInfo = 
                     let precsym = List.foldBack (fun x acc -> match acc with Some _ -> acc | None -> match x with z when IsTerminal z -> Some z | _ -> acc) syms precsym
                     let implicitPrecInfo = NoPrecedence
                     match precsym with 
                     | None -> implicitPrecInfo 
-                    | Some sym -> if explicitPrecInfo.ContainsKey(sym) then explicitPrecInfo.[sym] else implicitPrecInfo
+                    | Some sym -> prec_of_terminal sym None
                 Production(nonterm, precInfo, List.map mkSym syms, code)))
          |> List.concat
     let nonTerminals = List.map fst spec.Rules
@@ -110,7 +109,7 @@ let ProcessParserSpecAst (spec: ParserSpec) =
         if nt <> "error" && not (nonTerminalSet.Contains(nt)) then 
             failwith (sprintf "NonTerminal '%s' has no productions" nt)
 
-    for (Production(nt,_,syms,_)) in prods do
+    for Production(_,_,syms,_) in prods do
         for sym in syms do 
            match sym with 
            | NonTerminal nt -> 
@@ -120,7 +119,7 @@ let ProcessParserSpecAst (spec: ParserSpec) =
            
     if spec.StartSymbols= [] then (failwith "at least one %start declaration is required");
 
-    for (nt,_) in spec.Types do 
+    for nt,_ in spec.Types do 
         checkNonTerminal nt;
 
     let terminals = terminals |> List.map (fun t -> (t,prec_of_terminal t None)) 
@@ -176,7 +175,7 @@ type NonTerminalIndex = int
 type SymbolIndex = int
 let PTerminal(i:TerminalIndex) : SymbolIndex = -i-1
 let PNonTerminal(i:NonTerminalIndex) : SymbolIndex = i
-let (|PTerminal|PNonTerminal|) x = if x < 0 then PTerminal (-(x+1)) else PNonTerminal x
+let (|PTerminal|PNonTerminal|) x = if x < 0 then PTerminal (-x-1) else PNonTerminal x
 
 type SymbolIndexes = SymbolIndex list
 
@@ -211,7 +210,7 @@ let ProcessWorkList start f =
     let rec loop() = 
         match !work with 
         | [] -> ()
-        | x :: t -> 
+        | x::t -> 
             work := t; 
             f queueWork x;
             loop()
@@ -227,14 +226,14 @@ let LeastFixedPoint f set =
 /// A general standard memoization utility. Be sure to apply to only one (function) argument to build the
 /// residue function!
 let Memoize f = 
-    let t = new Dictionary<_,_>(1000)
+    let t = Dictionary(1000)
     fun x -> 
         let ok,v = t.TryGetValue(x) 
         if ok then v else let res = f x in t.[x] <- res; res 
 
 /// A standard utility to create a dictionary from a list of pairs
 let CreateDictionary xs = 
-    let dict = new Dictionary<_,_>()
+    let dict = Dictionary()
     for x,y in xs do dict.Add(x,y)
     dict
 
@@ -277,7 +276,7 @@ type ProductionTable(ntTab:NonTerminalTable, termTab:TerminalTable, nonTerminals
     let c = Array.ofList (List.map (fun (_,Production(_,prec,_,_)) -> prec) prodsWithIdxs)
     let productions = 
         nonTerminals
-        |> List.map(fun nt -> (ntTab.ToIndex nt, List.choose (fun (i,Production(nt2,prec,syms,_)) -> if nt2=nt then Some i else None) prodsWithIdxs))
+        |> List.map(fun nt -> (ntTab.ToIndex nt, List.choose (fun (i,Production(nt2,_,_,_)) -> if nt2=nt then Some i else None) prodsWithIdxs))
         |> CreateDictionary
 
     member prodTab.Symbols(i) = a.[i]
@@ -285,12 +284,12 @@ type ProductionTable(ntTab:NonTerminalTable, termTab:TerminalTable, nonTerminals
     member prodTab.Precedence(i) = c.[i]
     member prodTab.Symbol i n = 
         let syms = prodTab.Symbols i
-        if n >= syms.Length then None else Some (syms.[n])
+        if n >= syms.Length then None else Some syms.[n]
     member prodTab.Productions = productions
 
 /// A mutable table maping kernels to sets of lookahead tokens
 type LookaheadTable() = 
-    let t = new Dictionary<KernelItemIndex,Set<TerminalIndex>>()
+    let t = Dictionary<KernelItemIndex,Set<TerminalIndex>>()
     member table.Add(x,y) = 
         let prev = if t.ContainsKey(x) then t.[x] else Set.empty 
         t.[x] <- prev.Add(y)
@@ -314,9 +313,9 @@ type KernelTable(kernels) =
 
 /// Hold the results of cpmuting the LALR(1) closure of an LR(0) kernel
 type Closure1Table() = 
-    let t = new Dictionary<Item0,HashSet<TerminalIndex>>()
+    let t = Dictionary<Item0,HashSet<TerminalIndex>>()
     member table.Add(a,b) = 
-        if not (t.ContainsKey(a)) then t.[a] <- new HashSet<_>(HashIdentity.Structural)
+        if not (t.ContainsKey(a)) then t.[a] <- HashSet<_>(HashIdentity.Structural)
         t.[a].Add(b)
     member table.Count  = t.Count
     member table.IEnumerable = (t :> seq<_>)
@@ -325,9 +324,9 @@ type Closure1Table() =
 /// A mutable table giving a lookahead set Set<Terminal> for each kernel. The terminals represent the
 /// "spontaneous" items for the kernel. TODO: document this more w.r.t. the Dragon book.
 type SpontaneousTable() = 
-    let t = new Dictionary<KernelItemIndex,HashSet<TerminalIndex>>()
+    let t = Dictionary<KernelItemIndex,HashSet<TerminalIndex>>()
     member table.Add(a,b) = 
-        if not (t.ContainsKey(a)) then t.[a] <- new HashSet<_>(HashIdentity.Structural)
+        if not (t.ContainsKey(a)) then t.[a] <- HashSet<_>(HashIdentity.Structural)
         t.[a].Add(b)
     member table.Count  = t.Count
     member table.IEnumerable = (t :> seq<_>)
@@ -335,20 +334,35 @@ type SpontaneousTable() =
 /// A mutable table giving a Set<KernelItemIndex> for each kernel. The kernels represent the
 /// "propagate" items for the kernel. TODO: document this more w.r.t. the Dragon book.
 type PropagateTable() = 
-    let t = new Dictionary<KernelItemIndex,HashSet<KernelItemIndex>>()
+    let t = Dictionary<KernelItemIndex,HashSet<KernelItemIndex>>()
     member table.Add(a,b) = 
-        if not (t.ContainsKey(a)) then t.[a] <- new HashSet<KernelItemIndex>(HashIdentity.Structural)
+        if not (t.ContainsKey(a)) then t.[a] <- HashSet<KernelItemIndex>(HashIdentity.Structural)
         t.[a].Add(b)
     member table.Item 
-      with get(a) = 
+      with get a = 
         let ok,v = t.TryGetValue(a) 
         if ok then v :> seq<_> else Seq.empty
     member table.Count  = t.Count
 
 
+type Prod = NonTerminal * int * Symbols * option<Code>
+type ActionTable = (PrecedenceInfo * Action) array array
+
+type CompiledSpec = 
+    { prods: Prod []
+      states: int list []
+      startStates: int list
+      actionTable: ActionTable
+      immediateActionTable: Action option []
+      gotoTable: int option [] []
+      endOfInputTerminalIdx: int
+      errorTerminalIdx: int
+      nonTerminals: string list
+    }
+
 /// Compile a pre-processed LALR parser spec to tables following the Dragon book algorithm
-let CompilerLalrParserSpec logf (spec : ProcessedParserSpec) =
-    let stopWatch = new System.Diagnostics.Stopwatch()
+let CompilerLalrParserSpec logf (spec : ProcessedParserSpec): CompiledSpec =
+    let stopWatch = System.Diagnostics.Stopwatch()
     let reportTime() = printfn "        time: %A" stopWatch.Elapsed; stopWatch.Reset(); stopWatch.Start()
     stopWatch.Start()
 
@@ -400,7 +414,7 @@ let CompilerLalrParserSpec logf (spec : ProcessedParserSpec) =
                         let rhs = Array.toList (prodTab.Symbols prodIdx)
                         let rec place l =
                             match l with
-                            | (yi :: t) -> 
+                            | yi::t -> 
                                 res := 
                                    List.choose 
                                      (function None -> None | Some a -> Some (PNonTerminal nonTermX,Some a)) 
@@ -424,11 +438,11 @@ let CompilerLalrParserSpec logf (spec : ProcessedParserSpec) =
     /// have an empty token in the first set then we have to iterate through those. 
     let ComputeFirstSetOfTokenList =
         Memoize (fun (str,term) -> 
-            let acc = new System.Collections.Generic.List<_>()
+            let acc = System.Collections.Generic.List<_>()
             let rec add l = 
                 match l with 
                 | [] -> acc.Add(term)
-                | sym :: moreSyms -> 
+                | sym::moreSyms -> 
                     let firstSetOfSym = computedFirstTable.[sym]
                     firstSetOfSym |> Set.iter (function None -> () | Some v -> acc.Add(v)) 
                     if firstSetOfSym.Contains(None) then add moreSyms 
@@ -519,7 +533,7 @@ let CompilerLalrParserSpec logf (spec : ProcessedParserSpec) =
             fprintf os "  gotos:"
             fprintf os "%a" OutputGotos d) m
     
-    let OutputLalrTables os (prods,states, startStates,actionTable,immediateActionTable,gotoTable,endOfInputTerminalIdx,errorTerminalIdx) = 
+    let OutputLalrTables os (_,states, startStates,actionTable,immediateActionTable,gotoTable,_,_) = 
         let combined = Array.ofList (List.map2 (fun x (y,(z,w)) -> x,y,z,w) (Array.toList states) (List.zip (Array.toList actionTable) (List.zip (Array.toList immediateActionTable) (Array.toList gotoTable))))
         fprintfn os "------------------------";
         fprintfn os "states = ";
@@ -559,7 +573,7 @@ let CompilerLalrParserSpec logf (spec : ProcessedParserSpec) =
     // Input is kernel, output is kernel
     let ComputeGotosOfKernel iset sym = 
         let isetClosure = ComputeClosure0 iset
-        let acc = new System.Collections.Generic.List<_>(10)
+        let acc = System.Collections.Generic.List<_>(10)
         isetClosure |> Set.iter (fun item0 -> 
               match rsym_of_item0 item0 with 
               | Some sym2 when sym = sym2 -> acc.Add(advance_of_item0 item0) 
@@ -587,7 +601,7 @@ let CompilerLalrParserSpec logf (spec : ProcessedParserSpec) =
     
     reportTime(); printf "building kernel table..."; stdout.Flush();
     // Give an index to each LR(0) kernel, and from now on refer to them only by index 
-    let kernelTab = new KernelTable(kernels)
+    let kernelTab = KernelTable(kernels)
     let startKernelIdxs = List.map kernelTab.Index startKernels
     let startKernelItemIdxs = List.map2 (fun a b -> KernelItemIdx(a,b)) startKernelIdxs startItems
 
@@ -617,7 +631,7 @@ let CompilerLalrParserSpec logf (spec : ProcessedParserSpec) =
     //            add [B --> .g, b] to I
     
     let ComputeClosure1 iset = 
-        let acc = new Closure1Table()
+        let acc = Closure1Table()
         ProcessWorkList iset (fun addToWorkList (item0,pretokens:Set<TerminalIndex>) ->
             pretokens |> Set.iter (fun pretoken -> 
                 if not (acc.Contains(item0,pretoken)) then
@@ -625,7 +639,7 @@ let CompilerLalrParserSpec logf (spec : ProcessedParserSpec) =
                     let rsyms = rsyms_of_item0 item0 
                     if rsyms.Length > 0 then 
                         match rsyms.[0] with 
-                        | (PNonTerminal ntB) -> 
+                        | PNonTerminal ntB -> 
                              let firstSet = ComputeFirstSetOfTokenList (Array.toList rsyms.[1..],pretoken)
                              for prodIdx in prodTab.Productions.[ntB] do
                                  addToWorkList (prodIdx_to_item0 prodIdx,firstSet)
@@ -657,8 +671,8 @@ let CompilerLalrParserSpec logf (spec : ProcessedParserSpec) =
         let closure1OfItem0WithDummy = 
             Memoize (fun item0 -> ComputeClosure1 [(item0,Set.ofList [dummyLookaheadIdx])])
 
-        let spontaneous = new SpontaneousTable()
-        let propagate = new PropagateTable()
+        let spontaneous = SpontaneousTable()
+        let propagate = PropagateTable()
         let count = ref 0 
 
         for kernelIdx in kernelTab.Indexes do
@@ -669,7 +683,7 @@ let CompilerLalrParserSpec logf (spec : ProcessedParserSpec) =
                 let item0Idx = KernelItemIdx(kernelIdx,item0)
                 let jset = closure1OfItem0WithDummy item0
                 //printf  "#jset = %d\n" jset.Count; stdout.Flush();
-                for (KeyValue(closureItem0, lookaheadTokens)) in jset.IEnumerable do
+                for KeyValue(closureItem0, lookaheadTokens) in jset.IEnumerable do
                     incr count
                     match rsym_of_item0 closureItem0 with 
                     | None -> ()
@@ -701,11 +715,11 @@ let CompilerLalrParserSpec logf (spec : ProcessedParserSpec) =
         let initialWork =
             [ for idx in startKernelItemIdxs do
                   yield (idx,endOfInputTerminalIdx)
-              for (KeyValue(kernelItemIdx,lookaheads)) in spontaneous.IEnumerable do
+              for KeyValue(kernelItemIdx,lookaheads) in spontaneous.IEnumerable do
                   for lookahead in lookaheads do
                       yield (kernelItemIdx,lookahead) ]
 
-        let acc = new LookaheadTable()
+        let acc = LookaheadTable()
         // Compute the closure
         ProcessWorkList 
             initialWork
@@ -729,7 +743,7 @@ let CompilerLalrParserSpec logf (spec : ProcessedParserSpec) =
             // printf "DEBUG: state %d: adding action for %s, precNew = %a, actionNew = %a\n" kernelIdx (termTab.OfIndex termIdx) outputPrec precNew OutputAction actionNew; 
             // We add in order of precedence - however the precedences may be the same, and we give warnings when rpecedence resolution is based on implicit file orderings 
 
-            let (precSoFar, actionSoFar) as itemSoFar = arr.[termIdx]
+            let _, actionSoFar as itemSoFar = arr.[termIdx]
 
             // printf "DEBUG: state %d: adding action for %s, precNew = %a, precSoFar = %a, actionSoFar = %a\n" kernelIdx (termTab.OfIndex termIdx) outputPrec precNew outputPrec precSoFar OutputAction actionSoFar; 
             // if compare_prec precSoFar precNew = -1 then failwith "addResolvingPrecedence"; 
@@ -764,17 +778,17 @@ let CompilerLalrParserSpec logf (spec : ProcessedParserSpec) =
                     let a2n, astr2 = reportAction x2
                     printfn "        %s/%s error at state %d on terminal %s between %s and %s - assuming the former because %s" a1n a2n kernelIdx (termTab.OfIndex termIdx) astr1 astr2 reason
                 match itemSoFar,itemNew with 
-                | (_,Shift s1),(_, Shift s2) -> 
+                | (_,Shift _),(_, Shift _) -> 
                    if actionSoFar <> actionNew then 
                       reportConflict itemSoFar itemNew "internal error"
                    itemSoFar
 
-                | (((precShift,Shift sIdx) as shiftItem), 
-                   ((precReduce,Reduce prodIdx) as reduceItem))
-                | (((precReduce,Reduce prodIdx) as reduceItem), 
-                   ((precShift,Shift sIdx) as shiftItem)) -> 
+                | (precShift,Shift _ as shiftItem, 
+                   (precReduce,Reduce _ as reduceItem))
+                | (precReduce,Reduce _ as reduceItem, 
+                   (precShift,Shift _ as shiftItem)) -> 
                     match precReduce, precShift with 
-                    | (ExplicitPrec (_,p1), ExplicitPrec(assocNew,p2)) -> 
+                    | ExplicitPrec (_,p1), ExplicitPrec(assocNew,p2) -> 
                       if p1 < p2 then shiftItem
                       elif p1 > p2 then reduceItem
                       else
@@ -789,7 +803,7 @@ let CompilerLalrParserSpec logf (spec : ProcessedParserSpec) =
                        reportConflict shiftItem reduceItem "we prefer shift when unable to compare precedences"
                        incr shiftReduceConflicts;
                        shiftItem
-                | ((_,Reduce prodIdx1),(_, Reduce prodIdx2)) -> 
+                | (_,Reduce prodIdx1),(_, Reduce prodIdx2) -> 
                    "we prefer the rule earlier in the file"
                    |> if prodIdx1 < prodIdx2 then reportConflict itemSoFar itemNew else reportConflict itemNew itemSoFar
                    incr reduceReduceConflicts;
@@ -813,9 +827,9 @@ let CompilerLalrParserSpec logf (spec : ProcessedParserSpec) =
                      yield (item0,lookaheads) ]
                  |> ComputeClosure1
 
-            for (KeyValue(item0,lookaheads)) in items.IEnumerable do
+            for KeyValue(item0,lookaheads) in items.IEnumerable do
 
-                let nonTermA = ntIdx_of_item0 item0
+                let _ = ntIdx_of_item0 item0
                 match rsym_of_item0 item0 with 
                 | Some (PTerminal termIdx) -> 
                     let action =
@@ -890,18 +904,22 @@ let CompilerLalrParserSpec logf (spec : ProcessedParserSpec) =
 
     /// The final results
     let states = kernels |> Array.ofList 
-    let prods = Array.ofList (List.map (fun (Production(nt,prec,syms,code)) -> (nt, ntTab.ToIndex nt, syms,code)) prods)
+    let prods = Array.ofList (List.map (fun (Production(nt,_,syms,code)) -> (nt, ntTab.ToIndex nt, syms,code)) prods)
 
     logf (fun logStream -> 
         printfn  "writing tables to log"; stdout.Flush();
         OutputLalrTables logStream     (prods, states, startKernelIdxs, actionTable, immediateActionTable, gotoTable, (termTab.ToIndex endOfInputTerminal), errorTerminalIdx));
 
     let states = states |> Array.map (Set.toList >> List.map prodIdx_of_item0)
-    (prods, states, startKernelIdxs, 
-     actionTable, immediateActionTable, gotoTable, 
-     (termTab.ToIndex endOfInputTerminal), 
-     errorTerminalIdx, nonTerminals)
-
+    { prods = prods
+      states = states
+      startStates = startKernelIdxs
+      actionTable = actionTable
+      immediateActionTable = immediateActionTable
+      gotoTable = gotoTable
+      endOfInputTerminalIdx = termTab.ToIndex endOfInputTerminal
+      errorTerminalIdx = errorTerminalIdx
+      nonTerminals = nonTerminals }
   
 (* Some examples for testing *)  
 
diff --git a/buildtools/fsyacc/fsyaccdriver.fs b/buildtools/fsyacc/fsyaccdriver.fs
new file mode 100644
index 00000000000..b249e0e60d7
--- /dev/null
+++ b/buildtools/fsyacc/fsyaccdriver.fs
@@ -0,0 +1,547 @@
+module FsLexYacc.FsYacc.Driver
+
+open System
+open System.IO
+open FSharp.Text.Lexing
+open FsLexYacc.FsYacc
+open FsLexYacc.FsYacc.AST
+open Printf
+open System.Collections.Generic
+
+let has_extension (s:string) = 
+    (s.Length >= 1 && s.[s.Length - 1] = '.') 
+    || Path.HasExtension(s)
+
+let chop_extension (s:string) =
+    if not (has_extension s) then invalidArg "s" "the file name does not have an extension"
+    Path.Combine (Path.GetDirectoryName s,Path.GetFileNameWithoutExtension(s)) 
+
+let checkSuffix (x:string) (y:string) = x.EndsWith(y)
+
+let readSpecFromFile fileName codePage =
+  let stream,reader,lexbuf = UnicodeFileAsLexbuf(fileName, codePage)
+  use stream = stream
+  use reader = reader
+  try
+      let spec = Parser.spec Lexer.token lexbuf
+      Ok spec
+  with e ->
+      (e, lexbuf.StartPos.Line, lexbuf.StartPos.Column)
+      |> Result.Error
+
+let printTokens filename codePage = 
+    let stream,reader,lexbuf = UnicodeFileAsLexbuf(filename, codePage) 
+    use stream = stream
+    use reader = reader
+
+    try 
+      while true do 
+        printf "tokenize - getting one token";
+        let t = Lexer.token lexbuf in 
+        (*F# printf "tokenize - got %s" (Parser.token_to_string t); F#*)
+        if t = Parser.EOF then exit 0
+    with e -> 
+         eprintf "%s(%d,%d): error: %s" filename lexbuf.StartPos.Line lexbuf.StartPos.Column e.Message;
+         exit 1
+
+let logFileName (input: string, out: string option, log: bool) = 
+    if log then Some (match out with Some x -> chop_extension x + ".fsyacc.output" | _ -> chop_extension input + ".fsyacc.output") 
+    else None
+
+let deriveOutputFileNames (filename, out: string option) =
+  let output = match out with Some x -> x | _ -> chop_extension filename + (if checkSuffix filename ".mly" then ".ml" else ".fs") in
+  let outputi = match out with Some x -> chop_extension x + (if checkSuffix x ".ml" then ".mli" else ".fsi") | _ -> chop_extension filename + (if checkSuffix filename ".mly" then ".mli" else ".fsi") in
+  output, outputi
+
+type Logger = 
+    inherit IDisposable
+
+    abstract member LogStream: (TextWriter -> 'a) -> 'a
+    abstract member Log: TextWriterFormat<'a> -> 'a
+    abstract member LogString: string -> unit
+
+type FileLogger (outputFileLog) =
+    let osl = File.CreateText outputFileLog :> TextWriter
+
+    interface Logger with
+        member x.LogStream f = f osl
+
+        member x.Log format = fprintfn osl format
+        
+        member x.LogString msg =  fprintfn osl "%s" msg
+
+    interface IDisposable with
+        member _.Dispose() = 
+            osl.Dispose()
+
+type NullLogger () =
+    interface Logger with
+        member x.LogStream f = 
+            f  TextWriter.Null
+        member x.Log f = 
+            fprintfn TextWriter.Null f
+        member x.LogString _ = ()
+
+    interface IDisposable with member _.Dispose () = ()
+
+type Writer(outputFileName, outputFileInterface) = 
+    let os = File.CreateText outputFileName :> TextWriter
+    let mutable outputLineCount = 0
+    let osi = File.CreateText outputFileInterface :> TextWriter
+    let mutable interfaceLineCount = 0
+
+    member x.Write format = 
+        fprintf os format
+    
+    member x.WriteLine format =
+        kfprintf (fun _ -> 
+            outputLineCount <- outputLineCount + 1
+            os.WriteLine ()
+        ) os format
+
+    member x.WriteUInt16 (i: int) = fprintf os "%dus;" i
+    
+    member x.WriteCode (code, pos) = 
+        x.WriteLine "# %d \"%s\"" pos.pos_lnum pos.pos_fname
+        x.WriteLine "%s" code
+        let codeLines = code.Replace("\r","").Split([| '\n' |]).Length
+        outputLineCount <- outputLineCount + codeLines
+        x.WriteLine "# %d \"%s\"" outputLineCount outputFileName
+
+    member x.OutputLineCount = outputLineCount
+
+    member x.WriteInterface format = 
+        fprintf osi format
+    
+    member x.WriteLineInterface format = 
+        kfprintf (fun _ -> 
+            interfaceLineCount <- interfaceLineCount + 1
+            osi.WriteLine ()
+        ) osi format
+
+    member x.InterfaceLineCount = interfaceLineCount
+    
+    
+
+    interface IDisposable with
+        member x.Dispose () =
+            os.Dispose()
+            osi.Dispose()
+
+
+// This is to avoid name conflicts against keywords.
+let generic_nt_name nt = "'gentype_" + nt
+let anyMarker = 0xffff
+
+let actionCoding   =
+  let shiftFlag = 0x0000
+  let reduceFlag = 0x4000
+  let errorFlag = 0x8000
+  let acceptFlag = 0xc000
+  function
+  | Accept -> acceptFlag
+  | Shift n -> shiftFlag ||| n
+  | Reduce n -> reduceFlag ||| n
+  | Error -> errorFlag 
+
+type GeneratorState = 
+ { input: string
+   output: string option
+   logger: Logger
+   light: bool option
+   modname: string option
+   internal_module: bool
+   opens: string list
+   lexlib: string
+   parslib: string
+   compat: bool
+   generate_nonterminal_name: Identifier -> string
+   map_action_to_int: Action -> int
+   anyMarker: int }
+   with 
+   static member Default = 
+    {  input = ""
+       output = None
+       logger = new NullLogger()
+       light = None
+       modname = None
+       internal_module = false
+       opens = []
+       lexlib = ""
+       parslib = ""
+       compat = false
+       generate_nonterminal_name = generic_nt_name
+       map_action_to_int = actionCoding
+       anyMarker = anyMarker }
+
+let writeSpecToFile (generatorState: GeneratorState) (spec: ParserSpec) (compiledSpec: CompiledSpec) = 
+      let output, outputi = deriveOutputFileNames (generatorState.input, generatorState.output)
+      generatorState.logger.Log "        Output file describing compiled parser placed in %s and %s" output outputi
+      use writer = new Writer(output, outputi)
+      writer.WriteLine          "// Implementation file for parser generated by fsyacc";
+      writer.WriteLineInterface "// Signature file for parser generated by fsyacc";
+
+      if (generatorState.light = Some(false)) || (generatorState.light = None && checkSuffix output ".ml") then
+          writer.WriteLine "#light \"off\"";
+          writer.WriteLineInterface "#light \"off\"";
+
+      match generatorState.modname with 
+      | None -> ()
+      | Some s -> 
+          match generatorState.internal_module with
+          | true ->
+              writer.WriteLine          "module internal %s" s;
+              writer.WriteLineInterface "module internal %s" s;
+          | false ->
+              writer.WriteLine "module %s" s;
+              writer.WriteLineInterface "module %s" s;
+      
+      writer.WriteLine "#nowarn \"64\";; // turn off warnings that type variables used in production annotations are instantiated to concrete type";
+
+      for s in generatorState.opens do
+          writer.WriteLine          "open %s" s;
+          writer.WriteLineInterface "open %s" s;
+
+      writer.WriteLine "open %s" generatorState.lexlib;
+      writer.WriteLine "open %s.ParseHelpers" generatorState.parslib;
+      if generatorState.compat then 
+          writer.WriteLine "open Microsoft.FSharp.Compatibility.OCaml.Parsing";
+
+      writer.WriteCode spec.Header
+      
+      // Print the datatype for the tokens
+      writer.WriteLine "// This type is the type of tokens accepted by the parser";
+          
+          writer.WriteLine "type token = ";
+          writer.WriteLineInterface "type token = ";
+          for id,typ in spec.Tokens do 
+              match typ with
+              | None -> 
+                writer.WriteLine "  | %s" id
+                writer.WriteLineInterface "  | %s" id
+              | Some ty -> 
+                writer.WriteLine "  | %s of (%s)" id ty
+                writer.WriteLineInterface "  | %s of (%s)" id ty
+
+      // Print the datatype for the token names
+      writer.WriteLine "// This type is used to give symbolic names to token indexes, useful for error messages";
+      writer.WriteLine          "type tokenId = ";
+      writer.WriteLineInterface "type tokenId = ";
+          for id,_ in spec.Tokens do 
+               writer.WriteLine          "    | TOKEN_%s" id;
+               writer.WriteLineInterface "    | TOKEN_%s" id;
+      writer.WriteLine          "    | TOKEN_end_of_input";
+      writer.WriteLineInterface "    | TOKEN_end_of_input";
+      writer.WriteLine          "    | TOKEN_error";
+      writer.WriteLineInterface "    | TOKEN_error";
+
+      writer.WriteLine "// This type is used to give symbolic names to token indexes, useful for error messages";
+      writer.WriteLine          "type nonTerminalId = ";
+      writer.WriteLineInterface "type nonTerminalId = ";
+      for nt in compiledSpec.nonTerminals do 
+          writer.WriteLine          "    | NONTERM_%s" nt;
+          writer.WriteLineInterface "    | NONTERM_%s" nt;
+
+
+      writer.WriteLine "";
+      writer.WriteLine "// This function maps tokens to integer indexes";
+      writer.WriteLine "let tagOfToken (t:token) = ";
+      writer.WriteLine "  match t with";
+      spec.Tokens |> List.iteri (fun i (id,typ) -> 
+          writer.WriteLine "  | %s %s -> %d " id (match typ with Some _ -> "_" | None -> "") i);
+      writer.WriteLineInterface "/// This function maps tokens to integer indexes";
+      writer.WriteLineInterface "val tagOfToken: token -> int";
+
+      writer.WriteLine "";
+      writer.WriteLine "// This function maps integer indexes to symbolic token ids";
+      writer.WriteLine "let tokenTagToTokenId (tokenIdx:int) = ";
+      writer.WriteLine "  match tokenIdx with";
+      spec.Tokens |> List.iteri (fun i (id,_) ->  writer.WriteLine "  | %d -> TOKEN_%s " i id)
+      writer.WriteLine "  | %d -> TOKEN_end_of_input" compiledSpec.endOfInputTerminalIdx;
+      writer.WriteLine "  | %d -> TOKEN_error" compiledSpec.errorTerminalIdx;
+      writer.WriteLine "  | _ -> failwith \"tokenTagToTokenId: bad token\""
+
+      writer.WriteLineInterface "";
+      writer.WriteLineInterface "/// This function maps integer indexes to symbolic token ids";
+      writer.WriteLineInterface "val tokenTagToTokenId: int -> tokenId";
+
+      writer.WriteLine "";
+      writer.WriteLine "/// This function maps production indexes returned in syntax errors to strings representing the non terminal that would be produced by that production";
+      writer.WriteLine "let prodIdxToNonTerminal (prodIdx:int) = ";
+      writer.WriteLine "  match prodIdx with";
+      compiledSpec.prods |> Array.iteri (fun i (nt,_,_,_) ->  writer.WriteLine "    | %d -> NONTERM_%s " i nt);
+      writer.WriteLine "    | _ -> failwith \"prodIdxToNonTerminal: bad production index\""
+
+      writer.WriteLineInterface "";
+      writer.WriteLineInterface "/// This function maps production indexes returned in syntax errors to strings representing the non terminal that would be produced by that production";
+      writer.WriteLineInterface "val prodIdxToNonTerminal: int -> nonTerminalId";
+
+      writer.WriteLine "";
+      writer.WriteLine "let _fsyacc_endOfInputTag = %d " compiledSpec.endOfInputTerminalIdx;
+      writer.WriteLine "let _fsyacc_tagOfErrorTerminal = %d" compiledSpec.errorTerminalIdx;
+      writer.WriteLine "";
+      writer.WriteLine "// This function gets the name of a token as a string";
+      writer.WriteLine "let token_to_string (t:token) = ";
+      writer.WriteLine "  match t with ";
+      spec.Tokens |> List.iteri (fun _ (id,typ) ->  writer.WriteLine "  | %s %s -> \"%s\" " id (match typ with Some _ -> "_" | None -> "") id);
+
+      writer.WriteLineInterface "";
+      writer.WriteLineInterface "/// This function gets the name of a token as a string";
+      writer.WriteLineInterface "val token_to_string: token -> string";
+
+      writer.WriteLine "";
+      writer.WriteLine "// This function gets the data carried by a token as an object";
+      writer.WriteLine "let _fsyacc_dataOfToken (t:token) = ";
+      writer.WriteLine "  match t with ";
+
+      for id,typ in spec.Tokens do
+          writer.WriteLine "  | %s %s -> %s " 
+            id
+            (match typ with Some _ -> "_fsyacc_x" | None -> "")
+            (match typ with Some _ -> "Microsoft.FSharp.Core.Operators.box _fsyacc_x" | None -> "(null : System.Object)")
+
+      let tychar = "'cty" 
+
+      for key,_ in spec.Types |> Seq.countBy fst |> Seq.filter (fun (_,n) -> n > 1)  do
+            failwithf "%s is given multiple %%type declarations" key;
+        
+      for key,_ in spec.Tokens |> Seq.countBy fst |> Seq.filter (fun (_,n) -> n > 1)  do
+            failwithf "%s is given %%token declarations" key
+        
+      let types = Map.ofList spec.Types 
+      let tokens = Map.ofList spec.Tokens 
+      
+      let nStates = compiledSpec.states.Length 
+      begin 
+          writer.Write "let _fsyacc_gotos = [| " ;
+          let numGotoNonTerminals = compiledSpec.gotoTable.[0].Length 
+          let gotoIndexes = Array.create numGotoNonTerminals 0 
+          let mutable gotoTableCurrIndex = 0 
+          for j = 0 to numGotoNonTerminals-1 do  
+              gotoIndexes.[j] <- gotoTableCurrIndex
+
+              (* Count the number of entries in the association table. *)
+              let mutable count = 0
+              for i = 0 to nStates - 1 do 
+                let goto = compiledSpec.gotoTable.[i].[j] 
+                match goto with 
+                | None -> ()
+                | Some _ -> count <- count + 1
+       
+              (* Write the head of the table (i.e. the number of entries and the default value) *)
+              gotoTableCurrIndex <- gotoTableCurrIndex + 1
+              writer.WriteUInt16 count
+              writer.WriteUInt16 generatorState.anyMarker
+              
+              (* Write the pairs of entries in incremental order by key *)
+              (* This lets us implement the lookup by a binary chop. *)
+              for i = 0 to nStates - 1 do 
+                let goto = compiledSpec.gotoTable.[i].[j] 
+                match goto with 
+                | None -> ()
+                | Some n -> 
+                    gotoTableCurrIndex <- gotoTableCurrIndex + 1
+                    writer.WriteUInt16 i
+                    writer.WriteUInt16 n
+          writer.WriteLine "|]" ;
+          (* Output offsets into gotos table where the gotos for a particular nonterminal begin *)
+          writer.Write "let _fsyacc_sparseGotoTableRowOffsets = [|" ;
+          for j = 0 to numGotoNonTerminals-1 do  
+              writer.WriteUInt16 gotoIndexes.[j]
+          writer.WriteLine "|]"
+      end;
+
+      begin 
+          writer.Write "let _fsyacc_stateToProdIdxsTableElements = [| " ;
+          let indexes = Array.create compiledSpec.states.Length 0 
+          let mutable currIndex = 0 
+          for j = 0 to compiledSpec.states.Length - 1 do
+              let state = compiledSpec.states.[j]
+              indexes.[j] <- currIndex;
+
+              (* Write the head of the table (i.e. the number of entries) *)
+              writer.WriteUInt16 state.Length;
+              currIndex <- currIndex + state.Length + 1
+              
+              (* Write the pairs of entries in incremental order by key *)
+              (* This lets us implement the lookup by a binary chop. *)
+              for prodIdx in state do
+                    writer.WriteUInt16 prodIdx
+          writer.WriteLine "|]" ;
+          (* Output offsets into gotos table where the gotos for a particular nonterminal begin *)
+          writer.Write "let _fsyacc_stateToProdIdxsTableRowOffsets = [|" ;
+          for idx in indexes do 
+              writer.WriteUInt16 idx;
+          writer.WriteLine "|]" ;
+      end;
+
+      begin 
+        let numActionRows = (Array.length compiledSpec.actionTable) 
+        let _ = Array.length compiledSpec.actionTable.[0] 
+        writer.WriteLine "let _fsyacc_action_rows = %d" numActionRows;
+        writer.Write "let _fsyacc_actionTableElements = [|" ;
+        let actionIndexes = Array.create numActionRows 0 
+        
+        let mutable actionTableCurrIndex = 0 
+        for i = 0 to nStates-1 do 
+            actionIndexes.[i] <- actionTableCurrIndex;
+            let actions = compiledSpec.actionTable.[i] 
+            let terminalsByAction = Dictionary<_,int list>(10) 
+            let countPerAction = Dictionary<_,_>(10) 
+            for terminal = 0 to actions.Length - 1 do  
+                  let action = snd actions.[terminal] 
+                  if terminalsByAction.ContainsKey action then 
+                      terminalsByAction.[action] <- terminal :: terminalsByAction.[action] ;
+                  else
+                      terminalsByAction.[action] <- [terminal];
+                  if countPerAction.ContainsKey action then 
+                    countPerAction.[action] <- countPerAction.[action]+1
+                  else 
+                    countPerAction.[action] <- 1
+
+            let mostCommonAction = 
+                let mostCommon = ref Error 
+                let max = ref 0 
+                for KeyValue(x,y) in countPerAction do 
+                    if y > !max then (mostCommon := x; max := y)
+                !mostCommon 
+
+            (* Count the number of entries in the association table. *)
+            let count = ref 0 
+            for KeyValue(action,terminals) in terminalsByAction do 
+                for terminal in terminals do 
+                   if action <> mostCommonAction then  
+                       incr count;
+            
+            (* Write the head of the table (i.e. the number of entries and the default value) *)
+            actionTableCurrIndex <- actionTableCurrIndex + 1;
+            writer.WriteUInt16 !count;
+            writer.WriteUInt16 (generatorState.map_action_to_int mostCommonAction);
+            
+            (* Write the pairs of entries in incremental order by key *)
+            (* This lets us implement the lookup by a binary chop. *)
+            for terminal = 0 to Array.length actions-1 do  
+                let action = snd actions.[terminal] in 
+                if action <> mostCommonAction then  (
+                    actionTableCurrIndex <- actionTableCurrIndex + 1;
+                    writer.WriteUInt16 terminal;
+                    writer.WriteUInt16 (generatorState.map_action_to_int action);
+                );
+        writer.WriteLine "|]" ;
+        (* Output offsets into actions table where the actions for a particular nonterminal begin *)
+        writer.Write "let _fsyacc_actionTableRowOffsets = [|" ;
+        for j = 0 to numActionRows-1 do  
+            writer.WriteUInt16 actionIndexes.[j];
+        writer.WriteLine "|]" ;
+
+      end;
+      begin 
+          writer.Write "let _fsyacc_reductionSymbolCounts = [|" ;
+          for nt,ntIdx,syms,code in compiledSpec.prods do 
+              writer.WriteUInt16 (List.length syms);
+          writer.WriteLine "|]" ;
+      end;
+      begin 
+          writer.Write "let _fsyacc_productionToNonTerminalTable = [|" ;
+          for nt,ntIdx,syms,code in compiledSpec.prods do 
+              writer.WriteUInt16 ntIdx;
+          writer.WriteLine "|]" ;
+      end;
+      begin 
+          writer.Write "let _fsyacc_immediateActions = [|" ;
+          for prodIdx in compiledSpec.immediateActionTable do 
+              match prodIdx with
+                | None     -> writer.WriteUInt16 generatorState.anyMarker (* NONE REP *)
+                | Some act -> writer.WriteUInt16 (generatorState.map_action_to_int act)
+          writer.WriteLine "|]" ;
+      end;
+      
+      let getType nt = if types.ContainsKey nt then  types.[nt] else generatorState.generate_nonterminal_name nt
+      begin 
+          writer.WriteLine "let _fsyacc_reductions = lazy [|"
+          for nt,ntIdx,syms,code in compiledSpec.prods do 
+              writer.WriteLine "# %d \"%s\"" writer.OutputLineCount output;
+              writer.WriteLine "        (fun (parseState : %s.IParseState) ->"  generatorState.parslib
+              if generatorState.compat then 
+                  writer.WriteLine "            Parsing.set_parse_state parseState;"
+              syms |> List.iteri (fun i sym -> 
+                  let tyopt = 
+                      match sym with
+                      | Terminal t -> 
+                          if tokens.ContainsKey t then 
+                            tokens.[t]
+                          else None
+                      | NonTerminal nt -> Some (getType nt) 
+                  match tyopt with 
+                  | Some ty -> writer.WriteLine "            let _%d = parseState.GetInput(%d) :?> %s in" (i+1) (i+1) ty
+                  | None -> ())
+              writer.WriteLine "            Microsoft.FSharp.Core.Operators.box" 
+              writer.WriteLine "                (";
+              writer.WriteLine "                   (";
+              match code with 
+              | Some (_,pos) -> writer.WriteLine "# %d \"%s\"" pos.pos_lnum pos.pos_fname
+              | None -> ()
+              match code with 
+              | Some (code,_) -> 
+                  let dollar = ref false in 
+                  let c = code |> String.collect (fun c -> 
+                      if not !dollar && c = '$' then (dollar := true; "")
+                      elif !dollar && c >= '0' && c <= '9' then (dollar := false; "_"+String(c,1))
+                      elif !dollar then (dollar := false; "$"+String(c,1))
+                      else String(c,1))
+                  let lines = c.Split([| '\r'; '\n' |], StringSplitOptions.RemoveEmptyEntries);
+                  for line in lines do 
+                      writer.WriteLine "                     %s" line;
+                  if !dollar then writer.Write "$"
+              | None -> 
+                  writer.WriteLine "                      raise (%s.Accept(Microsoft.FSharp.Core.Operators.box _1))" generatorState.parslib
+              writer.WriteLine "                   )";
+              // Place the line count back for the type constraint
+              match code with 
+              | Some (_,pos) -> writer.WriteLine "# %d \"%s\"" pos.pos_lnum pos.pos_fname
+              | None -> ()
+              writer.WriteLine "                 : %s));" (if types.ContainsKey nt then  types.[nt] else generatorState.generate_nonterminal_name nt);
+          done;
+          writer.WriteLine "|]" ;
+      end;
+      writer.WriteLine "# %d \"%s\"" writer.OutputLineCount output;
+      writer.WriteLine "let tables : %s.Tables<_> = " generatorState.parslib
+      writer.WriteLine "  { reductions = _fsyacc_reductions.Value;"
+      writer.WriteLine "    endOfInputTag = _fsyacc_endOfInputTag;"
+      writer.WriteLine "    tagOfToken = tagOfToken;"
+      writer.WriteLine "    dataOfToken = _fsyacc_dataOfToken; "
+      writer.WriteLine "    actionTableElements = _fsyacc_actionTableElements;"
+      writer.WriteLine "    actionTableRowOffsets = _fsyacc_actionTableRowOffsets;"
+      writer.WriteLine "    stateToProdIdxsTableElements = _fsyacc_stateToProdIdxsTableElements;"
+      writer.WriteLine "    stateToProdIdxsTableRowOffsets = _fsyacc_stateToProdIdxsTableRowOffsets;"
+      writer.WriteLine "    reductionSymbolCounts = _fsyacc_reductionSymbolCounts;"
+      writer.WriteLine "    immediateActions = _fsyacc_immediateActions;"
+      writer.WriteLine "    gotos = _fsyacc_gotos;"
+      writer.WriteLine "    sparseGotoTableRowOffsets = _fsyacc_sparseGotoTableRowOffsets;"
+      writer.WriteLine "    tagOfErrorTerminal = _fsyacc_tagOfErrorTerminal;"
+      writer.WriteLine "    parseError = (fun (ctxt:%s.ParseErrorContext<_>) -> " generatorState.parslib
+      writer.WriteLine "                              match parse_error_rich with "
+      writer.WriteLine "                              | Some f -> f ctxt"
+      writer.WriteLine "                              | None -> parse_error ctxt.Message);"
+      
+      writer.WriteLine "    numTerminals = %d;" (Array.length compiledSpec.actionTable.[0]);
+      writer.WriteLine "    productionToNonTerminalTable = _fsyacc_productionToNonTerminalTable  }"
+      writer.WriteLine "let engine lexer lexbuf startState = tables.Interpret(lexer, lexbuf, startState)"                                                                                                         
+
+      for id,startState in List.zip spec.StartSymbols compiledSpec.startStates do
+            if not (types.ContainsKey id) then 
+              failwith ("a %type declaration is required for for start token "+id);
+            let ty = types.[id] in 
+            writer.WriteLine "let %s lexer lexbuf : %s =" id ty;
+            writer.WriteLine "    engine lexer lexbuf %d :?> _" startState
+
+      for id in spec.StartSymbols do
+          if not (types.ContainsKey id) then 
+            failwith ("a %type declaration is required for start token "+id);
+          let ty = types.[id] in 
+          writer.WriteLineInterface "val %s : (%s.LexBuffer<%s> -> token) -> %s.LexBuffer<%s> -> (%s) " id generatorState.lexlib tychar generatorState.lexlib tychar ty;
+
+
+let compileSpec (spec: ParserSpec) (logger: Logger) = 
+  let spec1 = ProcessParserSpecAst spec 
+  CompilerLalrParserSpec logger.LogStream spec1 
diff --git a/buildtools/fsyacc/fsyacclex.fs b/buildtools/fsyacc/fsyacclex.fs
index a035f6fe012..5b99ce61cdd 100644
--- a/buildtools/fsyacc/fsyacclex.fs
+++ b/buildtools/fsyacc/fsyacclex.fs
@@ -2,12 +2,12 @@
  
 (* (c) Microsoft Corporation 2005-2008.  *)
 
-module internal FsLexYacc.FsYacc.Lexer
+module FsLexYacc.FsYacc.Lexer
   
 open FsLexYacc.FsYacc.AST
 open FsLexYacc.FsYacc.Parser
 open System.Text
-open Internal.Utilities.Text.Lexing
+open FSharp.Text.Lexing
 
 let lexeme  (lexbuf : LexBuffer<char>) = new System.String(lexbuf.Lexeme)
 let newline (lexbuf:LexBuffer<_>) = lexbuf.EndPos <- lexbuf.EndPos.NextLine
@@ -290,92 +290,80 @@ let trans : uint16[] array =
      [| 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 130us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 130us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 129us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; |];
     |] 
 let actions : uint16[] = [|65535us; 5us; 1us; 5us; 5us; 3us; 4us; 5us; 4us; 2us; 1us; 0us; 65535us; 5us; 1us; 2us; 5us; 3us; 4us; 5us; 3us; 2us; 0us; 65535us; 0us; 1us; 2us; 8us; 8us; 4us; 5us; 8us; 7us; 8us; 6us; 6us; 5us; 65535us; 65535us; 65535us; 3us; 2us; 65535us; 7us; 1us; 7us; 2us; 7us; 7us; 5us; 6us; 7us; 65535us; 65535us; 65535us; 4us; 3us; 3us; 2us; 1us; 0us; 65535us; 0us; 1us; 2us; 65535us; 22us; 17us; 11us; 12us; 13us; 14us; 15us; 16us; 22us; 17us; 18us; 22us; 21us; 22us; 23us; 19us; 20us; 20us; 17us; 16us; 15us; 17us; 17us; 17us; 10us; 0us; 1us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 65535us; 9us; 65535us; 65535us; 65535us; 8us; 65535us; 65535us; 7us; 65535us; 65535us; 5us; 65535us; 65535us; 65535us; 4us; 65535us; 65535us; 65535us; 65535us; 6us; 65535us; 65535us; 65535us; 3us; 2us; 65535us; |]
-let _fslex_tables = Internal.Utilities.Text.Lexing.UnicodeTables.Create(trans,actions)
+let _fslex_tables = FSharp.Text.Lexing.UnicodeTables.Create(trans,actions)
 let rec _fslex_dummy () = _fslex_dummy() 
-(* Rule token *)
-and token  (lexbuf : Internal.Utilities.Text.Lexing.LexBuffer<_>) = _fslex_token  65 lexbuf
-(* Rule fs_type *)
-and fs_type  (lexbuf : Internal.Utilities.Text.Lexing.LexBuffer<_>) = _fslex_fs_type  61 lexbuf
-(* Rule header *)
-and header p buff (lexbuf : Internal.Utilities.Text.Lexing.LexBuffer<_>) = _fslex_header p buff 42 lexbuf
-(* Rule code *)
-and code p buff (lexbuf : Internal.Utilities.Text.Lexing.LexBuffer<_>) = _fslex_code p buff 23 lexbuf
-(* Rule codestring *)
-and codestring buff (lexbuf : Internal.Utilities.Text.Lexing.LexBuffer<_>) = _fslex_codestring buff 12 lexbuf
-(* Rule comment *)
-and comment  (lexbuf : Internal.Utilities.Text.Lexing.LexBuffer<_>) = _fslex_comment  0 lexbuf
-(* Rule token *)
-and _fslex_token  _fslex_state lexbuf =
-  match _fslex_tables.Interpret(_fslex_state,lexbuf) with
+// Rule token
+and token  lexbuf =
+  match _fslex_tables.Interpret(65,lexbuf) with
   | 0 -> ( 
 # 35 "fsyacclex.fsl"
                          let p = lexbuf.StartPos in header p (new StringBuilder 100) lexbuf 
-# 313 "fsyacclex.fs"
+# 301 "fsyacclex.fs"
           )
   | 1 -> ( 
 # 36 "fsyacclex.fsl"
                          PERCENT_PERCENT 
-# 318 "fsyacclex.fs"
+# 306 "fsyacclex.fs"
           )
   | 2 -> ( 
 # 37 "fsyacclex.fsl"
                                                typeDepth := 1; startPos := lexbuf.StartPos; clearBuf(); TOKEN (fs_type lexbuf) 
-# 323 "fsyacclex.fs"
+# 311 "fsyacclex.fs"
           )
   | 3 -> ( 
 # 38 "fsyacclex.fsl"
                              TOKEN (None) 
-# 328 "fsyacclex.fs"
+# 316 "fsyacclex.fs"
           )
   | 4 -> ( 
 # 39 "fsyacclex.fsl"
                             START 
-# 333 "fsyacclex.fs"
+# 321 "fsyacclex.fs"
           )
   | 5 -> ( 
 # 40 "fsyacclex.fsl"
                            PREC 
-# 338 "fsyacclex.fs"
+# 326 "fsyacclex.fs"
           )
   | 6 -> ( 
 # 41 "fsyacclex.fsl"
                                               typeDepth := 1; startPos := lexbuf.StartPos; clearBuf(); TYPE (match fs_type lexbuf with Some x -> x | None -> failwith "gettype") 
-# 343 "fsyacclex.fs"
+# 331 "fsyacclex.fs"
           )
   | 7 -> ( 
 # 42 "fsyacclex.fsl"
                             LEFT 
-# 348 "fsyacclex.fs"
+# 336 "fsyacclex.fs"
           )
   | 8 -> ( 
 # 43 "fsyacclex.fsl"
                              RIGHT 
-# 353 "fsyacclex.fs"
+# 341 "fsyacclex.fs"
           )
   | 9 -> ( 
 # 44 "fsyacclex.fsl"
                                 NONASSOC 
-# 358 "fsyacclex.fs"
+# 346 "fsyacclex.fs"
           )
   | 10 -> ( 
 # 45 "fsyacclex.fsl"
                             ERROR 
-# 363 "fsyacclex.fs"
+# 351 "fsyacclex.fs"
           )
   | 11 -> ( 
 # 46 "fsyacclex.fsl"
                         LESS 
-# 368 "fsyacclex.fs"
+# 356 "fsyacclex.fs"
           )
   | 12 -> ( 
 # 47 "fsyacclex.fsl"
                         GREATER 
-# 373 "fsyacclex.fs"
+# 361 "fsyacclex.fs"
           )
   | 13 -> ( 
 # 48 "fsyacclex.fsl"
                         SEMI 
-# 378 "fsyacclex.fs"
+# 366 "fsyacclex.fs"
           )
   | 14 -> ( 
 # 49 "fsyacclex.fsl"
@@ -384,61 +372,61 @@ and _fslex_token  _fslex_state lexbuf =
                         // adjust the first line to get even indentation for all lines w.r.t. the left hand margin
                         buff.Append (String.replicate (lexbuf.StartPos.Column+1) " ")  |> ignore;
                         code p buff lexbuf 
-# 387 "fsyacclex.fs"
+# 375 "fsyacclex.fs"
           )
   | 15 -> ( 
 # 54 "fsyacclex.fsl"
                                  token lexbuf 
-# 392 "fsyacclex.fs"
+# 380 "fsyacclex.fs"
           )
   | 16 -> ( 
 # 55 "fsyacclex.fsl"
                             newline lexbuf; token lexbuf 
-# 397 "fsyacclex.fs"
+# 385 "fsyacclex.fs"
           )
   | 17 -> ( 
 # 56 "fsyacclex.fsl"
                                                  IDENT (lexeme lexbuf) 
-# 402 "fsyacclex.fs"
+# 390 "fsyacclex.fs"
           )
   | 18 -> ( 
 # 57 "fsyacclex.fsl"
                         BAR 
-# 407 "fsyacclex.fs"
+# 395 "fsyacclex.fs"
           )
   | 19 -> ( 
 # 58 "fsyacclex.fsl"
                          ignore(comment lexbuf); token lexbuf 
-# 412 "fsyacclex.fs"
+# 400 "fsyacclex.fs"
           )
   | 20 -> ( 
 # 59 "fsyacclex.fsl"
                                        token lexbuf  
-# 417 "fsyacclex.fs"
+# 405 "fsyacclex.fs"
           )
   | 21 -> ( 
 # 60 "fsyacclex.fsl"
                         COLON 
-# 422 "fsyacclex.fs"
+# 410 "fsyacclex.fs"
           )
   | 22 -> ( 
 # 61 "fsyacclex.fsl"
                       unexpected_char lexbuf 
-# 427 "fsyacclex.fs"
+# 415 "fsyacclex.fs"
           )
   | 23 -> ( 
 # 62 "fsyacclex.fsl"
                         EOF  
-# 432 "fsyacclex.fs"
+# 420 "fsyacclex.fs"
           )
   | _ -> failwith "token"
-(* Rule fs_type *)
-and _fslex_fs_type  _fslex_state lexbuf =
-  match _fslex_tables.Interpret(_fslex_state,lexbuf) with
+// Rule fs_type
+and fs_type  lexbuf =
+  match _fslex_tables.Interpret(61,lexbuf) with
   | 0 -> ( 
 # 65 "fsyacclex.fsl"
                          incr typeDepth; appendBuf(lexeme lexbuf); fs_type lexbuf
-# 441 "fsyacclex.fs"
+# 429 "fsyacclex.fs"
           )
   | 1 -> ( 
 # 67 "fsyacclex.fsl"
@@ -446,73 +434,73 @@ and _fslex_fs_type  _fslex_state lexbuf =
                      if !typeDepth = 0
                      then Some(string str_buf) 
                      else appendBuf(lexeme lexbuf); fs_type lexbuf 
-# 449 "fsyacclex.fs"
+# 437 "fsyacclex.fs"
           )
   | 2 -> ( 
 # 71 "fsyacclex.fsl"
                        appendBuf(lexeme lexbuf); fs_type lexbuf 
-# 454 "fsyacclex.fs"
+# 442 "fsyacclex.fs"
           )
   | _ -> failwith "fs_type"
-(* Rule header *)
-and _fslex_header p buff _fslex_state lexbuf =
-  match _fslex_tables.Interpret(_fslex_state,lexbuf) with
+// Rule header
+and header p buff lexbuf =
+  match _fslex_tables.Interpret(42,lexbuf) with
   | 0 -> ( 
 # 74 "fsyacclex.fsl"
                          HEADER (buff.ToString(), p) 
-# 463 "fsyacclex.fs"
+# 451 "fsyacclex.fs"
           )
   | 1 -> ( 
 # 75 "fsyacclex.fsl"
                             newline lexbuf; 
                             ignore <| buff.Append System.Environment.NewLine; 
                             header p buff lexbuf 
-# 470 "fsyacclex.fs"
+# 458 "fsyacclex.fs"
           )
   | 2 -> ( 
 # 79 "fsyacclex.fsl"
                        ignore <| buff.Append (lexeme lexbuf); 
                        header p buff lexbuf 
-# 476 "fsyacclex.fs"
+# 464 "fsyacclex.fs"
           )
   | 3 -> ( 
 # 82 "fsyacclex.fsl"
                        ignore <| buff.Append (lexeme lexbuf); 
                        header p buff lexbuf 
-# 482 "fsyacclex.fs"
+# 470 "fsyacclex.fs"
           )
   | 4 -> ( 
 # 85 "fsyacclex.fsl"
                        ignore <| buff.Append (lexeme lexbuf); 
                        header p buff lexbuf 
-# 488 "fsyacclex.fs"
+# 476 "fsyacclex.fs"
           )
   | 5 -> ( 
 # 88 "fsyacclex.fsl"
                        ignore <| buff.Append (lexeme lexbuf); 
                        ignore(codestring buff lexbuf); 
                        header p buff lexbuf 
-# 495 "fsyacclex.fs"
+# 483 "fsyacclex.fs"
           )
   | 6 -> ( 
 # 91 "fsyacclex.fsl"
                         EOF 
-# 500 "fsyacclex.fs"
+# 488 "fsyacclex.fs"
           )
   | 7 -> ( 
 # 92 "fsyacclex.fsl"
                       ignore <| buff.Append(lexeme lexbuf).[0]; 
                       header p buff lexbuf 
-# 506 "fsyacclex.fs"
+# 494 "fsyacclex.fs"
           )
   | _ -> failwith "header"
-(* Rule code *)
-and _fslex_code p buff _fslex_state lexbuf =
-  match _fslex_tables.Interpret(_fslex_state,lexbuf) with
+// Rule code
+and code p buff lexbuf =
+  match _fslex_tables.Interpret(23,lexbuf) with
   | 0 -> ( 
 # 95 "fsyacclex.fsl"
                         CODE (buff.ToString(), p) 
-# 515 "fsyacclex.fs"
+# 503 "fsyacclex.fs"
           )
   | 1 -> ( 
 # 96 "fsyacclex.fsl"
@@ -520,124 +508,124 @@ and _fslex_code p buff _fslex_state lexbuf =
                         ignore(code p buff lexbuf); 
                         ignore <| buff.Append "}"; 
                         code p buff lexbuf 
-# 523 "fsyacclex.fs"
+# 511 "fsyacclex.fs"
           )
   | 2 -> ( 
 # 100 "fsyacclex.fsl"
                             newline lexbuf; 
                             ignore <| buff.Append System.Environment.NewLine; 
                             code p buff lexbuf 
-# 530 "fsyacclex.fs"
+# 518 "fsyacclex.fs"
           )
   | 3 -> ( 
 # 104 "fsyacclex.fsl"
                        ignore <| buff.Append (lexeme lexbuf); 
                        code p buff lexbuf 
-# 536 "fsyacclex.fs"
+# 524 "fsyacclex.fs"
           )
   | 4 -> ( 
 # 106 "fsyacclex.fsl"
                          ignore <| buff.Append (lexeme lexbuf); 
                          ignore(codestring buff lexbuf); 
                          code p buff lexbuf 
-# 543 "fsyacclex.fs"
+# 531 "fsyacclex.fs"
           )
   | 5 -> ( 
 # 110 "fsyacclex.fsl"
                     ignore <| buff.Append (lexeme lexbuf); 
                     code p buff lexbuf 
-# 549 "fsyacclex.fs"
+# 537 "fsyacclex.fs"
           )
   | 6 -> ( 
 # 113 "fsyacclex.fsl"
                     ignore <| buff.Append (lexeme lexbuf); 
                     code p buff lexbuf 
-# 555 "fsyacclex.fs"
+# 543 "fsyacclex.fs"
           )
   | 7 -> ( 
 # 115 "fsyacclex.fsl"
                         EOF 
-# 560 "fsyacclex.fs"
+# 548 "fsyacclex.fs"
           )
   | 8 -> ( 
 # 116 "fsyacclex.fsl"
                       ignore <| buff.Append(lexeme lexbuf).[0]; 
                       code p buff lexbuf 
-# 566 "fsyacclex.fs"
+# 554 "fsyacclex.fs"
           )
   | _ -> failwith "code"
-(* Rule codestring *)
-and _fslex_codestring buff _fslex_state lexbuf =
-  match _fslex_tables.Interpret(_fslex_state,lexbuf) with
+// Rule codestring
+and codestring buff lexbuf =
+  match _fslex_tables.Interpret(12,lexbuf) with
   | 0 -> ( 
 # 122 "fsyacclex.fsl"
                     ignore <| buff.Append (lexeme lexbuf); 
                     codestring buff lexbuf 
-# 576 "fsyacclex.fs"
+# 564 "fsyacclex.fs"
           )
   | 1 -> ( 
 # 124 "fsyacclex.fsl"
                         ignore <| buff.Append (lexeme lexbuf); 
                         buff.ToString() 
-# 582 "fsyacclex.fs"
+# 570 "fsyacclex.fs"
           )
   | 2 -> ( 
 # 126 "fsyacclex.fsl"
                             newline lexbuf; 
                             ignore <| buff.Append System.Environment.NewLine; 
                             codestring buff lexbuf 
-# 589 "fsyacclex.fs"
+# 577 "fsyacclex.fs"
           )
   | 3 -> ( 
 # 130 "fsyacclex.fsl"
                     ignore <| buff.Append (lexeme lexbuf); 
                     codestring buff lexbuf 
-# 595 "fsyacclex.fs"
+# 583 "fsyacclex.fs"
           )
   | 4 -> ( 
 # 132 "fsyacclex.fsl"
                         failwith "unterminated string in code" 
-# 600 "fsyacclex.fs"
+# 588 "fsyacclex.fs"
           )
   | 5 -> ( 
 # 133 "fsyacclex.fsl"
                       ignore <| buff.Append(lexeme lexbuf).[0]; 
                       codestring buff lexbuf 
-# 606 "fsyacclex.fs"
+# 594 "fsyacclex.fs"
           )
   | _ -> failwith "codestring"
-(* Rule comment *)
-and _fslex_comment  _fslex_state lexbuf =
-  match _fslex_tables.Interpret(_fslex_state,lexbuf) with
+// Rule comment
+and comment  lexbuf =
+  match _fslex_tables.Interpret(0,lexbuf) with
   | 0 -> ( 
 # 138 "fsyacclex.fsl"
                          ignore(comment lexbuf); comment lexbuf 
-# 615 "fsyacclex.fs"
+# 603 "fsyacclex.fs"
           )
   | 1 -> ( 
 # 139 "fsyacclex.fsl"
                             newline lexbuf; comment lexbuf 
-# 620 "fsyacclex.fs"
+# 608 "fsyacclex.fs"
           )
   | 2 -> ( 
 # 140 "fsyacclex.fsl"
                          () 
-# 625 "fsyacclex.fs"
+# 613 "fsyacclex.fs"
           )
   | 3 -> ( 
 # 141 "fsyacclex.fsl"
                         failwith "end of file in comment" 
-# 630 "fsyacclex.fs"
+# 618 "fsyacclex.fs"
           )
   | 4 -> ( 
 # 142 "fsyacclex.fsl"
                                                      comment lexbuf 
-# 635 "fsyacclex.fs"
+# 623 "fsyacclex.fs"
           )
   | 5 -> ( 
 # 143 "fsyacclex.fsl"
                        comment lexbuf 
-# 640 "fsyacclex.fs"
+# 628 "fsyacclex.fs"
           )
   | _ -> failwith "comment"
 
diff --git a/buildtools/fsyacc/fsyaccpars.fs b/buildtools/fsyacc/fsyaccpars.fs
index c6d614f2694..504e1cb55ed 100644
--- a/buildtools/fsyacc/fsyaccpars.fs
+++ b/buildtools/fsyacc/fsyaccpars.fs
@@ -1,8 +1,8 @@
 // Implementation file for parser generated by fsyacc
-module internal FsLexYacc.FsYacc.Parser
+module FsLexYacc.FsYacc.Parser
 #nowarn "64";; // turn off warnings that type variables used in production annotations are instantiated to concrete type
-open Internal.Utilities.Text.Lexing
-open Internal.Utilities.Text.Parsing.ParseHelpers
+open FSharp.Text.Lexing
+open FSharp.Text.Parsing.ParseHelpers
 # 1 "fsyaccpars.fsy"
 
 (* (c) Microsoft Corporation 2005-2008.  *)
@@ -214,19 +214,19 @@ let _fsyacc_productionToNonTerminalTable = [|0us; 1us; 2us; 2us; 3us; 3us; 4us;
 let _fsyacc_immediateActions = [|65535us; 49152us; 65535us; 65535us; 65535us; 16385us; 16386us; 65535us; 16389us; 65535us; 16390us; 65535us; 16391us; 65535us; 16392us; 65535us; 16393us; 65535us; 16394us; 65535us; 16395us; 65535us; 16396us; 65535us; 16398us; 65535us; 65535us; 65535us; 65535us; 16400us; 16402us; 16404us; 65535us; 65535us; 16405us; 65535us; 65535us; 16407us; 65535us; 16408us; 65535us; 16409us; 65535us; 16412us; |]
 let _fsyacc_reductions ()  =    [| 
 # 216 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : AST.ParserSpec)) in
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> AST.ParserSpec in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-                      raise (Internal.Utilities.Text.Parsing.Accept(Microsoft.FSharp.Core.Operators.box _1))
+                      raise (FSharp.Text.Parsing.Accept(Microsoft.FSharp.Core.Operators.box _1))
                    )
-                 : '_startspec));
+                 : 'gentype__startspec));
 # 225 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : 'headeropt)) in
-            let _2 = (let data = parseState.GetInput(2) in (Microsoft.FSharp.Core.Operators.unbox data : 'decls)) in
-            let _4 = (let data = parseState.GetInput(4) in (Microsoft.FSharp.Core.Operators.unbox data : 'rules)) in
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> 'gentype_headeropt in
+            let _2 = parseState.GetInput(2) :?> 'gentype_decls in
+            let _4 = parseState.GetInput(4) :?> 'gentype_rules in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -236,8 +236,8 @@ let _fsyacc_reductions ()  =    [|
 # 25 "fsyaccpars.fsy"
                  : AST.ParserSpec));
 # 238 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : AST.Code)) in
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> AST.Code in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -245,9 +245,9 @@ let _fsyacc_reductions ()  =    [|
                               _1 
                    )
 # 29 "fsyaccpars.fsy"
-                 : 'headeropt));
+                 : 'gentype_headeropt));
 # 249 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -255,9 +255,9 @@ let _fsyacc_reductions ()  =    [|
                              "", (parseState.ResultRange |> fst)
                    )
 # 31 "fsyaccpars.fsy"
-                 : 'headeropt));
+                 : 'gentype_headeropt));
 # 259 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -265,11 +265,11 @@ let _fsyacc_reductions ()  =    [|
                            [] 
                    )
 # 34 "fsyaccpars.fsy"
-                 : 'decls));
+                 : 'gentype_decls));
 # 269 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : 'decl)) in
-            let _2 = (let data = parseState.GetInput(2) in (Microsoft.FSharp.Core.Operators.unbox data : 'decls)) in
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> 'gentype_decl in
+            let _2 = parseState.GetInput(2) :?> 'gentype_decls in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -277,11 +277,11 @@ let _fsyacc_reductions ()  =    [|
                                       _1 :: _2 
                    )
 # 35 "fsyaccpars.fsy"
-                 : 'decls));
+                 : 'gentype_decls));
 # 281 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : string option)) in
-            let _2 = (let data = parseState.GetInput(2) in (Microsoft.FSharp.Core.Operators.unbox data : 'idents)) in
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> string option in
+            let _2 = parseState.GetInput(2) :?> 'gentype_idents in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -289,11 +289,11 @@ let _fsyacc_reductions ()  =    [|
                                         (fun x -> {x with Tokens = x.Tokens @ (List.map (fun x -> (x,_1)) _2)}) 
                    )
 # 38 "fsyaccpars.fsy"
-                 : 'decl));
+                 : 'gentype_decl));
 # 293 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : string)) in
-            let _2 = (let data = parseState.GetInput(2) in (Microsoft.FSharp.Core.Operators.unbox data : 'idents)) in
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> string in
+            let _2 = parseState.GetInput(2) :?> 'gentype_idents in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -301,10 +301,10 @@ let _fsyacc_reductions ()  =    [|
                                          (fun x -> {x with Types = x.Types @ (List.map (fun x -> (x,_1)) _2)} ) 
                    )
 # 39 "fsyaccpars.fsy"
-                 : 'decl));
+                 : 'gentype_decl));
 # 305 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _2 = (let data = parseState.GetInput(2) in (Microsoft.FSharp.Core.Operators.unbox data : 'idents)) in
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _2 = parseState.GetInput(2) :?> 'gentype_idents in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -312,10 +312,10 @@ let _fsyacc_reductions ()  =    [|
                                           (fun x -> {x with StartSymbols = x.StartSymbols @ _2} ) 
                    )
 # 40 "fsyaccpars.fsy"
-                 : 'decl));
+                 : 'gentype_decl));
 # 316 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _2 = (let data = parseState.GetInput(2) in (Microsoft.FSharp.Core.Operators.unbox data : 'idents)) in
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _2 = parseState.GetInput(2) :?> 'gentype_idents in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -323,10 +323,10 @@ let _fsyacc_reductions ()  =    [|
                                          (fun x -> {x with Associativities = x.Associativities @ [(List.map (fun x -> (x,LeftAssoc)) _2)]} ) 
                    )
 # 41 "fsyaccpars.fsy"
-                 : 'decl));
+                 : 'gentype_decl));
 # 327 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _2 = (let data = parseState.GetInput(2) in (Microsoft.FSharp.Core.Operators.unbox data : 'idents)) in
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _2 = parseState.GetInput(2) :?> 'gentype_idents in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -334,10 +334,10 @@ let _fsyacc_reductions ()  =    [|
                                           (fun x -> {x with Associativities = x.Associativities @ [(List.map (fun x -> (x,RightAssoc)) _2)]} ) 
                    )
 # 42 "fsyaccpars.fsy"
-                 : 'decl));
+                 : 'gentype_decl));
 # 338 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _2 = (let data = parseState.GetInput(2) in (Microsoft.FSharp.Core.Operators.unbox data : 'idents)) in
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _2 = parseState.GetInput(2) :?> 'gentype_idents in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -345,11 +345,11 @@ let _fsyacc_reductions ()  =    [|
                                              (fun x -> {x with Associativities = x.Associativities @ [(List.map (fun x -> (x,NonAssoc)) _2)]} ) 
                    )
 # 43 "fsyaccpars.fsy"
-                 : 'decl));
+                 : 'gentype_decl));
 # 349 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : string)) in
-            let _2 = (let data = parseState.GetInput(2) in (Microsoft.FSharp.Core.Operators.unbox data : 'idents)) in
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> string in
+            let _2 = parseState.GetInput(2) :?> 'gentype_idents in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -357,9 +357,9 @@ let _fsyacc_reductions ()  =    [|
                                             _1 :: _2 
                    )
 # 45 "fsyaccpars.fsy"
-                 : 'idents));
+                 : 'gentype_idents));
 # 361 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -367,11 +367,11 @@ let _fsyacc_reductions ()  =    [|
                                                            [] 
                    )
 # 45 "fsyaccpars.fsy"
-                 : 'idents));
+                 : 'gentype_idents));
 # 371 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : 'rule)) in
-            let _2 = (let data = parseState.GetInput(2) in (Microsoft.FSharp.Core.Operators.unbox data : 'rules)) in
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> 'gentype_rule in
+            let _2 = parseState.GetInput(2) :?> 'gentype_rules in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -379,10 +379,10 @@ let _fsyacc_reductions ()  =    [|
                                          _1 :: _2 
                    )
 # 46 "fsyaccpars.fsy"
-                 : 'rules));
+                 : 'gentype_rules));
 # 383 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : 'rule)) in
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> 'gentype_rule in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -390,13 +390,13 @@ let _fsyacc_reductions ()  =    [|
                                                              [_1] 
                    )
 # 46 "fsyaccpars.fsy"
-                 : 'rules));
+                 : 'gentype_rules));
 # 394 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : string)) in
-            let _3 = (let data = parseState.GetInput(3) in (Microsoft.FSharp.Core.Operators.unbox data : 'optbar)) in
-            let _4 = (let data = parseState.GetInput(4) in (Microsoft.FSharp.Core.Operators.unbox data : 'clauses)) in
-            let _5 = (let data = parseState.GetInput(5) in (Microsoft.FSharp.Core.Operators.unbox data : 'optsemi)) in
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> string in
+            let _3 = parseState.GetInput(3) :?> 'gentype_optbar in
+            let _4 = parseState.GetInput(4) :?> 'gentype_clauses in
+            let _5 = parseState.GetInput(5) :?> 'gentype_optsemi in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -404,9 +404,9 @@ let _fsyacc_reductions ()  =    [|
                                                                 (_1,_4) 
                    )
 # 47 "fsyaccpars.fsy"
-                 : 'rule));
+                 : 'gentype_rule));
 # 408 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -414,9 +414,9 @@ let _fsyacc_reductions ()  =    [|
                                
                    )
 # 48 "fsyaccpars.fsy"
-                 : 'optbar));
+                 : 'gentype_optbar));
 # 418 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -424,9 +424,9 @@ let _fsyacc_reductions ()  =    [|
                                          
                    )
 # 48 "fsyaccpars.fsy"
-                 : 'optbar));
+                 : 'gentype_optbar));
 # 428 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -434,9 +434,9 @@ let _fsyacc_reductions ()  =    [|
                                 
                    )
 # 49 "fsyaccpars.fsy"
-                 : 'optsemi));
+                 : 'gentype_optsemi));
 # 438 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -444,11 +444,11 @@ let _fsyacc_reductions ()  =    [|
                                            
                    )
 # 49 "fsyaccpars.fsy"
-                 : 'optsemi));
+                 : 'gentype_optsemi));
 # 448 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : 'clause)) in
-            let _3 = (let data = parseState.GetInput(3) in (Microsoft.FSharp.Core.Operators.unbox data : 'clauses)) in
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> 'gentype_clause in
+            let _3 = parseState.GetInput(3) :?> 'gentype_clauses in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -456,10 +456,10 @@ let _fsyacc_reductions ()  =    [|
                                                   _1 :: _3 
                    )
 # 50 "fsyaccpars.fsy"
-                 : 'clauses));
+                 : 'gentype_clauses));
 # 460 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : 'clause)) in
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> 'gentype_clause in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -467,12 +467,12 @@ let _fsyacc_reductions ()  =    [|
                                                                         [_1] 
                    )
 # 50 "fsyaccpars.fsy"
-                 : 'clauses));
+                 : 'gentype_clauses));
 # 471 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : 'syms)) in
-            let _2 = (let data = parseState.GetInput(2) in (Microsoft.FSharp.Core.Operators.unbox data : 'optprec)) in
-            let _3 = (let data = parseState.GetInput(3) in (Microsoft.FSharp.Core.Operators.unbox data : AST.Code)) in
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> 'gentype_syms in
+            let _2 = parseState.GetInput(2) :?> 'gentype_optprec in
+            let _3 = parseState.GetInput(3) :?> AST.Code in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -480,11 +480,11 @@ let _fsyacc_reductions ()  =    [|
                                                  Rule(_1,_2,Some _3) 
                    )
 # 51 "fsyaccpars.fsy"
-                 : 'clause));
+                 : 'gentype_clause));
 # 484 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _1 = (let data = parseState.GetInput(1) in (Microsoft.FSharp.Core.Operators.unbox data : string)) in
-            let _2 = (let data = parseState.GetInput(2) in (Microsoft.FSharp.Core.Operators.unbox data : 'syms)) in
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> string in
+            let _2 = parseState.GetInput(2) :?> 'gentype_syms in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -492,10 +492,10 @@ let _fsyacc_reductions ()  =    [|
                                         _1 :: _2 
                    )
 # 52 "fsyaccpars.fsy"
-                 : 'syms));
+                 : 'gentype_syms));
 # 496 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _2 = (let data = parseState.GetInput(2) in (Microsoft.FSharp.Core.Operators.unbox data : 'syms)) in
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _2 = parseState.GetInput(2) :?> 'gentype_syms in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -503,9 +503,9 @@ let _fsyacc_reductions ()  =    [|
                                                                   "error" :: _2 
                    )
 # 52 "fsyaccpars.fsy"
-                 : 'syms));
+                 : 'gentype_syms));
 # 507 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -513,9 +513,9 @@ let _fsyacc_reductions ()  =    [|
                                                                                       [] 
                    )
 # 52 "fsyaccpars.fsy"
-                 : 'syms));
+                 : 'gentype_syms));
 # 517 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -523,10 +523,10 @@ let _fsyacc_reductions ()  =    [|
                                 None 
                    )
 # 53 "fsyaccpars.fsy"
-                 : 'optprec));
+                 : 'gentype_optprec));
 # 527 "fsyaccpars.fs"
-        (fun (parseState : Internal.Utilities.Text.Parsing.IParseState) ->
-            let _2 = (let data = parseState.GetInput(2) in (Microsoft.FSharp.Core.Operators.unbox data : string)) in
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _2 = parseState.GetInput(2) :?> string in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
@@ -534,10 +534,10 @@ let _fsyacc_reductions ()  =    [|
                                                       Some _2 
                    )
 # 53 "fsyaccpars.fsy"
-                 : 'optprec));
+                 : 'gentype_optprec));
 |]
 # 539 "fsyaccpars.fs"
-let tables () : Internal.Utilities.Text.Parsing.Tables<_> = 
+let tables : FSharp.Text.Parsing.Tables<_> = 
   { reductions= _fsyacc_reductions ();
     endOfInputTag = _fsyacc_endOfInputTag;
     tagOfToken = tagOfToken;
@@ -551,12 +551,12 @@ let tables () : Internal.Utilities.Text.Parsing.Tables<_> =
     gotos = _fsyacc_gotos;
     sparseGotoTableRowOffsets = _fsyacc_sparseGotoTableRowOffsets;
     tagOfErrorTerminal = _fsyacc_tagOfErrorTerminal;
-    parseError = (fun (ctxt:Internal.Utilities.Text.Parsing.ParseErrorContext<_>) -> 
+    parseError = (fun (ctxt:FSharp.Text.Parsing.ParseErrorContext<_>) -> 
                               match parse_error_rich with 
                               | Some f -> f ctxt
                               | None -> parse_error ctxt.Message);
     numTerminals = 21;
     productionToNonTerminalTable = _fsyacc_productionToNonTerminalTable  }
-let engine lexer lexbuf startState = (tables ()).Interpret(lexer, lexbuf, startState)
+let engine lexer lexbuf startState = tables.Interpret(lexer, lexbuf, startState)
 let spec lexer lexbuf : AST.ParserSpec =
-    Microsoft.FSharp.Core.Operators.unbox ((tables ()).Interpret(lexer, lexbuf, 0))
+    engine lexer lexbuf 0 :?> _
diff --git a/docs/diagnostics.md b/docs/diagnostics.md
index 026e3b256ba..784d1491c0b 100644
--- a/docs/diagnostics.md
+++ b/docs/diagnostics.md
@@ -32,7 +32,7 @@ Adding or adjusting diagnostics emitted by the compiler is usually straightforwa
 4. Use another search tool or a tool like Find All References / Find Usages to see where it's used in the compiler source code.
 5. Set a breakpoint at the location in source you found. If you debug the compiler with the same steps, it should trigger the breakpoint you set. This verifies that the location you found is the one that emits the error or warning you want to improve.
 
-From here, you can either simply update the error test, or you can use some of the information at the point in the source code you identified to see if there is more information to include in the error message. For example, if the error message doesn't contain information about the identifier the user is using incorrectly, you may be able to include the name of the identifier based on data the compiler has available at that stage of compilation.
+From here, you can either simply update the error text, or you can use some of the information at the point in the source code you identified to see if there is more information to include in the error message. For example, if the error message doesn't contain information about the identifier the user is using incorrectly, you may be able to include the name of the identifier based on data the compiler has available at that stage of compilation.
 
 If you're including data from user code in an error message, it's important to also write a test that verifies the exact error message for a given string of F# code.
 
@@ -55,3 +55,12 @@ Diagnostics must often format types.
 * When displaying multiple types in a comparative way, for example, two types that didn't match, you will want to display the minimal amount of infomation to convey the fact that the two types are different, for example, `NicePrint.minimalStringsOfTwoTypes`.
 
 * When displaying a type, you have the option of displaying the constraints implied by any type variables mentioned in the types, appended as `when ...`. For example, `NicePrint.layoutPrettifiedTypeAndConstraints`.
+
+## Localization
+
+The file `FSComp.txt` contains the canonical listing of diagnostic messages, but there are also `.xlf` localization files for various languages.
+See [the DEVGUIDE](../DEVGUIDE.md#updating-fscompfs-fscompresx-and-xlf) for more details.
+
+## Enabling a warning or error by default
+
+The file `CompilerDiagnostics.fs` contains the function `IsWarningOrInfoEnabled`, which determines whether a given diagnostic is emitted.
diff --git a/docs/overview.md b/docs/overview.md
index f66d80ae613..1c796bbd87d 100644
--- a/docs/overview.md
+++ b/docs/overview.md
@@ -49,7 +49,7 @@ The following are the most relevant parts of the F# compiler tooling, making up
 
 * The corresponding APIs wrapping and accessing these structures in the public-facing [`FSharp.Compiler.Service` API](https://github.com/dotnet/fsharp/tree/main/src/Compiler/Service) and [Symbol API](https://github.com/dotnet/fsharp/tree/main/src/Compiler/Symbols).
 
-* The [F# Compiler Service Caches](https://fsharp.github.io/FSharp.Compiler.Service/caches.html), the various caches maintained by an instance of an `FSharpChecker`.
+* The [F# Compiler Service Caches](https://fsharp.github.io/fsharp-compiler-docs/fcs/caches.html), the various caches maintained by an instance of an `FSharpChecker`.
 
 ## Key compiler phases
 
@@ -137,7 +137,7 @@ The following are the key phases and high-level logical operations of the F# com
 
 * _Resolving references_. For .NET SDK generally references are resolved explicitly by external tooling.
    There is a legacy aspect to this if references use old .NET Framework references including for
-   scripting.  See [ReferenceResolver.fs](https://github.com/dotnet/fsharp/blob/main/src/Compiler/Facilities/ReferenceResolver.fs) for the abstract definition of compiler reference resolution. See [LegacyMSBuildReferenceResolver.fs](https://github.com/dotnet/fsharp/blob/main/src/Compiler/Legacy/LegacyMSBuildReferenceResolver.fs) for reference resolution used by the .NET Framework F# compiler when running on .NET Framework. See [SimulatedMSBuildReferenceResolver.fs](https://github.com/dotnet/fsharp/blob/main/src/Compiler/Facilities/SimulatedMSBuildReferenceResolver.fs) when not using the .NET Framework F# compiler.
+   scripting.  See [ReferenceResolver.fs](https://github.com/dotnet/fsharp/blob/main/src/Compiler/Facilities/ReferenceResolver.fs) for the abstract definition of compiler reference resolution. See [LegacyMSBuildReferenceResolver.fs](../src/LegacyMsBuildResolver/LegacyMSBuildReferenceResolver.fs) for reference resolution used by the .NET Framework F# compiler when running on .NET Framework. See [SimulatedMSBuildReferenceResolver.fs](https://github.com/dotnet/fsharp/blob/main/src/Compiler/Facilities/SimulatedMSBuildReferenceResolver.fs) when not using the .NET Framework F# compiler.
    See [DependencyManager](https://github.com/dotnet/fsharp/tree/main/src/Compiler/DependencyManager) for reference resolution and package management used in `fsi`.
 
 * _Importing referenced .NET binaries_, see [import.fsi](https://github.com/dotnet/fsharp/blob/main/src/Compiler/Checking/import.fsi)/[import.fs](https://github.com/dotnet/fsharp/blob/main/src/Compiler/Checking/import.fs). Accepts file references and produces a Typed Tree node for each referenced assembly, including information about its type definitions (and type forwarders if any).
@@ -155,7 +155,7 @@ The following are the key phases and high-level logical operations of the F# com
 
 * _Post-inference type checks_, see [PostInferenceChecks.fsi](https://github.com/dotnet/fsharp/blob/main/src/Compiler/Checking/PostInferenceChecks.fsi)/[PostInferenceChecks.fs](https://github.com/dotnet/fsharp/blob/main/src/Compiler/Checking/PostInferenceChecks.fs). Called at the end of type checking/inference for each file. A range of checks that can only be enforced after type checking on a file is complete, such as analysis when using `byref<'T>` or other `IsByRefLike` structs.
 
-* _Quotation translation_, see [QuotationTranslator.fsi](https://github.com/dotnet/fsharp/blob/main/src/Compiler/Checking/QuotationTranslator.fsi)/[QuotationTranslator.fs](https://github.com/dotnet/fsharp/blob/main/src/Compiler/Checking/QuotationTranslator.fs)/[QuotationPickler.fsi](https://github.com/dotnet/fsharp/blob/main/src/Compiler/Checking/QuotationPickler.fsi)/[QuotationPickler.fs](https://github.com/dotnet/fsharp/blob/main/src/Compiler/Checking/QuotationPickler.fs). Generates the stored information for F# quotation nodes, generated from the Typed Tree expression structures of the F# compiler. Quotations are ultimately stored as binary data plus some added type references. "ReflectedDefinition" quotations are collected and stored in a single blob.
+* _Quotation translation_, see [QuotationTranslator.fsi](https://github.com/dotnet/fsharp/blob/main/src/Compiler/Checking/QuotationTranslator.fsi)/[QuotationTranslator.fs](https://github.com/dotnet/fsharp/blob/main/src/Compiler/Checking/QuotationTranslator.fs)/[QuotationPickler.fsi](../src/Compiler/TypedTree/QuotationPickler.fsi)/[QuotationPickler.fs](../src/Compiler/TypedTree/QuotationPickler.fs). Generates the stored information for F# quotation nodes, generated from the Typed Tree expression structures of the F# compiler. Quotations are ultimately stored as binary data plus some added type references. "ReflectedDefinition" quotations are collected and stored in a single blob.
 
 * _Optimization phases_, primarily the "Optimize" (peephole/inlining) and "Top Level Representation" (lambda lifting) phases, see [Optimizer.fsi](https://github.com/dotnet/fsharp/blob/main/src/Compiler/Optimize/Optimizer.fsi)/[Optimizer.fs](https://github.com/dotnet/fsharp/blob/main/src/Compiler/Optimize/Optimizer.fs) and [InnerLambdasToTopLevelFuncs.fsi](https://github.com/dotnet/fsharp/blob/main/src/Compiler/Optimize/InnerLambdasToTopLevelFuncs.fsi)/[InnerLambdasToTopLevelFuncs.fs](https://github.com/dotnet/fsharp/blob/main/src/Compiler/Optimize/InnerLambdasToTopLevelFuncs.fs) and [LowerCalls.fs](https://github.com/dotnet/fsharp/blob/main/src/Compiler/Optimize/LowerCalls.fs). Each of these takes Typed Tree nodes for types and expressions and either modifies the nodes in place or produces new Typed Tree nodes. These phases are orchestrated in [CompilerOptions.fs](https://github.com/dotnet/fsharp/blob/main/src/Compiler/Driver/CompilerOptions.fs)
 
@@ -174,7 +174,7 @@ These and transformations used to build the following:
 
 * _The F# Interactive Shell_, see [fsi.fs](https://github.com/dotnet/fsharp/blob/main/src/Compiler/Interactive/fsi.fs).
 
-* _The F# Compiler Shell_, see [fsc.fs](https://github.com/dotnet/fsharp/blob/main/src/Compiler/Driver/fsc.fs) and [fscmain.fs](https://github.com/dotnet/fsharp/blob/main/src/Compiler/Driver/fscmain.fs).
+* _The F# Compiler Shell_, see [fsc.fs](https://github.com/dotnet/fsharp/blob/main/src/Compiler/Driver/fsc.fs) and [fscmain.fs](../src/fsc/fscmain.fs).
 
 ## Bootstrapping
 
diff --git a/eng/Build.ps1 b/eng/Build.ps1
index 98a71be0b07..1d99378357d 100644
--- a/eng/Build.ps1
+++ b/eng/Build.ps1
@@ -287,7 +287,7 @@ function VerifyAssemblyVersionsAndSymbols() {
     }
 }
 
-function TestUsingMSBuild([string] $testProject, [string] $targetFramework, [string]$testadapterpath, [boolean] $noTestFilter = $false) {
+function TestUsingMSBuild([string] $testProject, [string] $targetFramework, [string]$testadapterpath, [boolean] $noTestFilter = $false, [boolean] $asBackgroundJob = $false) {
     $dotnetPath = InitializeDotNetCli
     $dotnetExe = Join-Path $dotnetPath "dotnet.exe"
     $projectName = [System.IO.Path]::GetFileNameWithoutExtension($testProject)
@@ -308,16 +308,26 @@ function TestUsingMSBuild([string] $testProject, [string] $targetFramework, [str
         $args += " --filter TestCategory!=PullRequest"
     }
 
-    Write-Host("$args")
-    Exec-Console $dotnetExe $args
+    
+    if ($asBackgroundJob) {
+        Write-Host("Starting on the background: $args")
+        Write-Host("------------------------------------")
+        $bgJob = Start-Job -ScriptBlock {       
+            & $using:dotnetExe test $using:testProject -c $using:configuration -f $using:targetFramework -v n --test-adapter-path $using:testadapterpath --logger "nunit;LogFilePath=$using:testLogPath" /bl:$using:testBinLogPath  --blame --results-directory $using:ArtifactsDir\TestResults\$using:configuration
+        }
+        return $bgJob
+    } else{
+        Write-Host("$args")
+        Exec-Console $dotnetExe $args
+    }
 }
 
-function TestUsingXUnit([string] $testProject, [string] $targetFramework, [string]$testadapterpath) {
-    TestUsingMsBuild -testProject $testProject -targetFramework $targetFramework -testadapterpath $testadapterpath -noTestFilter $true
+function TestUsingXUnit([string] $testProject, [string] $targetFramework, [string]$testadapterpath, [boolean] $asBackgroundJob = $false) {
+    TestUsingMsBuild -testProject $testProject -targetFramework $targetFramework -testadapterpath $testadapterpath -noTestFilter $true -asBackgroundJob $asBackgroundJob
 }
 
-function TestUsingNUnit([string] $testProject, [string] $targetFramework, [string]$testadapterpath) {
-    TestUsingMsBuild -testProject $testProject -targetFramework $targetFramework -testadapterpath $testadapterpath -noTestFilter $false
+function TestUsingNUnit([string] $testProject, [string] $targetFramework, [string]$testadapterpath, [boolean] $asBackgroundJob = $false) {
+    TestUsingMsBuild -testProject $testProject -targetFramework $targetFramework -testadapterpath $testadapterpath -noTestFilter $false -asBackgroundJob $asBackgroundJob
 }
 
 function Prepare-TempDir() {
@@ -517,23 +527,33 @@ try {
     $coreclrTargetFramework = "net7.0"
 
     if ($testDesktop) {
+        $bgJob = TestUsingNUnit -testProject "$RepoRoot\tests\fsharp\FSharpSuite.Tests.fsproj" -targetFramework $desktopTargetFramework -testadapterpath "$ArtifactsDir\bin\FSharpSuite.Tests\" -asBackgroundJob $true
+
         TestUsingXUnit -testProject "$RepoRoot\tests\FSharp.Compiler.ComponentTests\FSharp.Compiler.ComponentTests.fsproj" -targetFramework $desktopTargetFramework -testadapterpath "$ArtifactsDir\bin\FSharp.Compiler.ComponentTests\" -noTestFilter $true
         TestUsingNUnit -testProject "$RepoRoot\tests\FSharp.Compiler.UnitTests\FSharp.Compiler.UnitTests.fsproj" -targetFramework $desktopTargetFramework  -testadapterpath "$ArtifactsDir\bin\FSharp.Compiler.UnitTests\"
         TestUsingNUnit -testProject "$RepoRoot\tests\FSharp.Compiler.Service.Tests\FSharp.Compiler.Service.Tests.fsproj" -targetFramework $desktopTargetFramework -testadapterpath "$ArtifactsDir\bin\FSharp.Compiler.Service.Tests\"
         TestUsingXUnit -testProject "$RepoRoot\tests\FSharp.Compiler.Private.Scripting.UnitTests\FSharp.Compiler.Private.Scripting.UnitTests.fsproj" -targetFramework $desktopTargetFramework  -testadapterpath "$ArtifactsDir\bin\FSharp.Compiler.Private.Scripting.UnitTests\"
         TestUsingNUnit -testProject "$RepoRoot\tests\FSharp.Build.UnitTests\FSharp.Build.UnitTests.fsproj" -targetFramework $desktopTargetFramework -testadapterpath "$ArtifactsDir\bin\FSharp.Build.UnitTests\"
         TestUsingXUnit -testProject "$RepoRoot\tests\FSharp.Core.UnitTests\FSharp.Core.UnitTests.fsproj" -targetFramework $desktopTargetFramework -testadapterpath "$ArtifactsDir\bin\FSharp.Core.UnitTests\"
-        TestUsingNUnit -testProject "$RepoRoot\tests\fsharp\FSharpSuite.Tests.fsproj" -targetFramework $desktopTargetFramework -testadapterpath "$ArtifactsDir\bin\FSharpSuite.Tests\"
+        
+        # Collect output from  background jobs
+        Wait-job $bgJob | out-null
+        Receive-Job $bgJob 
     }
 
     if ($testCoreClr) {
+        $bgJob = TestUsingNUnit -testProject "$RepoRoot\tests\fsharp\FSharpSuite.Tests.fsproj" -targetFramework $coreclrTargetFramework -testadapterpath "$ArtifactsDir\bin\FSharpSuite.Tests\" -asBackgroundJob $true
+
         TestUsingXUnit -testProject "$RepoRoot\tests\FSharp.Compiler.ComponentTests\FSharp.Compiler.ComponentTests.fsproj" -targetFramework $coreclrTargetFramework -testadapterpath "$ArtifactsDir\bin\FSharp.Compiler.ComponentTests\"
         TestUsingNUnit -testProject "$RepoRoot\tests\FSharp.Compiler.UnitTests\FSharp.Compiler.UnitTests.fsproj" -targetFramework $coreclrTargetFramework -testadapterpath "$ArtifactsDir\bin\FSharp.Compiler.UnitTests\"
         TestUsingNUnit -testProject "$RepoRoot\tests\FSharp.Compiler.Service.Tests\FSharp.Compiler.Service.Tests.fsproj" -targetFramework $coreclrTargetFramework -testadapterpath "$ArtifactsDir\bin\FSharp.Compiler.Service.Tests\"
         TestUsingXUnit -testProject "$RepoRoot\tests\FSharp.Compiler.Private.Scripting.UnitTests\FSharp.Compiler.Private.Scripting.UnitTests.fsproj" -targetFramework $coreclrTargetFramework -testadapterpath "$ArtifactsDir\bin\FSharp.Compiler.Private.Scripting.UnitTests\"
         TestUsingNUnit -testProject "$RepoRoot\tests\FSharp.Build.UnitTests\FSharp.Build.UnitTests.fsproj" -targetFramework $coreclrTargetFramework -testadapterpath "$ArtifactsDir\bin\FSharp.Build.UnitTests\"
         TestUsingXUnit -testProject "$RepoRoot\tests\FSharp.Core.UnitTests\FSharp.Core.UnitTests.fsproj" -targetFramework $coreclrTargetFramework -testadapterpath "$ArtifactsDir\bin\FSharp.Core.UnitTests\"
-        TestUsingNUnit -testProject "$RepoRoot\tests\fsharp\FSharpSuite.Tests.fsproj" -targetFramework $coreclrTargetFramework -testadapterpath "$ArtifactsDir\bin\FSharpSuite.Tests\"
+        
+        # Collect output from  background jobs
+        Wait-job $bgJob | out-null
+        Receive-Job $bgJob      
     }
 
     if ($testFSharpQA) {
@@ -592,7 +612,7 @@ try {
 
     if ($testVs -and -not $noVisualStudio) {
         TestUsingNUnit -testProject "$RepoRoot\vsintegration\tests\UnitTests\VisualFSharp.UnitTests.fsproj" -targetFramework $desktopTargetFramework -testadapterpath "$ArtifactsDir\bin\VisualFSharp.UnitTests\"
-        TestUsingNUnit -testProject "$RepoRoot\vsintegration\tests\FSharp.Editor.Tests\FSharp.Editor.Tests.fsproj" -targetFramework $desktopTargetFramework -testadapterpath "$ArtifactsDir\bin\FSharp.Editor.Tests\FSharp.Editor.Tests.fsproj"
+        TestUsingXUnit -testProject "$RepoRoot\vsintegration\tests\FSharp.Editor.Tests\FSharp.Editor.Tests.fsproj" -targetFramework $desktopTargetFramework -testadapterpath "$ArtifactsDir\bin\FSharp.Editor.Tests\FSharp.Editor.Tests.fsproj"
     }
 
     # verify nupkgs have access to the source code
diff --git a/eng/Versions.props b/eng/Versions.props
index c82085d4f81..0939c8b5671 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -15,7 +15,7 @@
     <!-- F# Version components -->
     <FSMajorVersion>7</FSMajorVersion>
     <FSMinorVersion>0</FSMinorVersion>
-    <FSBuildVersion>0</FSBuildVersion>
+    <FSBuildVersion>200</FSBuildVersion>
     <FSRevisionVersion>0</FSRevisionVersion>
     <!-- -->
     <!-- F# Language version -->
@@ -33,7 +33,7 @@
     <!-- FSharp.Compiler.Service version -->
     <FCSMajorVersion>43</FCSMajorVersion>
     <FCSMinorVersion>7</FCSMinorVersion>
-    <FCSBuildVersion>102</FCSBuildVersion>
+    <FCSBuildVersion>$(FSBuildVersion)</FCSBuildVersion>
     <FCSRevisionVersion>$(FSRevisionVersion)</FCSRevisionVersion>
     <FSharpCompilerServicePackageVersion>$(FCSMajorVersion).$(FCSMinorVersion).$(FCSBuildVersion)</FSharpCompilerServicePackageVersion>
     <FSharpCompilerServiceVersion>$(FCSMajorVersion).$(FCSMinorVersion).$(FCSBuildVersion).$(FCSRevisionVersion)</FSharpCompilerServiceVersion>
@@ -47,8 +47,9 @@
     <!-- -->
     <!-- FSharp tools for Visual Studio version number -->
     <FSToolsMajorVersion>12</FSToolsMajorVersion>
-    <FSToolsMinorVersion>0</FSToolsMinorVersion>
-    <FSToolsBuildVersion>5</FSToolsBuildVersion>
+
+    <FSToolsMinorVersion>5</FSToolsMinorVersion>
+    <FSToolsBuildVersion>0</FSToolsBuildVersion>
     <FSToolsRevisionVersion>$(FSRevisionVersion)</FSToolsRevisionVersion>
     <FSProductVersionPrefix>$(FSToolsMajorVersion).$(FSToolsMinorVersion).$(FSToolsBuildVersion)</FSProductVersionPrefix>
     <FSProductVersionReleaseNotesVersion>$(FSToolsMajorVersion)-$(FSToolsMinorVersion)-$(FSToolsBuildVersion)</FSProductVersionReleaseNotesVersion>
@@ -56,7 +57,7 @@
   </PropertyGroup>
   <PropertyGroup>
     <VSMajorVersion>17</VSMajorVersion>
-    <VSMinorVersion>3</VSMinorVersion>
+    <VSMinorVersion>5</VSMinorVersion>
     <VSGeneralVersion>$(VSMajorVersion).0</VSGeneralVersion>
     <VSAssemblyVersionPrefix>$(VSMajorVersion).$(VSMinorVersion).0</VSAssemblyVersionPrefix>
     <VSAssemblyVersion>$(VSAssemblyVersionPrefix).0</VSAssemblyVersion>
@@ -96,11 +97,11 @@
     <SystemRuntimeCompilerServicesUnsafeVersion>6.0.0</SystemRuntimeCompilerServicesUnsafeVersion>
     <SystemValueTupleVersion>4.5.0</SystemValueTupleVersion>
     <!-- Versions for package groups -->
-    <RoslynVersion>4.4.0-3.22470.1</RoslynVersion>
-    <VisualStudioEditorPackagesVersion>17.4.196-preview</VisualStudioEditorPackagesVersion>
-    <MicrosoftVisualStudioShellPackagesVersion>17.4.0-preview-3-32916-145</MicrosoftVisualStudioShellPackagesVersion>
-    <VisualStudioProjectSystemPackagesVersion>17.4.342-pre</VisualStudioProjectSystemPackagesVersion>
-    <MicrosoftVisualStudioThreadingPackagesVersion>17.4.23-alpha</MicrosoftVisualStudioThreadingPackagesVersion>
+    <RoslynVersion>4.5.0-1.22520.13</RoslynVersion>
+    <VisualStudioEditorPackagesVersion>17.5.49-preview</VisualStudioEditorPackagesVersion>
+    <MicrosoftVisualStudioShellPackagesVersion>17.5.0-preview-1-33020-520</MicrosoftVisualStudioShellPackagesVersion>
+    <VisualStudioProjectSystemPackagesVersion>17.5.202-pre-g89e17c9f72</VisualStudioProjectSystemPackagesVersion>
+    <MicrosoftVisualStudioThreadingPackagesVersion>17.4.27</MicrosoftVisualStudioThreadingPackagesVersion>
     <MicrosoftBuildOverallPackagesVersion>17.4.0-preview-22469-04</MicrosoftBuildOverallPackagesVersion>
     <!-- Roslyn packages -->
     <MicrosoftCodeAnalysisEditorFeaturesVersion>$(RoslynVersion)</MicrosoftCodeAnalysisEditorFeaturesVersion>
@@ -108,7 +109,6 @@
     <MicrosoftCodeAnalysisEditorFeaturesWpfVersion>$(RoslynVersion)</MicrosoftCodeAnalysisEditorFeaturesWpfVersion>
     <MicrosoftCodeAnalysisExternalAccessFSharpVersion>$(RoslynVersion)</MicrosoftCodeAnalysisExternalAccessFSharpVersion>
     <MicrosoftCodeAnalysisVersion>$(RoslynVersion)</MicrosoftCodeAnalysisVersion>
-    <MicrosoftCodeAnalysisWorkspacesCommonVersion>$(RoslynVersion)</MicrosoftCodeAnalysisWorkspacesCommonVersion>
     <MicrosoftCodeAnalysisCSharpVersion>$(RoslynVersion)</MicrosoftCodeAnalysisCSharpVersion>
     <MicrosoftVisualStudioLanguageServicesVersion>$(RoslynVersion)</MicrosoftVisualStudioLanguageServicesVersion>
     <MicrosoftCodeAnalysisTestResourcesProprietaryVersion>2.0.28</MicrosoftCodeAnalysisTestResourcesProprietaryVersion>
@@ -116,7 +116,7 @@
     <!-- Visual Studio Shell packages -->
     <MicrosoftVisualStudioInteropVersion>$(MicrosoftVisualStudioShellPackagesVersion)</MicrosoftVisualStudioInteropVersion>
     <MicrosoftInternalVisualStudioInteropVersion>$(MicrosoftVisualStudioShellPackagesVersion)</MicrosoftInternalVisualStudioInteropVersion>
-    <MicrosoftVisualStudioImagingInterop140DesignTimeVersion>17.4.0-preview-3-32916-053</MicrosoftVisualStudioImagingInterop140DesignTimeVersion>
+    <MicrosoftVisualStudioImagingInterop140DesignTimeVersion>17.5.0-preview-1-33019-447</MicrosoftVisualStudioImagingInterop140DesignTimeVersion>
     <MicrosoftVisualStudioShellInterop80Version>$(MicrosoftVisualStudioShellPackagesVersion)</MicrosoftVisualStudioShellInterop80Version>
     <MicrosoftVisualStudioShellInterop90Version>$(MicrosoftVisualStudioShellPackagesVersion)</MicrosoftVisualStudioShellInterop90Version>
     <MicrosoftVisualStudioShellInterop100Version>$(MicrosoftVisualStudioShellPackagesVersion)</MicrosoftVisualStudioShellInterop100Version>
@@ -133,8 +133,8 @@
     <MicrosoftVisualStudioShellDesignVersion>$(MicrosoftVisualStudioShellPackagesVersion)</MicrosoftVisualStudioShellDesignVersion>
     <MicrosoftVisualStudioShellFrameworkVersion>$(MicrosoftVisualStudioShellPackagesVersion)</MicrosoftVisualStudioShellFrameworkVersion>
     <MicrosoftVisualStudioPackageLanguageService150Version>$(MicrosoftVisualStudioShellPackagesVersion)</MicrosoftVisualStudioPackageLanguageService150Version>
-    <MicrosoftVisualStudioManagedInterfacesVersion>17.4.0-preview-3-32916-053</MicrosoftVisualStudioManagedInterfacesVersion>
-    <MicrosoftVisualStudioProjectAggregatorVersion>17.4.0-preview-3-32916-053</MicrosoftVisualStudioProjectAggregatorVersion>
+    <MicrosoftVisualStudioManagedInterfacesVersion>17.5.0-preview-1-33019-447</MicrosoftVisualStudioManagedInterfacesVersion>
+    <MicrosoftVisualStudioProjectAggregatorVersion>17.5.0-preview-1-33019-447</MicrosoftVisualStudioProjectAggregatorVersion>
     <MicrosoftVisualStudioGraphModelVersion>$(MicrosoftVisualStudioShellPackagesVersion)</MicrosoftVisualStudioGraphModelVersion>
     <MicrosoftVisualStudioImagingVersion>$(MicrosoftVisualStudioShellPackagesVersion)</MicrosoftVisualStudioImagingVersion>
     <MicrosoftVisualStudioDesignerInterfacesVersion>$(MicrosoftVisualStudioShellPackagesVersion)</MicrosoftVisualStudioDesignerInterfacesVersion>
@@ -171,7 +171,7 @@
     <MicrosoftVisualStudioProjectSystemManagedVersion>2.3.6152103</MicrosoftVisualStudioProjectSystemManagedVersion>
     <!-- Misc. Visual Studio packages -->
     <MicrosoftVSSDKBuildToolsVersion>17.1.4054</MicrosoftVSSDKBuildToolsVersion>
-    <MicrosoftVisualStudioRpcContractsVersion>17.4.7-alpha</MicrosoftVisualStudioRpcContractsVersion>
+    <MicrosoftVisualStudioRpcContractsVersion>17.5.9-alpha-g84529e7115</MicrosoftVisualStudioRpcContractsVersion>
     <MicrosoftVisualFSharpMicrosoftVisualStudioShellUIInternalVersion>17.0.0</MicrosoftVisualFSharpMicrosoftVisualStudioShellUIInternalVersion>
     <MicrosoftVisualStudioValidationVersion>17.0.64</MicrosoftVisualStudioValidationVersion>
     <MicrosoftVisualStudioWCFReferenceInteropVersion>9.0.30729</MicrosoftVisualStudioWCFReferenceInteropVersion>
@@ -198,14 +198,14 @@
     <MicrosoftNETCoreILAsmVersion>5.0.0-preview.7.20364.11</MicrosoftNETCoreILAsmVersion>
     <MicrosoftNETTestSdkVersion>16.11.0</MicrosoftNETTestSdkVersion>
     <MicrosoftWin32RegistryVersion>5.0.0</MicrosoftWin32RegistryVersion>
-    <NewtonsoftJsonVersion>13.0.1</NewtonsoftJsonVersion>
+    <NewtonsoftJsonVersion>13.0.2</NewtonsoftJsonVersion>
     <NUnitVersion>3.13.2</NUnitVersion>
     <NUnit3TestAdapterVersion>4.1.0</NUnit3TestAdapterVersion>
     <NUnitLiteVersion>3.11.0</NUnitLiteVersion>
     <NunitXmlTestLoggerVersion>2.1.80</NunitXmlTestLoggerVersion>
     <RoslynToolsSignToolVersion>1.0.0-beta2-dev3</RoslynToolsSignToolVersion>
-    <StreamJsonRpcVersion>2.13.23-alpha</StreamJsonRpcVersion>
-    <NerdbankStreamsVersion>2.9.87-alpha</NerdbankStreamsVersion>
+    <StreamJsonRpcVersion>2.14.6-alpha</StreamJsonRpcVersion>
+    <NerdbankStreamsVersion>2.9.112</NerdbankStreamsVersion>
     <XUnitVersion>2.4.1</XUnitVersion>
     <XUnitRunnerVersion>2.4.2</XUnitRunnerVersion>
     <FluentAssertionsVersion>5.10.3</FluentAssertionsVersion>
diff --git a/eng/release/insert-into-vs.yml b/eng/release/insert-into-vs.yml
index 11bd12be6d3..63973516ba8 100644
--- a/eng/release/insert-into-vs.yml
+++ b/eng/release/insert-into-vs.yml
@@ -14,7 +14,7 @@ stages:
   jobs:
   - job: Insert_VS
     pool:
-      name: NetCore1ESPool-Internal
+      name: NetCore1ESPool-Svc-Internal
       demands: ImageOverride -equals windows.vs2019.amd64
     variables:
     - group: DotNet-VSTS-Infra-Access
diff --git a/global.json b/global.json
index 8c6f61284da..a0daa280301 100644
--- a/global.json
+++ b/global.json
@@ -1,18 +1,18 @@
 {
   "sdk": {
-    "version": "7.0.100-rc.2.22477.23",
+    "version": "7.0.102",
     "allowPrerelease": true,
     "rollForward": "latestPatch"
   },
   "tools": {
-    "dotnet": "7.0.100-rc.2.22477.23",
+    "dotnet": "7.0.102",
     "vs": {
-      "version": "17.2",
+      "version": "17.4",
       "components": [
         "Microsoft.VisualStudio.Component.FSharp"
       ]
     },
-    "xcopy-msbuild": "17.3.1"
+    "xcopy-msbuild": "17.4.1"
   },
   "native-tools": {
     "perl": "5.32.1.1"
diff --git a/src/Compiler/AbstractIL/il.fs b/src/Compiler/AbstractIL/il.fs
index e2cca7d1809..2470c7ae215 100644
--- a/src/Compiler/AbstractIL/il.fs
+++ b/src/Compiler/AbstractIL/il.fs
@@ -29,8 +29,6 @@ let _ =
     if logging then
         dprintn "* warning: Il.logging is on"
 
-let int_order = LanguagePrimitives.FastGenericComparer<int>
-
 let notlazy v = Lazy<_>.CreateFromValue v
 
 /// A little ugly, but the idea is that if a data structure does not
@@ -99,8 +97,6 @@ let rec splitNamespaceAux (nm: string) =
 let splitNamespace nm =
     memoizeNamespaceTable.GetOrAdd(nm, splitNamespaceAux)
 
-let splitNamespaceMemoized nm = splitNamespace nm
-
 // ++GLOBAL MUTABLE STATE (concurrency-safe)
 let memoizeNamespaceArrayTable = ConcurrentDictionary<string, string[]>()
 
@@ -152,11 +148,6 @@ splitILTypeNameWithPossibleStaticArguments "Foo.Bar,\"1.0\"" = ([| "Foo" |], "Ba
 splitILTypeNameWithPossibleStaticArguments "Foo.Bar.Bar,\"1.0\"" = ([| "Foo"; "Bar" |], "Bar,\"1.0\"")
 *)
 
-let unsplitTypeName (ns, n) =
-    match ns with
-    | [] -> String.concat "." ns + "." + n
-    | _ -> n
-
 let splitTypeNameRightAux (nm: string) =
     let idx = nm.LastIndexOf '.'
 
@@ -434,8 +425,6 @@ type AssemblyRefData =
 /// Global state: table of all assembly references keyed by AssemblyRefData.
 let AssemblyRefUniqueStampGenerator = UniqueStampGenerator<AssemblyRefData>()
 
-let isMscorlib data = data.assemRefName = "mscorlib"
-
 [<Sealed>]
 type ILAssemblyRef(data) =
     let pkToken key =
@@ -3249,9 +3238,6 @@ let mkILMethods xs =
 let mkILMethodsComputed f = ILMethodDefs f
 let emptyILMethods = mkILMethodsFromArray [||]
 
-let filterILMethodDefs f (mdefs: ILMethodDefs) =
-    ILMethodDefs(fun () -> mdefs.AsArray() |> Array.filter f)
-
 // --------------------------------------------------------------------
 // Operations and defaults for modules, assemblies etc.
 // --------------------------------------------------------------------
@@ -3460,11 +3446,6 @@ let mkLdcInt32 i =
     else
         AI_ldc(DT_I4, ILConst.I4 i)
 
-let tname_CompilerGeneratedAttribute =
-    "System.Runtime.CompilerServices.CompilerGeneratedAttribute"
-
-let tname_DebuggableAttribute = "System.Diagnostics.DebuggableAttribute"
-
 (* NOTE: ecma_ prefix refers to the standard "mscorlib" *)
 let ecmaPublicKey =
     PublicKeyToken(Bytes.ofInt32Array [| 0xde; 0xad; 0xbe; 0xef; 0xca; 0xfe; 0xfa; 0xce |])
@@ -3819,14 +3800,6 @@ let mkILClassCtor impl =
         body = notlazy impl
     )
 
-// --------------------------------------------------------------------
-// Make a virtual method, where the overriding is simply the default
-// (i.e. overrides by name/signature)
-// --------------------------------------------------------------------
-
-let mk_ospec (ty: ILType, callconv, nm, genparams, formal_args, formal_ret) =
-    OverridesSpec(mkILMethRef (ty.TypeRef, callconv, nm, genparams, formal_args, formal_ret), ty)
-
 let mkILGenericVirtualMethod (nm, callconv: ILCallingConv, access, genparams, actual_args, actual_ret, impl) =
     let attributes =
         convertMemberAccess access
@@ -3902,7 +3875,7 @@ let prependInstrsToCode (instrs: ILInstr list) (c2: ILCode) =
     // If there is a sequence point as the first instruction then keep it at the front
     | I_seqpoint _ as i0 ->
         let labels =
-            let dict = Dictionary.newWithSize c2.Labels.Count
+            let dict = Dictionary.newWithSize (c2.Labels.Count * 2) // Decrease chance of collisions by oversizing the hashtable
 
             for kvp in c2.Labels do
                 dict.Add(kvp.Key, (if kvp.Value = 0 then 0 else kvp.Value + n))
@@ -3915,7 +3888,7 @@ let prependInstrsToCode (instrs: ILInstr list) (c2: ILCode) =
         }
     | _ ->
         let labels =
-            let dict = Dictionary.newWithSize c2.Labels.Count
+            let dict = Dictionary.newWithSize (c2.Labels.Count * 2) // Decrease chance of collisions by oversizing the hashtable
 
             for kvp in c2.Labels do
                 dict.Add(kvp.Key, kvp.Value + n)
@@ -3953,11 +3926,6 @@ let cdef_cctorCode2CodeOrCreate tag imports f (cd: ILTypeDef) =
 
     cd.With(methods = methods)
 
-let codeOfMethodDef (md: ILMethodDef) =
-    match md.Code with
-    | Some x -> x
-    | None -> failwith "codeOfmdef: not IL"
-
 let mkRefToILMethod (tref, md: ILMethodDef) =
     mkILMethRef (tref, md.CallingConv, md.Name, md.GenericParams.Length, md.ParameterTypes, md.Return.Type)
 
@@ -4363,10 +4331,6 @@ let computeILEnumInfo (mdName, mdFields: ILFieldDefs) =
 
 let sigptr_get_byte bytes sigptr = Bytes.get bytes sigptr, sigptr + 1
 
-let sigptr_get_bool bytes sigptr =
-    let b0, sigptr = sigptr_get_byte bytes sigptr
-    (b0 = 0x01), sigptr
-
 let sigptr_get_u8 bytes sigptr =
     let b0, sigptr = sigptr_get_byte bytes sigptr
     byte b0, sigptr
@@ -4490,11 +4454,6 @@ let mkRefToILAssembly (m: ILAssemblyManifest) =
         m.Locale
     )
 
-let z_unsigned_int_size n =
-    if n <= 0x7F then 1
-    elif n <= 0x3FFF then 2
-    else 3
-
 let z_unsigned_int n =
     if n >= 0 && n <= 0x7F then
         [| byte n |]
@@ -4555,8 +4514,6 @@ let ieee32AsBytes i = i32AsBytes (bitsOfSingle i)
 
 let ieee64AsBytes i = i64AsBytes (bitsOfDouble i)
 
-let et_END = 0x00uy
-let et_VOID = 0x01uy
 let et_BOOLEAN = 0x02uy
 let et_CHAR = 0x03uy
 let et_I1 = 0x04uy
@@ -4570,22 +4527,8 @@ let et_U8 = 0x0Buy
 let et_R4 = 0x0Cuy
 let et_R8 = 0x0Duy
 let et_STRING = 0x0Euy
-let et_PTR = 0x0Fuy
-let et_BYREF = 0x10uy
-let et_VALUETYPE = 0x11uy
-let et_CLASS = 0x12uy
-let et_VAR = 0x13uy
-let et_ARRAY = 0x14uy
-let et_WITH = 0x15uy
-let et_TYPEDBYREF = 0x16uy
-let et_I = 0x18uy
-let et_U = 0x19uy
-let et_FNPTR = 0x1Buy
 let et_OBJECT = 0x1Cuy
 let et_SZARRAY = 0x1Duy
-let et_MVAR = 0x1Euy
-let et_CMOD_REQD = 0x1Fuy
-let et_CMOD_OPT = 0x20uy
 
 let formatILVersion (version: ILVersionInfo) =
     sprintf "%d.%d.%d.%d" (int version.Major) (int version.Minor) (int version.Build) (int version.Revision)
diff --git a/src/Compiler/AbstractIL/ilmorph.fs b/src/Compiler/AbstractIL/ilmorph.fs
index dad1e16369d..99fcb9811b2 100644
--- a/src/Compiler/AbstractIL/ilmorph.fs
+++ b/src/Compiler/AbstractIL/ilmorph.fs
@@ -37,7 +37,7 @@ let code_instr2instrs f (code: ILCode) =
     adjust[old] <- nw
 
     let labels =
-        let dict = Dictionary.newWithSize code.Labels.Count
+        let dict = Dictionary.newWithSize (code.Labels.Count * 2) // Decrease chance of collisions by oversizing the hashtable
 
         for kvp in code.Labels do
             dict.Add(kvp.Key, adjust[kvp.Value])
@@ -112,11 +112,6 @@ and callsig_scoref2scoref_tyvar2ty f x =
 and tys_scoref2scoref_tyvar2ty f i =
     List.map (ty_scoref2scoref_tyvar2ty f) i
 
-and gparams_scoref2scoref_tyvar2ty f i =
-    List.map (gparam_scoref2scoref_tyvar2ty f) i
-
-and gparam_scoref2scoref_tyvar2ty _f i = i
-
 and morphILScopeRefsInILTypeRef fscope (tref: ILTypeRef) =
     ILTypeRef.Create(scope = fscope tref.Scope, enclosing = tref.Enclosing, name = tref.Name)
 
diff --git a/src/Compiler/AbstractIL/ilnativeres.fs b/src/Compiler/AbstractIL/ilnativeres.fs
index 70846577d68..b37ae327c40 100644
--- a/src/Compiler/AbstractIL/ilnativeres.fs
+++ b/src/Compiler/AbstractIL/ilnativeres.fs
@@ -26,9 +26,6 @@ type WCHAR = Char
 type WORD = uint16
 
 let inline WORD s = uint16 s
-let inline DWORD s = uint32 s
-let inline WCHAR s = char s
-let inline BYTE s = byte s
 
 type ResourceException(name: string, ?inner: Exception MaybeNull) =
     inherit Exception(name, Option.toObj inner)
diff --git a/src/Compiler/AbstractIL/ilprint.fs b/src/Compiler/AbstractIL/ilprint.fs
index 0335e28ef22..5ecdd91986c 100644
--- a/src/Compiler/AbstractIL/ilprint.fs
+++ b/src/Compiler/AbstractIL/ilprint.fs
@@ -13,8 +13,6 @@ open FSharp.Compiler.AbstractIL.ILX.Types
 open FSharp.Compiler.AbstractIL.IL
 
 #if DEBUG
-let pretty () = true
-
 // --------------------------------------------------------------------
 // Pretty printing
 // --------------------------------------------------------------------
@@ -53,8 +51,6 @@ let mk_ppenv ilg =
         ppenvMethodFormals = 0
     }
 
-let debug_ppenv = mk_ppenv
-
 let ppenv_enter_modul env =
     { env with
         ppenvClassFormals = 0
@@ -135,14 +131,6 @@ let output_seq sep f os (a: seq<_>) =
             output_string os sep
             f os e.Current
 
-let output_array sep f os (a: _[]) =
-    if not (Array.isEmpty a) then
-        for i in 0 .. a.Length - 2 do
-            f os a[i]
-            output_string os sep
-
-        f os a[a.Length - 1]
-
 let output_parens f os a =
     output_string os "("
     f os a
@@ -153,19 +141,8 @@ let output_angled f os a =
     f os a
     output_string os ">"
 
-let output_bracks f os a =
-    output_string os "["
-    f os a
-    output_string os "]"
-
 let output_id os n = output_sqstring os n
 
-let output_label os n = output_string os n
-
-let output_lid os lid = output_seq "." output_string os lid
-
-let string_of_type_name (_, n) = n
-
 let output_byte os i =
     output_hex_digit os (i / 16)
     output_hex_digit os (i % 16)
@@ -293,16 +270,6 @@ and output_tyvar os d =
     output_u16 os d
     ()
 
-and goutput_ldtoken_info env os =
-    function
-    | ILToken.ILType x -> goutput_typ env os x
-    | ILToken.ILMethod x ->
-        output_string os "method "
-        goutput_mspec env os x
-    | ILToken.ILField x ->
-        output_string os "field "
-        goutput_fspec env os x
-
 and goutput_typ_with_shortened_class_syntax env os =
     function
     | ILType.Boxed tspec when tspec.GenericArgs = [] -> goutput_tref env os tspec.TypeRef
@@ -424,12 +391,6 @@ and goutput_dlocref env os (dref: ILType) =
         goutput_typ_with_shortened_class_syntax env os ty
         output_string os "::"
 
-and goutput_callsig env os (csig: ILCallingSignature) =
-    output_callconv os csig.CallingConv
-    output_string os " "
-    goutput_typ env os csig.ReturnType
-    output_parens (output_seq ", " (goutput_typ env)) os csig.ArgTypes
-
 and goutput_mref env os (mref: ILMethodRef) =
     output_callconv os mref.CallingConv
     output_string os " "
@@ -465,56 +426,6 @@ and goutput_mspec env os (mspec: ILMethodSpec) =
     goutput_gactuals env os mspec.GenericArgs
     output_parens (output_seq ", " (goutput_typ fenv)) os mspec.FormalArgTypes
 
-and goutput_vararg_mspec env os (mspec, varargs) =
-    match varargs with
-    | None -> goutput_mspec env os mspec
-    | Some varargs' ->
-        let fenv =
-            ppenv_enter_method mspec.GenericArity (ppenv_enter_tdef (mkILFormalTypars mspec.DeclaringType.GenericArgs) env)
-
-        output_callconv os mspec.CallingConv
-        output_string os " "
-        goutput_typ fenv os mspec.FormalReturnType
-        output_string os " "
-        goutput_dlocref env os mspec.DeclaringType
-        let name = mspec.Name
-
-        if name = ".ctor" || name = ".cctor" then
-            output_string os name
-        else
-            output_id os name
-
-        goutput_gactuals env os mspec.GenericArgs
-        output_string os "("
-        output_seq ", " (goutput_typ fenv) os mspec.FormalArgTypes
-        output_string os ", ..., "
-        output_seq ", " (goutput_typ fenv) os varargs'
-        output_string os ")"
-
-and goutput_vararg_sig env os (csig: ILCallingSignature, varargs: ILVarArgs) =
-    match varargs with
-    | None ->
-        goutput_callsig env os csig
-        ()
-    | Some varargs' ->
-        goutput_typ env os csig.ReturnType
-        output_string os " ("
-        let argTys = csig.ArgTypes
-
-        if argTys.Length <> 0 then
-            output_seq ", " (goutput_typ env) os argTys
-
-        output_string os ", ..., "
-        output_seq ", " (goutput_typ env) os varargs'
-        output_string os ")"
-
-and goutput_fspec env os (x: ILFieldSpec) =
-    let fenv = ppenv_enter_tdef (mkILFormalTypars x.DeclaringType.GenericArgs) env
-    goutput_typ fenv os x.FormalType
-    output_string os " "
-    goutput_dlocref env os x.DeclaringType
-    output_id os x.Name
-
 let output_member_access os access =
     output_string
         os
@@ -592,41 +503,6 @@ let output_option f os =
     | None -> ()
     | Some x -> f os x
 
-let goutput_alternative_ref env os (alt: IlxUnionCase) =
-    output_id os alt.Name
-
-    alt.FieldDefs
-    |> output_parens (output_array ", " (fun os fdef -> goutput_typ env os fdef.Type)) os
-
-let goutput_curef env os (IlxUnionRef (_, tref, alts, _, _)) =
-    output_string os " .classunion import "
-    goutput_tref env os tref
-    output_parens (output_array ", " (goutput_alternative_ref env)) os alts
-
-let goutput_cuspec env os (IlxUnionSpec (IlxUnionRef (_, tref, _, _, _), i)) =
-    output_string os "class /* classunion */ "
-    goutput_tref env os tref
-    goutput_gactuals env os i
-
-let output_basic_type os x =
-    output_string
-        os
-        (match x with
-         | DT_I1 -> "i1"
-         | DT_U1 -> "u1"
-         | DT_I2 -> "i2"
-         | DT_U2 -> "u2"
-         | DT_I4 -> "i4"
-         | DT_U4 -> "u4"
-         | DT_I8 -> "i8"
-         | DT_U8 -> "u8"
-         | DT_R4 -> "r4"
-         | DT_R8 -> "r8"
-         | DT_R -> "r"
-         | DT_I -> "i"
-         | DT_U -> "u"
-         | DT_REF -> "ref")
-
 let output_custom_attr_data os data =
     output_string os " = "
     output_parens output_bytes os data
@@ -684,28 +560,6 @@ let goutput_fdef _tref env os (fd: ILFieldDef) =
     output_string os "\n"
     goutput_custom_attrs env os fd.CustomAttrs
 
-let output_alignment os =
-    function
-    | Aligned -> ()
-    | Unaligned1 -> output_string os "unaligned. 1 "
-    | Unaligned2 -> output_string os "unaligned. 2 "
-    | Unaligned4 -> output_string os "unaligned. 4 "
-
-let output_volatility os =
-    function
-    | Nonvolatile -> ()
-    | Volatile -> output_string os "volatile. "
-
-let output_tailness os =
-    function
-    | Tailcall -> output_string os "tail. "
-    | _ -> ()
-
-let output_after_tailcall os =
-    function
-    | Tailcall -> output_string os " ret "
-    | _ -> ()
-
 let rec goutput_apps env os =
     function
     | Apps_tyapp (actual, cs) ->
@@ -722,25 +576,6 @@ let rec goutput_apps env os =
         output_string os "--> "
         goutput_typ env os ty
 
-/// Print the short form of instructions
-let output_short_u16 os (x: uint16) =
-    if int x < 256 then
-        (output_string os ".s "
-         output_u16 os x)
-    else
-        output_string os " "
-        output_u16 os x
-
-let output_short_i32 os i32 =
-    if i32 < 256 && 0 >= i32 then
-        (output_string os ".s "
-         output_i32 os i32)
-    else
-        output_string os " "
-        output_i32 os i32
-
-let output_code_label os lab = output_string os (formatCodeLabel lab)
-
 let goutput_local env os (l: ILLocal) =
     goutput_typ env os l.Type
 
@@ -758,287 +593,6 @@ let goutput_param env os (l: ILParameter) =
 let goutput_params env os ps =
     output_parens (output_seq ", " (goutput_param env)) os ps
 
-let goutput_freevar env os l =
-    goutput_typ env os l.fvType
-    output_string os " "
-    output_sqstring os l.fvName
-
-let goutput_freevars env os ps =
-    output_parens (output_seq ", " (goutput_freevar env)) os ps
-
-let output_source os (s: ILDebugPoint) =
-    if s.Document.File <> "" then
-        output_string os " .line "
-        output_int os s.Line
-
-        if s.Column <> -1 then
-            output_string os " : "
-            output_int os s.Column
-
-        output_string os " /* - "
-        output_int os s.EndLine
-
-        if s.Column <> -1 then
-            output_string os " : "
-            output_int os s.EndColumn
-
-        output_string os "*/ "
-        output_sqstring os s.Document.File
-
-let rec goutput_instr env os inst =
-    match inst with
-    | si when isNoArgInstr si -> output_lid os (wordsOfNoArgInstr si)
-    | I_brcmp (cmp, tg1) ->
-        output_string
-            os
-            (match cmp with
-             | BI_beq -> "beq"
-             | BI_bgt -> "bgt"
-             | BI_bgt_un -> "bgt.un"
-             | BI_bge -> "bge"
-             | BI_bge_un -> "bge.un"
-             | BI_ble -> "ble"
-             | BI_ble_un -> "ble.un"
-             | BI_blt -> "blt"
-             | BI_blt_un -> "blt.un"
-             | BI_bne_un -> "bne.un"
-             | BI_brfalse -> "brfalse"
-             | BI_brtrue -> "brtrue")
-
-        output_string os " "
-        output_code_label os tg1
-    | I_br tg ->
-        output_string os "/* br "
-        output_code_label os tg
-        output_string os "*/"
-    | I_leave tg ->
-        output_string os "leave "
-        output_code_label os tg
-    | I_call (tl, mspec, varargs) ->
-        output_tailness os tl
-        output_string os "call "
-        goutput_vararg_mspec env os (mspec, varargs)
-        output_after_tailcall os tl
-    | I_calli (tl, mref, varargs) ->
-        output_tailness os tl
-        output_string os "calli "
-        goutput_vararg_sig env os (mref, varargs)
-        output_after_tailcall os tl
-    | I_ldarg u16 ->
-        output_string os "ldarg"
-        output_short_u16 os u16
-    | I_ldarga u16 ->
-        output_string os "ldarga "
-        output_u16 os u16
-    | AI_ldc (dt, ILConst.I4 x) ->
-        output_string os "ldc."
-        output_basic_type os dt
-        output_short_i32 os x
-    | AI_ldc (dt, ILConst.I8 x) ->
-        output_string os "ldc."
-        output_basic_type os dt
-        output_string os " "
-        output_i64 os x
-    | AI_ldc (dt, ILConst.R4 x) ->
-        output_string os "ldc."
-        output_basic_type os dt
-        output_string os " "
-        output_ieee32 os x
-    | AI_ldc (dt, ILConst.R8 x) ->
-        output_string os "ldc."
-        output_basic_type os dt
-        output_string os " "
-        output_ieee64 os x
-    | I_ldftn mspec ->
-        output_string os "ldftn "
-        goutput_mspec env os mspec
-    | I_ldvirtftn mspec ->
-        output_string os "ldvirtftn "
-        goutput_mspec env os mspec
-    | I_ldind (al, vol, dt) ->
-        output_alignment os al
-        output_volatility os vol
-        output_string os "ldind."
-        output_basic_type os dt
-    | I_cpblk (al, vol) ->
-        output_alignment os al
-        output_volatility os vol
-        output_string os "cpblk"
-    | I_initblk (al, vol) ->
-        output_alignment os al
-        output_volatility os vol
-        output_string os "initblk"
-    | I_ldloc u16 ->
-        output_string os "ldloc"
-        output_short_u16 os u16
-    | I_ldloca u16 ->
-        output_string os "ldloca "
-        output_u16 os u16
-    | I_starg u16 ->
-        output_string os "starg "
-        output_u16 os u16
-    | I_stind (al, vol, dt) ->
-        output_alignment os al
-        output_volatility os vol
-        output_string os "stind."
-        output_basic_type os dt
-    | I_stloc u16 ->
-        output_string os "stloc"
-        output_short_u16 os u16
-    | I_switch l ->
-        output_string os "switch "
-        output_parens (output_seq ", " output_code_label) os l
-    | I_callvirt (tl, mspec, varargs) ->
-        output_tailness os tl
-        output_string os "callvirt "
-        goutput_vararg_mspec env os (mspec, varargs)
-        output_after_tailcall os tl
-    | I_callconstraint (callvirt, tl, ty, mspec, varargs) ->
-        output_tailness os tl
-        output_string os "constraint. "
-        goutput_typ env os ty
-        output_string os (if callvirt then " callvirt " else " call ")
-        goutput_vararg_mspec env os (mspec, varargs)
-        output_after_tailcall os tl
-    | I_castclass ty ->
-        output_string os "castclass "
-        goutput_typ env os ty
-    | I_isinst ty ->
-        output_string os "isinst "
-        goutput_typ env os ty
-    | I_ldfld (al, vol, fspec) ->
-        output_alignment os al
-        output_volatility os vol
-        output_string os "ldfld "
-        goutput_fspec env os fspec
-    | I_ldflda fspec ->
-        output_string os "ldflda "
-        goutput_fspec env os fspec
-    | I_ldsfld (vol, fspec) ->
-        output_volatility os vol
-        output_string os "ldsfld "
-        goutput_fspec env os fspec
-    | I_ldsflda fspec ->
-        output_string os "ldsflda "
-        goutput_fspec env os fspec
-    | I_stfld (al, vol, fspec) ->
-        output_alignment os al
-        output_volatility os vol
-        output_string os "stfld "
-        goutput_fspec env os fspec
-    | I_stsfld (vol, fspec) ->
-        output_volatility os vol
-        output_string os "stsfld "
-        goutput_fspec env os fspec
-    | I_ldtoken tok ->
-        output_string os "ldtoken "
-        goutput_ldtoken_info env os tok
-    | I_refanyval ty ->
-        output_string os "refanyval "
-        goutput_typ env os ty
-    | I_refanytype -> output_string os "refanytype"
-    | I_mkrefany typ ->
-        output_string os "mkrefany "
-        goutput_typ env os typ
-    | I_ldstr s ->
-        output_string os "ldstr "
-        output_string os s
-    | I_newobj (mspec, varargs) ->
-        // newobj: IL has a special rule that the CC is always implicitly "instance" and need
-        // not be mentioned explicitly
-        output_string os "newobj "
-        goutput_vararg_mspec env os (mspec, varargs)
-    | I_stelem dt ->
-        output_string os "stelem."
-        output_basic_type os dt
-    | I_ldelem dt ->
-        output_string os "ldelem."
-        output_basic_type os dt
-
-    | I_newarr (shape, typ) ->
-        if shape = ILArrayShape.SingleDimensional then
-            output_string os "newarr "
-            goutput_typ_with_shortened_class_syntax env os typ
-        else
-            output_string os "newobj void "
-            goutput_dlocref env os (mkILArrTy (typ, shape))
-            output_string os ".ctor"
-            let rank = shape.Rank
-            output_parens (output_array ", " (goutput_typ env)) os (Array.create rank PrimaryAssemblyILGlobals.typ_Int32)
-    | I_stelem_any (shape, dt) ->
-        if shape = ILArrayShape.SingleDimensional then
-            output_string os "stelem.any "
-            goutput_typ env os dt
-        else
-            output_string os "call instance void "
-            goutput_dlocref env os (mkILArrTy (dt, shape))
-            output_string os "Set"
-            let rank = shape.Rank
-            let arr = Array.create (rank + 1) PrimaryAssemblyILGlobals.typ_Int32
-            arr[rank] <- dt
-            output_parens (output_array ", " (goutput_typ env)) os arr
-    | I_ldelem_any (shape, tok) ->
-        if shape = ILArrayShape.SingleDimensional then
-            output_string os "ldelem.any "
-            goutput_typ env os tok
-        else
-            output_string os "call instance "
-            goutput_typ env os tok
-            output_string os " "
-            goutput_dlocref env os (mkILArrTy (tok, shape))
-            output_string os "Get"
-            let rank = shape.Rank
-            output_parens (output_array ", " (goutput_typ env)) os (Array.create rank PrimaryAssemblyILGlobals.typ_Int32)
-    | I_ldelema (ro, _, shape, tok) ->
-        if ro = ReadonlyAddress then
-            output_string os "readonly. "
-
-        if shape = ILArrayShape.SingleDimensional then
-            output_string os "ldelema "
-            goutput_typ env os tok
-        else
-            output_string os "call instance "
-            goutput_typ env os (ILType.Byref tok)
-            output_string os " "
-            goutput_dlocref env os (mkILArrTy (tok, shape))
-            output_string os "Address"
-            let rank = shape.Rank
-            output_parens (output_array ", " (goutput_typ env)) os (Array.create rank PrimaryAssemblyILGlobals.typ_Int32)
-
-    | I_box tok ->
-        output_string os "box "
-        goutput_typ env os tok
-    | I_unbox tok ->
-        output_string os "unbox "
-        goutput_typ env os tok
-    | I_unbox_any tok ->
-        output_string os "unbox.any "
-        goutput_typ env os tok
-    | I_initobj tok ->
-        output_string os "initobj "
-        goutput_typ env os tok
-    | I_ldobj (al, vol, tok) ->
-        output_alignment os al
-        output_volatility os vol
-        output_string os "ldobj "
-        goutput_typ env os tok
-    | I_stobj (al, vol, tok) ->
-        output_alignment os al
-        output_volatility os vol
-        output_string os "stobj "
-        goutput_typ env os tok
-    | I_cpobj tok ->
-        output_string os "cpobj "
-        goutput_typ env os tok
-    | I_sizeof tok ->
-        output_string os "sizeof "
-        goutput_typ env os tok
-    | I_seqpoint s -> output_source os s
-    | EI_ilzero ty ->
-        output_string os "ilzero "
-        goutput_typ env os ty
-    | _ -> output_string os "<printing for this instruction is not implemented>"
-
 let goutput_ilmbody env os (il: ILMethodBody) =
     if il.IsZeroInit then
         output_string os " .zeroinit\n"
@@ -1198,11 +752,6 @@ let goutput_superclass env os =
         output_string os "extends "
         (goutput_typ_with_shortened_class_syntax env) os typ
 
-let goutput_superinterfaces env os imp =
-    if not (List.isEmpty imp) then
-        output_string os "implements "
-        output_seq ", " (goutput_typ_with_shortened_class_syntax env) os imp
-
 let goutput_implements env os (imp: ILTypes) =
     if not (List.isEmpty imp) then
         output_string os "implements "
@@ -1337,48 +886,10 @@ let output_locale os s =
     output_string os " .Locale "
     output_qstring os s
 
-let output_hash os x =
-    output_string os " .hash = "
-    output_parens output_bytes os x
-
-let output_publickeytoken os x =
-    output_string os " .publickeytoken = "
-    output_parens output_bytes os x
-
 let output_publickey os x =
     output_string os " .publickey = "
     output_parens output_bytes os x
 
-let output_publickeyinfo os =
-    function
-    | PublicKey k -> output_publickey os k
-    | PublicKeyToken k -> output_publickeytoken os k
-
-let output_assemblyRef os (aref: ILAssemblyRef) =
-    output_string os " .assembly extern "
-    output_sqstring os aref.Name
-
-    if aref.Retargetable then
-        output_string os " retargetable "
-
-    output_string os " { "
-    output_option output_hash os aref.Hash
-    output_option output_publickeyinfo os aref.PublicKey
-    output_option output_ver os aref.Version
-    output_option output_locale os aref.Locale
-    output_string os " } "
-
-let output_modref os (modref: ILModuleRef) =
-    output_string
-        os
-        (if modref.HasMetadata then
-             " .module extern "
-         else
-             " .file nometadata ")
-
-    output_sqstring os modref.Name
-    output_option output_hash os modref.Hash
-
 let goutput_resource env os r =
     output_string os " .mresource "
 
diff --git a/src/Compiler/AbstractIL/ilread.fs b/src/Compiler/AbstractIL/ilread.fs
index 06c50483a2e..7c7f26a699b 100644
--- a/src/Compiler/AbstractIL/ilread.fs
+++ b/src/Compiler/AbstractIL/ilread.fs
@@ -73,8 +73,6 @@ let doubleOfBits (x: int64) = BitConverter.Int64BitsToDouble x
 let align alignment n =
     ((n + alignment - 0x1) / alignment) * alignment
 
-let uncodedToken (tab: TableName) idx = ((tab.Index <<< 24) ||| idx)
-
 let i32ToUncodedToken tok =
     let idx = tok &&& 0xffffff
     let tab = tok >>>& 24
@@ -329,8 +327,6 @@ let seekReadUserString mdv addr =
     let bytes = seekReadBytes mdv addr (len - 1)
     Encoding.Unicode.GetString(bytes, 0, bytes.Length)
 
-let seekReadGuid mdv addr = seekReadBytes mdv addr 0x10
-
 let seekReadUncodedToken mdv addr =
     i32ToUncodedToken (seekReadInt32 mdv addr)
 
@@ -748,9 +744,6 @@ let rec getTwoByteInstr i =
 
 type ImageChunk = { size: int32; addr: int32 }
 
-let chunk sz next = ({ addr = next; size = sz }, next + sz)
-let nochunk next = ({ addr = 0x0; size = 0x0 }, next)
-
 type RowElementKind =
     | UShort
     | ULong
@@ -839,9 +832,6 @@ let kindExportedType = RowKind [ ULong; ULong; SString; SString; Implementation
 let kindAssembly =
     RowKind [ ULong; UShort; UShort; UShort; UShort; ULong; Blob; SString; SString ]
 
-let kindGenericParam_v1_1 =
-    RowKind [ UShort; UShort; TypeOrMethodDef; SString; TypeDefOrRefOrSpec ]
-
 let kindGenericParam_v2_0 = RowKind [ UShort; UShort; TypeOrMethodDef; SString ]
 let kindMethodSpec = RowKind [ MethodDefOrRef; Blob ]
 
@@ -997,17 +987,6 @@ let mkCacheGeneric lowMem _inbase _nm _sz =
 // Polymorphic general helpers for searching for particular rows.
 // ----------------------------------------------------------------------
 
-let seekFindRow numRows rowChooser =
-    let mutable i = 1
-
-    while (i <= numRows && not (rowChooser i)) do
-        i <- i + 1
-
-    if i > numRows then
-        dprintn "warning: seekFindRow: row not found"
-
-    i
-
 // search for rows satisfying predicate
 let seekReadIndexedRows (numRows, rowReader, keyFunc, keyComparer, binaryChop, rowConverter) =
     if binaryChop then
@@ -1220,12 +1199,9 @@ type ISeekReadIndexedRowReader<'RowT, 'KeyT, 'T when 'RowT: struct> =
     abstract CompareKey: 'KeyT -> int
     abstract ConvertRow: byref<'RowT> -> 'T
 
-let seekReadIndexedRowsRange numRows binaryChop (reader: ISeekReadIndexedRowReader<'RowT, _, _>) =
+let seekReadIndexedRowsByInterface numRows binaryChop (reader: ISeekReadIndexedRowReader<'RowT, _, _>) =
     let mutable row = Unchecked.defaultof<'RowT>
 
-    let mutable startRid = -1
-    let mutable endRid = -1
-
     if binaryChop then
         let mutable low = 0
         let mutable high = numRows + 1
@@ -1244,12 +1220,12 @@ let seekReadIndexedRowsRange numRows binaryChop (reader: ISeekReadIndexedRowRead
                 elif c < 0 then high <- mid
                 else fin <- true
 
+        let res = ImmutableArray.CreateBuilder()
+
         if high - low > 1 then
             // now read off rows, forward and backwards
             let mid = (low + high) / 2
 
-            startRid <- mid
-
             // read backwards
             let mutable fin = false
             let mutable curr = mid - 1
@@ -1261,12 +1237,14 @@ let seekReadIndexedRowsRange numRows binaryChop (reader: ISeekReadIndexedRowRead
                     reader.GetRow(curr, &row)
 
                     if reader.CompareKey(reader.GetKey(&row)) = 0 then
-                        startRid <- curr
+                        res.Add(reader.ConvertRow(&row))
                     else
                         fin <- true
 
                 curr <- curr - 1
 
+            res.Reverse()
+
             // read forward
             let mutable fin = false
             let mutable curr = mid
@@ -1278,47 +1256,23 @@ let seekReadIndexedRowsRange numRows binaryChop (reader: ISeekReadIndexedRowRead
                     reader.GetRow(curr, &row)
 
                     if reader.CompareKey(reader.GetKey(&row)) = 0 then
-                        endRid <- curr
+                        res.Add(reader.ConvertRow(&row))
                     else
                         fin <- true
 
                     curr <- curr + 1
 
+        res.ToArray()
     else
-        let mutable rid = 1
+        let res = ImmutableArray.CreateBuilder()
 
-        while rid <= numRows && startRid = -1 do
-            reader.GetRow(rid, &row)
+        for i = 1 to numRows do
+            reader.GetRow(i, &row)
 
             if reader.CompareKey(reader.GetKey(&row)) = 0 then
-                startRid <- rid
-                endRid <- rid
-
-            rid <- rid + 1
-
-        let mutable fin = false
-
-        while rid <= numRows && not fin do
-            reader.GetRow(rid, &row)
-
-            if reader.CompareKey(reader.GetKey(&row)) = 0 then
-                endRid <- rid
-            else
-                fin <- true
-
-    startRid, endRid
-
-let seekReadIndexedRowsByInterface numRows binaryChop (reader: ISeekReadIndexedRowReader<'RowT, _, _>) =
-    let startRid, endRid = seekReadIndexedRowsRange numRows binaryChop reader
-
-    if startRid <= 0 || endRid < startRid then
-        [||]
-    else
+                res.Add(reader.ConvertRow(&row))
 
-        Array.init (endRid - startRid + 1) (fun i ->
-            let mutable row = Unchecked.defaultof<'RowT>
-            reader.GetRow(startRid + i, &row)
-            reader.ConvertRow(&row))
+        res.ToArray()
 
 [<Struct>]
 type CustomAttributeRow =
diff --git a/src/Compiler/AbstractIL/ilreflect.fs b/src/Compiler/AbstractIL/ilreflect.fs
index 5cf3ec58222..f22d36e6818 100644
--- a/src/Compiler/AbstractIL/ilreflect.fs
+++ b/src/Compiler/AbstractIL/ilreflect.fs
@@ -417,9 +417,6 @@ let equalTypes (s: Type) (t: Type) = Type.op_Equality (s, t)
 let equalTypeLists (tys1: Type list) (tys2: Type list) =
     List.lengthsEqAndForall2 equalTypes tys1 tys2
 
-let equalTypeArrays (tys1: Type[]) (tys2: Type[]) =
-    Array.lengthsEqAndForall2 equalTypes tys1 tys2
-
 let getGenericArgumentsOfType (typT: Type) =
     if typT.IsGenericType then
         typT.GetGenericArguments()
@@ -626,8 +623,6 @@ let envSetLocals emEnv locs =
     assert (emEnv.emLocals.Length = 0) // check "locals" is not yet set (scopes once only)
     { emEnv with emLocals = locs }
 
-let envGetLocal emEnv i = emEnv.emLocals[i]
-
 let envSetLabel emEnv name lab =
     assert (not (Zmap.mem name emEnv.emLabels))
 
@@ -1152,10 +1147,6 @@ let convConstructorSpec cenv emEnv (mspec: ILMethodSpec) =
         )
     | NonNull res -> res
 
-let emitLabelMark emEnv (ilG: ILGenerator) (label: ILCodeLabel) =
-    let lab = envGetLabel emEnv label
-    ilG.MarkLabelAndLog lab
-
 ///Emit comparison instructions.
 let emitInstrCompare emEnv (ilG: ILGenerator) comp targ =
     match comp with
@@ -1219,28 +1210,6 @@ let emitInstrCall cenv emEnv (ilG: ILGenerator) opCall tail (mspec: ILMethodSpec
             | None -> ilG.EmitAndLog(opCall, minfo)
             | Some varargTys -> ilG.EmitCall(opCall, minfo, convTypesToArray cenv emEnv varargTys))
 
-let getGenericMethodDefinition q (ty: Type) =
-    let gminfo =
-        match q with
-        | Quotations.Patterns.Call (_, minfo, _) -> minfo.GetGenericMethodDefinition()
-        | _ -> failwith "unexpected failure decoding quotation at ilreflect startup"
-
-    gminfo.MakeGenericMethod [| ty |]
-
-let getArrayMethInfo n ty =
-    match n with
-    | 2 -> getGenericMethodDefinition <@@ LanguagePrimitives.IntrinsicFunctions.GetArray2D<int> null 0 0 @@> ty
-    | 3 -> getGenericMethodDefinition <@@ LanguagePrimitives.IntrinsicFunctions.GetArray3D<int> null 0 0 0 @@> ty
-    | 4 -> getGenericMethodDefinition <@@ LanguagePrimitives.IntrinsicFunctions.GetArray4D<int> null 0 0 0 0 @@> ty
-    | _ -> invalidArg "n" "not expecting array dimension > 4"
-
-let setArrayMethInfo n ty =
-    match n with
-    | 2 -> getGenericMethodDefinition <@@ LanguagePrimitives.IntrinsicFunctions.SetArray2D<int> null 0 0 0 @@> ty
-    | 3 -> getGenericMethodDefinition <@@ LanguagePrimitives.IntrinsicFunctions.SetArray3D<int> null 0 0 0 0 @@> ty
-    | 4 -> getGenericMethodDefinition <@@ LanguagePrimitives.IntrinsicFunctions.SetArray4D<int> null 0 0 0 0 0 @@> ty
-    | _ -> invalidArg "n" "not expecting array dimension > 4"
-
 //----------------------------------------------------------------------------
 // emitInstr cenv
 //----------------------------------------------------------------------------
@@ -2104,35 +2073,6 @@ let buildMethodImplsPass3 cenv _tref (typB: TypeBuilder) emEnv (mimpl: ILMethodI
 // typeAttributesOf*
 //----------------------------------------------------------------------------
 
-let typeAttributesOfTypeDefKind x =
-    match x with
-    // required for a TypeBuilder
-    | ILTypeDefKind.Class -> TypeAttributes.Class
-    | ILTypeDefKind.ValueType -> TypeAttributes.Class
-    | ILTypeDefKind.Interface -> TypeAttributes.Interface
-    | ILTypeDefKind.Enum -> TypeAttributes.Class
-    | ILTypeDefKind.Delegate -> TypeAttributes.Class
-
-let typeAttributesOfTypeAccess x =
-    match x with
-    | ILTypeDefAccess.Public -> TypeAttributes.Public
-    | ILTypeDefAccess.Private -> TypeAttributes.NotPublic
-    | ILTypeDefAccess.Nested macc ->
-        match macc with
-        | ILMemberAccess.Assembly -> TypeAttributes.NestedAssembly
-        | ILMemberAccess.CompilerControlled -> failwith "Nested compiler controlled."
-        | ILMemberAccess.FamilyAndAssembly -> TypeAttributes.NestedFamANDAssem
-        | ILMemberAccess.FamilyOrAssembly -> TypeAttributes.NestedFamORAssem
-        | ILMemberAccess.Family -> TypeAttributes.NestedFamily
-        | ILMemberAccess.Private -> TypeAttributes.NestedPrivate
-        | ILMemberAccess.Public -> TypeAttributes.NestedPublic
-
-let typeAttributesOfTypeEncoding x =
-    match x with
-    | ILDefaultPInvokeEncoding.Ansi -> TypeAttributes.AnsiClass
-    | ILDefaultPInvokeEncoding.Auto -> TypeAttributes.AutoClass
-    | ILDefaultPInvokeEncoding.Unicode -> TypeAttributes.UnicodeClass
-
 let typeAttributesOfTypeLayout cenv emEnv x =
     let attr x p =
         if p.Size = None && p.Pack = None then
diff --git a/src/Compiler/AbstractIL/ilsign.fs b/src/Compiler/AbstractIL/ilsign.fs
index 0239f4759c0..5d4d37c97fb 100644
--- a/src/Compiler/AbstractIL/ilsign.fs
+++ b/src/Compiler/AbstractIL/ilsign.fs
@@ -28,10 +28,6 @@ let CALG_RSA_SIGN = int (ALG_CLASS_SIGNATURE ||| ALG_TYPE_RSA)
 let ALG_CLASS_HASH = int (4 <<< 13)
 let ALG_TYPE_ANY = int 0
 let CALG_SHA1 = int (ALG_CLASS_HASH ||| ALG_TYPE_ANY ||| 4)
-let CALG_SHA_256 = int (ALG_CLASS_HASH ||| ALG_TYPE_ANY ||| 12)
-let CALG_SHA_384 = int (ALG_CLASS_HASH ||| ALG_TYPE_ANY ||| 13)
-let CALG_SHA_512 = int (ALG_CLASS_HASH ||| ALG_TYPE_ANY ||| 14)
-
 let PUBLICKEYBLOB = int 0x6
 let PRIVATEKEYBLOB = int 0x7
 let BLOBHEADER_CURRENT_BVERSION = int 0x2
@@ -41,10 +37,6 @@ let RSA_PRIV_MAGIC = int 0x32415352
 
 let getResourceString (_, str) = str
 
-let check _action hresult =
-    if uint32 hresult >= 0x80000000ul then
-        Marshal.ThrowExceptionForHR hresult
-
 [<Struct; StructLayout(LayoutKind.Explicit)>]
 type ByteArrayUnion =
     [<FieldOffset(0)>]
@@ -297,12 +289,6 @@ let signStream stream keyBlob =
     let signature = createSignature hash keyBlob KeyType.KeyPair
     patchSignature stream peReader signature
 
-let signFile fileName keyBlob =
-    use fs =
-        FileSystem.OpenFileForWriteShim(fileName, FileMode.Open, FileAccess.ReadWrite)
-
-    signStream fs keyBlob
-
 let signatureSize (pk: byte[]) =
     if pk.Length < 25 then
         raise (CryptographicException(getResourceString (FSComp.SR.ilSignInvalidPKBlob ())))
@@ -331,26 +317,11 @@ type keyPair = byte[]
 type pubkey = byte[]
 type pubkeyOptions = byte[] * bool
 
-let signerOpenPublicKeyFile filePath =
-    FileSystem.OpenFileForReadShim(filePath).ReadAllBytes()
-
-let signerOpenKeyPairFile filePath =
-    FileSystem.OpenFileForReadShim(filePath).ReadAllBytes()
-
 let signerGetPublicKeyForKeyPair (kp: keyPair) : pubkey = getPublicKeyForKeyPair kp
 
-let signerGetPublicKeyForKeyContainer (_kcName: keyContainerName) : pubkey =
-    raise (NotImplementedException("signerGetPublicKeyForKeyContainer is not yet implemented"))
-
-let signerCloseKeyContainer (_kc: keyContainerName) : unit =
-    raise (NotImplementedException("signerCloseKeyContainer is not yet implemented"))
-
 let signerSignatureSize (pk: pubkey) : int = signatureSize pk
 
-let signerSignFileWithKeyPair (fileName: string) (kp: keyPair) : unit = signFile fileName kp
-
-let signerSignFileWithKeyContainer (_fileName: string) (_kcName: keyContainerName) : unit =
-    raise (NotImplementedException("signerSignFileWithKeyContainer is not yet implemented"))
+let signerSignStreamWithKeyPair stream keyBlob = signStream stream keyBlob
 
 let failWithContainerSigningUnsupportedOnThisPlatform () =
     failwith (FSComp.SR.containerSigningUnsupportedOnThisPlatform () |> snd)
@@ -364,20 +335,12 @@ type ILStrongNameSigner =
     | KeyPair of keyPair
     | KeyContainer of keyContainerName
 
-    static member OpenPublicKeyOptions s p =
-        PublicKeyOptionsSigner((signerOpenPublicKeyFile s), p)
+    static member OpenPublicKeyOptions kp p = PublicKeyOptionsSigner(kp, p)
 
-    static member OpenPublicKey pubkey = PublicKeySigner pubkey
-    static member OpenKeyPairFile s = KeyPair(signerOpenKeyPairFile s)
+    static member OpenPublicKey bytes = PublicKeySigner bytes
+    static member OpenKeyPairFile bytes = KeyPair(bytes)
     static member OpenKeyContainer s = KeyContainer s
 
-    member s.Close() =
-        match s with
-        | PublicKeySigner _
-        | PublicKeyOptionsSigner _
-        | KeyPair _ -> ()
-        | KeyContainer _ -> failWithContainerSigningUnsupportedOnThisPlatform ()
-
     member s.IsFullySigned =
         match s with
         | PublicKeySigner _ -> false
@@ -412,9 +375,9 @@ type ILStrongNameSigner =
         | KeyPair kp -> pkSignatureSize (signerGetPublicKeyForKeyPair kp)
         | KeyContainer _ -> failWithContainerSigningUnsupportedOnThisPlatform ()
 
-    member s.SignFile file =
+    member s.SignStream stream =
         match s with
         | PublicKeySigner _ -> ()
         | PublicKeyOptionsSigner _ -> ()
-        | KeyPair kp -> signerSignFileWithKeyPair file kp
+        | KeyPair kp -> signerSignStreamWithKeyPair stream kp
         | KeyContainer _ -> failWithContainerSigningUnsupportedOnThisPlatform ()
diff --git a/src/Compiler/AbstractIL/ilsign.fsi b/src/Compiler/AbstractIL/ilsign.fsi
index 23a82daffca..9dcdbf8ecda 100644
--- a/src/Compiler/AbstractIL/ilsign.fsi
+++ b/src/Compiler/AbstractIL/ilsign.fsi
@@ -7,18 +7,20 @@
 
 module internal FSharp.Compiler.AbstractIL.StrongNameSign
 
+open System
+open System.IO
+
 //---------------------------------------------------------------------
 // Strong name signing
 //---------------------------------------------------------------------
 [<Sealed>]
 type ILStrongNameSigner =
     member PublicKey: byte[]
-    static member OpenPublicKeyOptions: string -> bool -> ILStrongNameSigner
+    static member OpenPublicKeyOptions: byte array -> bool -> ILStrongNameSigner
     static member OpenPublicKey: byte[] -> ILStrongNameSigner
-    static member OpenKeyPairFile: string -> ILStrongNameSigner
+    static member OpenKeyPairFile: byte[] -> ILStrongNameSigner
     static member OpenKeyContainer: string -> ILStrongNameSigner
-    member Close: unit -> unit
     member IsFullySigned: bool
     member PublicKey: byte[]
     member SignatureSize: int
-    member SignFile: string -> unit
+    member SignStream: Stream -> unit
diff --git a/src/Compiler/AbstractIL/ilsupp.fs b/src/Compiler/AbstractIL/ilsupp.fs
index 272f7b74029..513d14d9f51 100644
--- a/src/Compiler/AbstractIL/ilsupp.fs
+++ b/src/Compiler/AbstractIL/ilsupp.fs
@@ -16,19 +16,9 @@ let DateTime1970Jan01 =
 let absilWriteGetTimeStamp () =
     (DateTime.UtcNow - DateTime1970Jan01).TotalSeconds |> int
 
-// Force inline, so GetLastWin32Error calls are immediately after interop calls as seen by FxCop under Debug build.
-let inline ignore _x = ()
-
 // Native Resource linking/unlinking
 type IStream = System.Runtime.InteropServices.ComTypes.IStream
 
-let check _action hresult =
-    if uint32 hresult >= 0x80000000ul then
-        Marshal.ThrowExceptionForHR hresult
-//printf "action = %s, hresult = 0x%nx \n" action hresult
-
-let MAX_PATH = 260
-
 let E_FAIL = 0x80004005
 
 let bytesToWord (b0: byte, b1: byte) = int16 b0 ||| (int16 b1 <<< 8)
@@ -36,16 +26,6 @@ let bytesToWord (b0: byte, b1: byte) = int16 b0 ||| (int16 b1 <<< 8)
 let bytesToDWord (b0: byte, b1: byte, b2: byte, b3: byte) =
     int b0 ||| (int b1 <<< 8) ||| (int b2 <<< 16) ||| (int b3 <<< 24)
 
-let bytesToQWord (b0: byte, b1: byte, b2: byte, b3: byte, b4: byte, b5: byte, b6: byte, b7: byte) =
-    int64 b0
-    ||| (int64 b1 <<< 8)
-    ||| (int64 b2 <<< 16)
-    ||| (int64 b3 <<< 24)
-    ||| (int64 b4 <<< 32)
-    ||| (int64 b5 <<< 40)
-    ||| (int64 b6 <<< 48)
-    ||| (int64 b7 <<< 56)
-
 let dwToBytes n =
     [|
         byte (n &&& 0xff)
@@ -110,20 +90,6 @@ type IMAGE_FILE_HEADER(m: int16, secs: int16, tds: int32, ptst: int32, nos: int3
         buf.EmitUInt16(uint16 characteristics)
         buf.AsMemory().ToArray()
 
-let bytesToIFH (buffer: byte[]) (offset: int) =
-    if (buffer.Length - offset) < IMAGE_FILE_HEADER.Width then
-        invalidArg "buffer" "buffer too small to fit an IMAGE_FILE_HEADER"
-
-    IMAGE_FILE_HEADER(
-        bytesToWord (buffer[offset], buffer[offset + 1]), // Machine
-        bytesToWord (buffer[offset + 2], buffer[offset + 3]), // NumberOfSections
-        bytesToDWord (buffer[offset + 4], buffer[offset + 5], buffer[offset + 6], buffer[offset + 7]), // TimeDateStamp
-        bytesToDWord (buffer[offset + 8], buffer[offset + 9], buffer[offset + 10], buffer[offset + 11]), // PointerToSymbolTable
-        bytesToDWord (buffer[offset + 12], buffer[offset + 13], buffer[offset + 14], buffer[offset + 15]), // NumberOfSymbols
-        bytesToWord (buffer[offset + 16], buffer[offset + 17]), // SizeOfOptionalHeader
-        bytesToWord (buffer[offset + 18], buffer[offset + 19])
-    ) // Characteristics
-
 type IMAGE_SECTION_HEADER(n: int64, ai: int32, va: int32, srd: int32, prd: int32, pr: int32, pln: int32, nr: int16, nl: int16, c: int32) =
     let mutable name = n
     let mutable addressInfo = ai // PhysicalAddress / VirtualSize
@@ -196,32 +162,6 @@ type IMAGE_SECTION_HEADER(n: int64, ai: int32, va: int32, srd: int32, prd: int32
         buf.EmitInt32 characteristics
         buf.AsMemory().ToArray()
 
-let bytesToISH (buffer: byte[]) (offset: int) =
-    if (buffer.Length - offset) < IMAGE_SECTION_HEADER.Width then
-        invalidArg "buffer" "buffer too small to fit an IMAGE_SECTION_HEADER"
-
-    IMAGE_SECTION_HEADER(
-        bytesToQWord (
-            buffer[offset],
-            buffer[offset + 1],
-            buffer[offset + 2],
-            buffer[offset + 3],
-            buffer[offset + 4],
-            buffer[offset + 5],
-            buffer[offset + 6],
-            buffer[offset + 7]
-        ), // Name
-        bytesToDWord (buffer[offset + 8], buffer[offset + 9], buffer[offset + 10], buffer[offset + 11]), // AddressInfo
-        bytesToDWord (buffer[offset + 12], buffer[offset + 13], buffer[offset + 14], buffer[offset + 15]), // VirtualAddress
-        bytesToDWord (buffer[offset + 16], buffer[offset + 17], buffer[offset + 18], buffer[offset + 19]), // SizeOfRawData
-        bytesToDWord (buffer[offset + 20], buffer[offset + 21], buffer[offset + 22], buffer[offset + 23]), // PointerToRawData
-        bytesToDWord (buffer[offset + 24], buffer[offset + 25], buffer[offset + 26], buffer[offset + 27]), // PointerToRelocations
-        bytesToDWord (buffer[offset + 28], buffer[offset + 29], buffer[offset + 30], buffer[offset + 31]), // PointerToLineNumbers
-        bytesToWord (buffer[offset + 32], buffer[offset + 33]), // NumberOfRelocations
-        bytesToWord (buffer[offset + 34], buffer[offset + 35]), // NumberOfLineNumbers
-        bytesToDWord (buffer[offset + 36], buffer[offset + 37], buffer[offset + 38], buffer[offset + 39])
-    ) // Characteristics
-
 type IMAGE_SYMBOL(n: int64, v: int32, sn: int16, t: int16, sc: byte, nas: byte) =
     let mutable name = n
     let mutable value = v
@@ -266,28 +206,6 @@ type IMAGE_SYMBOL(n: int64, v: int32, sn: int16, t: int16, sc: byte, nas: byte)
         buf.EmitByte numberOfAuxSymbols
         buf.AsMemory().ToArray()
 
-let bytesToIS (buffer: byte[]) (offset: int) =
-    if (buffer.Length - offset) < IMAGE_SYMBOL.Width then
-        invalidArg "buffer" "buffer too small to fit an IMAGE_SYMBOL"
-
-    IMAGE_SYMBOL(
-        bytesToQWord (
-            buffer[offset],
-            buffer[offset + 1],
-            buffer[offset + 2],
-            buffer[offset + 3],
-            buffer[offset + 4],
-            buffer[offset + 5],
-            buffer[offset + 6],
-            buffer[offset + 7]
-        ), // Name
-        bytesToDWord (buffer[offset + 8], buffer[offset + 9], buffer[offset + 10], buffer[offset + 11]), // Value
-        bytesToWord (buffer[offset + 12], buffer[offset + 13]), // SectionNumber
-        bytesToWord (buffer[offset + 14], buffer[offset + 15]), // Type
-        buffer[offset + 16],
-        buffer[offset + 17]
-    ) // NumberOfAuxSymbols
-
 type IMAGE_RELOCATION(va: int32, sti: int32, t: int16) =
     let mutable virtualAddress = va // Also RelocCount
     let mutable symbolTableIndex = sti
@@ -318,16 +236,6 @@ type IMAGE_RELOCATION(va: int32, sti: int32, t: int16) =
         buf.EmitUInt16(uint16 ty)
         buf.AsMemory().ToArray()
 
-let bytesToIR (buffer: byte[]) (offset: int) =
-    if (buffer.Length - offset) < IMAGE_RELOCATION.Width then
-        invalidArg "buffer" "buffer too small to fit an IMAGE_RELOCATION"
-
-    IMAGE_RELOCATION(
-        bytesToDWord (buffer[offset], buffer[offset + 1], buffer[offset + 2], buffer[offset + 3]),
-        bytesToDWord (buffer[offset + 4], buffer[offset + 5], buffer[offset + 6], buffer[offset + 7]),
-        bytesToWord (buffer[offset + 8], buffer[offset + 9])
-    )
-
 type IMAGE_RESOURCE_DIRECTORY(c: int32, tds: int32, mjv: int16, mnv: int16, nne: int16, nie: int16) =
     let mutable characteristics = c
     let mutable timeDateStamp = tds
diff --git a/src/Compiler/AbstractIL/ilwrite.fs b/src/Compiler/AbstractIL/ilwrite.fs
index 80bb791c25f..d804ba2fb53 100644
--- a/src/Compiler/AbstractIL/ilwrite.fs
+++ b/src/Compiler/AbstractIL/ilwrite.fs
@@ -18,10 +18,6 @@ open FSharp.Compiler.DiagnosticsLogger
 open FSharp.Compiler.IO
 open FSharp.Compiler.Text.Range
 
-#if DEBUG
-let showEntryLookups = false
-#endif
-
 //---------------------------------------------------------------------
 // Byte, byte array fragments and other concrete representations
 // manipulations.
@@ -502,9 +498,7 @@ type cenv =
 
       emitTailcalls: bool
 
-      deterministic: bool
-
-      showTimes: bool
+      deterministic: bool    
 
       desiredMetadataVersion: ILVersionInfo
 
@@ -1075,18 +1069,6 @@ let GetMemberAccessFlags access =
     | ILMemberAccess.FamilyOrAssembly -> 0x00000005
     | ILMemberAccess.Assembly -> 0x00000003
 
-let GetTypeAccessFlags access =
-    match access with
-    | ILTypeDefAccess.Public -> 0x00000001
-    | ILTypeDefAccess.Private -> 0x00000000
-    | ILTypeDefAccess.Nested ILMemberAccess.Public -> 0x00000002
-    | ILTypeDefAccess.Nested ILMemberAccess.Private -> 0x00000003
-    | ILTypeDefAccess.Nested ILMemberAccess.Family -> 0x00000004
-    | ILTypeDefAccess.Nested ILMemberAccess.CompilerControlled -> failwith "bad type access"
-    | ILTypeDefAccess.Nested ILMemberAccess.FamilyAndAssembly -> 0x00000006
-    | ILTypeDefAccess.Nested ILMemberAccess.FamilyOrAssembly -> 0x00000007
-    | ILTypeDefAccess.Nested ILMemberAccess.Assembly -> 0x00000005
-
 exception MethodDefNotFound
 let FindMethodDefIdx cenv mdkey =
     try cenv.methodDefIdxsByKey.GetTableEntry mdkey
@@ -1192,7 +1174,7 @@ let canGenPropertyDef cenv (prop: ILPropertyDef) =
         // If we have GetMethod or SetMethod set (i.e. not None), try and see if we have MethodDefs for them.
         // NOTE: They can be not-None and missing MethodDefs if we skip generating them for reference assembly in the earlier pass.
         // Only generate property if we have at least getter or setter, otherwise, we skip.
-        [| prop.GetMethod; prop.SetMethod |]
+        [| prop.GetMethod; prop.SetMethod |]      
         |> Array.choose id
         |> Array.map (TryGetMethodRefAsMethodDefIdx cenv)
         |> Array.exists (function | Ok _ -> true | _ -> false)
@@ -1304,11 +1286,14 @@ and GenTypeDefPass2 pidx enc cenv (tdef: ILTypeDef) =
         // Now generate or assign index numbers for tables referenced by the maps.
         // Don't yet generate contents of these tables - leave that to pass3, as
         // code may need to embed these entries.
-        tdef.Implements |> List.iter (GenImplementsPass2 cenv env tidx)
-        props |> List.iter (GenPropertyDefPass2 cenv tidx)
+        tdef.Implements |> List.iter (GenImplementsPass2 cenv env tidx)        
         events |> List.iter (GenEventDefPass2 cenv tidx)
         tdef.Fields.AsList() |> List.iter (GenFieldDefPass2 tdef cenv tidx)
         tdef.Methods |> Seq.iter (GenMethodDefPass2 tdef cenv tidx)
+        // Generation of property definitions for **ref assemblies** is checking existence of generated method definitions.
+        // Therefore, due to mutable state within "cenv", order of operations matters.
+        // Who could have thought that using shared mutable state can bring unexpected bugs...?
+        props |> List.iter (GenPropertyDefPass2 cenv tidx)
         tdef.NestedTypes.AsList() |> GenTypeDefsPass2 tidx (enc@[tdef.Name]) cenv
    with exn ->
      failwith ("Error in pass2 for type "+tdef.Name+", error: " + exn.Message)
@@ -3020,14 +3005,14 @@ let GenModule (cenv : cenv) (modul: ILModuleDef) =
     let midx = AddUnsharedRow cenv TableNames.Module (GetModuleAsRow cenv modul)
     List.iter (GenResourcePass3 cenv) (modul.Resources.AsList())
     let tdefs = destTypeDefsWithGlobalFunctionsFirst cenv.ilg modul.TypeDefs
-    reportTime cenv.showTimes "Module Generation Preparation"
+    reportTime "Module Generation Preparation"
     GenTypeDefsPass1 [] cenv tdefs
-    reportTime cenv.showTimes "Module Generation Pass 1"
+    reportTime "Module Generation Pass 1"
     GenTypeDefsPass2 0 [] cenv tdefs
-    reportTime cenv.showTimes "Module Generation Pass 2"
+    reportTime "Module Generation Pass 2"
     (match modul.Manifest with None -> () | Some m -> GenManifestPass3 cenv m)
     GenTypeDefsPass3 [] cenv tdefs
-    reportTime cenv.showTimes "Module Generation Pass 3"
+    reportTime "Module Generation Pass 3"
     GenCustomAttrsPass3Or4 cenv (hca_Module, midx) modul.CustomAttrs
     // GenericParam is the only sorted table indexed by Columns in other tables (GenericParamConstraint\CustomAttributes).
     // Hence we need to sort it before we emit any entries in GenericParamConstraint\CustomAttributes that are attached to generic params.
@@ -3035,7 +3020,7 @@ let GenModule (cenv : cenv) (modul: ILModuleDef) =
     // the key --> index map since it is no longer valid
     cenv.GetTable(TableNames.GenericParam).SetRowsOfSharedTable (SortTableRows TableNames.GenericParam (cenv.GetTable(TableNames.GenericParam).GenericRowsOfTable))
     GenTypeDefsPass4 [] cenv tdefs
-    reportTime cenv.showTimes "Module Generation Pass 4"
+    reportTime "Module Generation Pass 4"
 
 /// Arbitrary value
 [<Literal>]
@@ -3053,8 +3038,7 @@ let generateIL (
     generatePdb,
     ilg: ILGlobals,
     emitTailcalls,
-    deterministic,
-    showTimes,
+    deterministic,  
     referenceAssemblyOnly,
     referenceAssemblyAttribOpt: ILAttribute option,
     allGivenSources,
@@ -3095,8 +3079,7 @@ let generateIL (
                 MetadataTable.Unshared (MetadataTable<UnsharedRow>.New ("row table "+string i, EqualityComparer.Default)))
     use cenv =
         { emitTailcalls=emitTailcalls
-          deterministic = deterministic
-          showTimes=showTimes
+          deterministic = deterministic         
           ilg = ilg
           desiredMetadataVersion=desiredMetadataVersion
           requiredDataFixups= requiredDataFixups
@@ -3180,7 +3163,7 @@ let generateIL (
        EventTokenMap = (fun t edef ->
         let tidx = idxForNextedTypeDef t
         getUncodedToken TableNames.Event (cenv.eventDefs.GetTableEntry (EventKey (tidx, edef.Name)))) }
-    reportTime cenv.showTimes "Finalize Module Generation Results"
+    reportTime "Finalize Module Generation Results"
     // New return the results
     let data = cenv.data.AsMemory().ToArray()
     let resources = cenv.resources.AsMemory().ToArray()
@@ -3214,8 +3197,7 @@ let writeILMetadataAndCode (
     desiredMetadataVersion,
     ilg,
     emitTailcalls,
-    deterministic,
-    showTimes,
+    deterministic,   
     referenceAssemblyOnly,
     referenceAssemblyAttribOpt,
     allGivenSources,
@@ -3237,8 +3219,7 @@ let writeILMetadataAndCode (
           generatePdb,
           ilg,
           emitTailcalls,
-          deterministic,
-          showTimes,
+          deterministic,       
           referenceAssemblyOnly,
           referenceAssemblyAttribOpt,
           allGivenSources,
@@ -3246,7 +3227,7 @@ let writeILMetadataAndCode (
           cilStartAddress,
           normalizeAssemblyRefs)
 
-    reportTime showTimes "Generated Tables and Code"
+    reportTime "Generated Tables and Code"
     let tableSize (tab: TableName) = tables[tab.Index].Count
 
    // Now place the code
@@ -3318,7 +3299,7 @@ let writeILMetadataAndCode (
       (if tableSize TableNames.GenericParamConstraint > 0 then 0x00001000 else 0x00000000) |||
       0x00000200
 
-    reportTime showTimes "Layout Header of Tables"
+    reportTime "Layout Header of Tables"
 
     let guidAddress n = (if n = 0 then 0 else (n - 1) * 0x10 + 0x01)
 
@@ -3362,7 +3343,7 @@ let writeILMetadataAndCode (
         if n >= blobAddressTable.Length then failwith "blob index out of range"
         blobAddressTable[n]
 
-    reportTime showTimes "Build String/Blob Address Tables"
+    reportTime "Build String/Blob Address Tables"
 
     let sortedTables =
       Array.init 64 (fun i ->
@@ -3371,7 +3352,7 @@ let writeILMetadataAndCode (
           let rows = tab.GenericRowsOfTable
           if TableRequiresSorting tabName then SortTableRows tabName rows else rows)
 
-    reportTime showTimes "Sort Tables"
+    reportTime "Sort Tables"
 
     let codedTables =
 
@@ -3486,7 +3467,7 @@ let writeILMetadataAndCode (
                 tablesBuf.EmitInt32 rows.Length
 
 
-        reportTime showTimes "Write Header of tablebuf"
+        reportTime "Write Header of tablebuf"
 
       // The tables themselves
         for rows in sortedTables do
@@ -3521,7 +3502,7 @@ let writeILMetadataAndCode (
 
         tablesBuf.AsMemory().ToArray()
 
-    reportTime showTimes "Write Tables to tablebuf"
+    reportTime "Write Tables to tablebuf"
 
     let tablesStreamUnpaddedSize = codedTables.Length
     // QUERY: extra 4 empty bytes in array.exe - why? Include some extra padding after
@@ -3538,7 +3519,7 @@ let writeILMetadataAndCode (
     let blobsChunk, _next = chunk blobsStreamPaddedSize next
     let blobsStreamPadding = blobsChunk.size - blobsStreamUnpaddedSize
 
-    reportTime showTimes "Layout Metadata"
+    reportTime "Layout Metadata"
 
     let metadata, guidStart =
       use mdbuf = ByteBuffer.Create(MetadataCapacity, useArrayPool = true)
@@ -3573,12 +3554,12 @@ let writeILMetadataAndCode (
       mdbuf.EmitInt32 blobsChunk.size
       mdbuf.EmitIntsAsBytes [| 0x23; 0x42; 0x6c; 0x6f; 0x62; 0x00; 0x00; 0x00; (* #Blob000 *)|]
 
-      reportTime showTimes "Write Metadata Header"
+      reportTime "Write Metadata Header"
      // Now the coded tables themselves
       mdbuf.EmitBytes codedTables
       for i = 1 to tablesStreamPadding do
           mdbuf.EmitIntAsByte 0x00
-      reportTime showTimes "Write Metadata Tables"
+      reportTime "Write Metadata Tables"
 
      // The string stream
       mdbuf.EmitByte 0x00uy
@@ -3586,7 +3567,7 @@ let writeILMetadataAndCode (
           mdbuf.EmitBytes s
       for i = 1 to stringsStreamPadding do
           mdbuf.EmitIntAsByte 0x00
-      reportTime showTimes "Write Metadata Strings"
+      reportTime "Write Metadata Strings"
      // The user string stream
       mdbuf.EmitByte 0x00uy
       for s in userStrings do
@@ -3596,7 +3577,7 @@ let writeILMetadataAndCode (
       for i = 1 to userStringsStreamPadding do
           mdbuf.EmitIntAsByte 0x00
 
-      reportTime showTimes "Write Metadata User Strings"
+      reportTime "Write Metadata User Strings"
     // The GUID stream
       let guidStart = mdbuf.Position
       Array.iter mdbuf.EmitBytes guids
@@ -3608,7 +3589,7 @@ let writeILMetadataAndCode (
           mdbuf.EmitBytes s
       for i = 1 to blobsStreamPadding do
           mdbuf.EmitIntAsByte 0x00
-      reportTime showTimes "Write Blob Stream"
+      reportTime "Write Blob Stream"
      // Done - close the buffer and return the result.
       mdbuf.AsMemory().ToArray(), guidStart
 
@@ -3624,7 +3605,7 @@ let writeILMetadataAndCode (
               let token = getUncodedToken TableNames.UserStrings (userStringAddress userStringIndex)
               if (Bytes.get code (locInCode-1) <> i_ldstr) then failwith "strings-in-code fixup: not at ldstr instruction!"
               applyFixup32 code locInCode token
-    reportTime showTimes "Fixup Metadata"
+    reportTime "Fixup Metadata"
 
     entryPointToken, code, codePadding, metadata, data, resources, requiredDataFixups.Value, pdbData, mappings, guidStart
 
@@ -3687,8 +3668,7 @@ let writeDirectory os dict =
 let writeBytes (os: BinaryWriter) (chunk: byte[]) = os.Write(chunk, 0, chunk.Length)
 
 let writePdb (
-    dumpDebugInfo,
-    showTimes,
+    dumpDebugInfo,   
     embeddedPDB,
     pdbfile,
     outfile,
@@ -3711,9 +3691,22 @@ let writePdb (
     // Used to capture the pdb file bytes in the case we're generating in-memory
     let mutable pdbBytes = None
 
+    let signImage () =
+        // Sign the binary. No further changes to binary allowed past this point!
+        match signer with
+        | None -> ()
+        | Some s ->
+            use fs = reopenOutput()
+            try
+                s.SignStream fs
+            with exn ->
+                failwith ($"Warning: A call to SignFile failed ({exn.Message})")
+        reportTime "Signing Image"
+
     // Now we've done the bulk of the binary, do the PDB file and fixup the binary.
     match pdbfile with
-    | None -> ()
+    | None -> signImage ()
+
     | Some pdbfile ->
         let idd =
             match pdbInfoOpt with
@@ -3738,7 +3731,7 @@ let writePdb (
                         stream.WriteTo fs
                     getInfoForPortablePdb contentId pdbfile pathMap debugDataChunk debugDeterministicPdbChunk debugChecksumPdbChunk algorithmName checkSum embeddedPDB deterministic
             | None -> [| |]
-        reportTime showTimes "Generate PDB Info"
+        reportTime "Generate PDB Info"
 
         // Now we have the debug data we can go back and fill in the debug directory in the image
         use fs2 = reopenOutput()
@@ -3763,28 +3756,15 @@ let writePdb (
                     os2.BaseStream.Seek (int64 (textV2P i.iddChunk.addr), SeekOrigin.Begin) |> ignore
                     if i.iddChunk.size < i.iddData.Length then failwith "Debug data area is not big enough. Debug info may not be usable"
                     writeBytes os2 i.iddData
+            reportTime "Finalize PDB"
+            signImage ()
             os2.Dispose()
         with exn ->
             failwith ("Error while writing debug directory entry: " + exn.Message)
             (try os2.Dispose(); FileSystem.FileDeleteShim outfile with _ -> ())
             reraise()
-
-    reportTime showTimes "Finalize PDB"
-
-    // Sign the binary. No further changes to binary allowed past this point!
-    match signer with
-    | None -> ()
-    | Some s ->
-        try
-            s.SignFile outfile
-            s.Close()
-        with exn ->
-            failwith ("Warning: A call to SignFile failed ("+exn.Message+")")
-            (try s.Close() with _ -> ())
-            (try FileSystem.FileDeleteShim outfile with _ -> ())
-            ()
-
-    reportTime showTimes "Signing Image"
+           
+    reportTime "Finish"
     pdbBytes
 
 type options =
@@ -3800,8 +3780,7 @@ type options =
      checksumAlgorithm: HashAlgorithm
      signer: ILStrongNameSigner option
      emitTailcalls: bool
-     deterministic: bool
-     showTimes: bool
+     deterministic: bool  
      dumpDebugInfo: bool
      referenceAssemblyOnly: bool
      referenceAssemblyAttribOpt: ILAttribute option
@@ -3812,7 +3791,7 @@ let writeBinaryAux (stream: Stream, options: options, modul, normalizeAssemblyRe
     // Store the public key from the signer into the manifest. This means it will be written
     // to the binary and also acts as an indicator to leave space for delay sign
 
-    reportTime options.showTimes "Write Started"
+    reportTime "Write Started"
     let isDll = modul.IsDLL
     let ilg = options.ilg
 
@@ -3926,8 +3905,7 @@ let writeBinaryAux (stream: Stream, options: options, modul, normalizeAssemblyRe
                   desiredMetadataVersion,
                   ilg,
                   options.emitTailcalls,
-                  options.deterministic,
-                  options.showTimes,
+                  options.deterministic,                 
                   options.referenceAssemblyOnly,
                   options.referenceAssemblyAttribOpt,
                   options.allGivenSources,
@@ -3936,7 +3914,7 @@ let writeBinaryAux (stream: Stream, options: options, modul, normalizeAssemblyRe
                   normalizeAssemblyRefs
               )
 
-          reportTime options.showTimes "Generated IL and metadata"
+          reportTime "Generated IL and metadata"
           let _codeChunk, next = chunk code.Length next
           let _codePaddingChunk, next = chunk codePadding.Length next
 
@@ -3969,7 +3947,7 @@ let writeBinaryAux (stream: Stream, options: options, modul, normalizeAssemblyRe
             match options.pdbfile, options.portablePDB with
             | Some _, true ->
                 let pdbInfo =
-                    generatePortablePdb options.embedAllSource options.embedSourceList options.sourceLink options.checksumAlgorithm options.showTimes pdbData options.pathMap
+                    generatePortablePdb options.embedAllSource options.embedSourceList options.sourceLink options.checksumAlgorithm pdbData options.pathMap
 
                 if options.embeddedPDB then
                     let (uncompressedLength, contentId, stream, algorithmName, checkSum) = pdbInfo
@@ -4095,7 +4073,7 @@ let writeBinaryAux (stream: Stream, options: options, modul, normalizeAssemblyRe
           let imageEndSectionPhysLoc = nextPhys
           let imageEndAddr = next
 
-          reportTime options.showTimes "Layout image"
+          reportTime "Layout image"
 
           let write p (os: BinaryWriter) chunkName chunk =
               match p with
@@ -4502,7 +4480,7 @@ let writeBinaryAux (stream: Stream, options: options, modul, normalizeAssemblyRe
 
           pdbData, pdbInfoOpt, debugDirectoryChunk, debugDataChunk, debugChecksumPdbChunk, debugEmbeddedPdbChunk, debugDeterministicPdbChunk, textV2P, mappings
 
-    reportTime options.showTimes "Writing Image"
+    reportTime "Writing Image"
     pdbData, pdbInfoOpt, debugDirectoryChunk, debugDataChunk, debugChecksumPdbChunk, debugEmbeddedPdbChunk, debugDeterministicPdbChunk, textV2P, mappings
 
 let writeBinaryFiles (options: options, modul, normalizeAssemblyRefs) =
@@ -4528,10 +4506,9 @@ let writeBinaryFiles (options: options, modul, normalizeAssemblyRefs) =
             reraise()
 
     let reopenOutput () =
-        FileSystem.OpenFileForWriteShim(options.outfile, FileMode.Open, FileAccess.Write, FileShare.Read)
+        FileSystem.OpenFileForWriteShim(options.outfile, FileMode.Open, FileAccess.ReadWrite, FileShare.Read)
 
-    writePdb (options.dumpDebugInfo,
-        options.showTimes,
+    writePdb (options.dumpDebugInfo,      
         options.embeddedPDB,
         options.pdbfile,
         options.outfile,
@@ -4558,11 +4535,12 @@ let writeBinaryInMemory (options: options, modul, normalizeAssemblyRefs) =
     let pdbData, pdbInfoOpt, debugDirectoryChunk, debugDataChunk, debugChecksumPdbChunk, debugEmbeddedPdbChunk, debugDeterministicPdbChunk, textV2P, _mappings =
         writeBinaryAux(stream, options, modul, normalizeAssemblyRefs)
 
-    let reopenOutput () = stream
+    let reopenOutput () =
+        stream.Seek(0, SeekOrigin.Begin) |> ignore
+        stream
 
     let pdbBytes =
-        writePdb (options.dumpDebugInfo,
-            options.showTimes,
+        writePdb (options.dumpDebugInfo,         
             options.embeddedPDB,
             options.pdbfile,
             options.outfile,
diff --git a/src/Compiler/AbstractIL/ilwrite.fsi b/src/Compiler/AbstractIL/ilwrite.fsi
index 780a6a95f09..a5240473fb1 100644
--- a/src/Compiler/AbstractIL/ilwrite.fsi
+++ b/src/Compiler/AbstractIL/ilwrite.fsi
@@ -22,7 +22,6 @@ type options =
       signer: ILStrongNameSigner option
       emitTailcalls: bool
       deterministic: bool
-      showTimes: bool
       dumpDebugInfo: bool
       referenceAssemblyOnly: bool
       referenceAssemblyAttribOpt: ILAttribute option
diff --git a/src/Compiler/AbstractIL/ilwritepdb.fs b/src/Compiler/AbstractIL/ilwritepdb.fs
index 715987a2ad1..9b969bae098 100644
--- a/src/Compiler/AbstractIL/ilwritepdb.fs
+++ b/src/Compiler/AbstractIL/ilwritepdb.fs
@@ -316,10 +316,10 @@ let pdbGetDebugInfo
 let getDebugFileName outfile =
     (FileSystemUtils.chopExtension outfile) + ".pdb"
 
-let sortMethods showTimes info =
-    reportTime showTimes (sprintf "PDB: Defined %d documents" info.Documents.Length)
+let sortMethods info =
+    reportTime (sprintf "PDB: Defined %d documents" info.Documents.Length)
     Array.sortInPlaceBy (fun x -> x.MethToken) info.Methods
-    reportTime showTimes (sprintf "PDB: Sorted %d methods" info.Methods.Length)
+    reportTime (sprintf "PDB: Sorted %d methods" info.Methods.Length)
     ()
 
 let getRowCounts tableRowCounts =
@@ -345,7 +345,6 @@ type PortablePdbGenerator
         embedSourceList: string list,
         sourceLink: string,
         checksumAlgorithm,
-        showTimes,
         info: PdbData,
         pathMap: PathMap
     ) =
@@ -784,7 +783,7 @@ type PortablePdbGenerator
         | Some scope -> writeMethodScopes minfo.MethToken scope
 
     member _.Emit() =
-        sortMethods showTimes info
+        sortMethods info
         metadata.SetCapacity(TableIndex.MethodDebugInformation, info.Methods.Length)
 
         defineModuleImportScope ()
@@ -823,7 +822,7 @@ type PortablePdbGenerator
         let contentId = serializer.Serialize blobBuilder
         let portablePdbStream = new MemoryStream()
         blobBuilder.WriteContentTo portablePdbStream
-        reportTime showTimes "PDB: Created"
+        reportTime "PDB: Created"
         (portablePdbStream.Length, contentId, portablePdbStream, algorithmName, contentHash)
 
 let generatePortablePdb
@@ -831,12 +830,11 @@ let generatePortablePdb
     (embedSourceList: string list)
     (sourceLink: string)
     checksumAlgorithm
-    showTimes
     (info: PdbData)
     (pathMap: PathMap)
     =
     let generator =
-        PortablePdbGenerator(embedAllSource, embedSourceList, sourceLink, checksumAlgorithm, showTimes, info, pathMap)
+        PortablePdbGenerator(embedAllSource, embedSourceList, sourceLink, checksumAlgorithm, info, pathMap)
 
     generator.Emit()
 
diff --git a/src/Compiler/AbstractIL/ilwritepdb.fsi b/src/Compiler/AbstractIL/ilwritepdb.fsi
index 79c1db52ac0..5987cc165e3 100644
--- a/src/Compiler/AbstractIL/ilwritepdb.fsi
+++ b/src/Compiler/AbstractIL/ilwritepdb.fsi
@@ -107,7 +107,6 @@ val generatePortablePdb:
     embedSourceList: string list ->
     sourceLink: string ->
     checksumAlgorithm: HashAlgorithm ->
-    showTimes: bool ->
     info: PdbData ->
     pathMap: PathMap ->
         int64 * BlobContentId * MemoryStream * string * byte[]
diff --git a/src/Compiler/AbstractIL/ilx.fs b/src/Compiler/AbstractIL/ilx.fs
index e91ad50d712..75447e06bcb 100644
--- a/src/Compiler/AbstractIL/ilx.fs
+++ b/src/Compiler/AbstractIL/ilx.fs
@@ -90,8 +90,6 @@ let rec instLambdasAux n inst lambdas =
         )
     | Lambdas_return retTy -> Lambdas_return(instILTypeAux n inst retTy)
 
-let instLambdas i t = instLambdasAux 0 i t
-
 type IlxClosureFreeVar =
     {
         fvName: string
diff --git a/src/Compiler/Checking/AttributeChecking.fs b/src/Compiler/Checking/AttributeChecking.fs
index de1aadfc803..087ebc1e0b1 100644
--- a/src/Compiler/Checking/AttributeChecking.fs
+++ b/src/Compiler/Checking/AttributeChecking.fs
@@ -522,7 +522,7 @@ let CheckRecdFieldInfoAttributes g (x:RecdFieldInfo) m =
     CheckRecdFieldAttributes g x.RecdFieldRef m
 
 // Identify any security attributes
-let IsSecurityAttribute (g: TcGlobals) amap (casmap : Dictionary<Stamp, bool>) (Attrib(tcref, _, _, _, _, _, _)) m =
+let IsSecurityAttribute (g: TcGlobals) amap (casmap : IDictionary<Stamp, bool>) (Attrib(tcref, _, _, _, _, _, _)) m =
     // There's no CAS on Silverlight, so we have to be careful here
     match g.attrib_SecurityAttribute with
     | None -> false
@@ -533,7 +533,7 @@ let IsSecurityAttribute (g: TcGlobals) amap (casmap : Dictionary<Stamp, bool>) (
             match casmap.TryGetValue tcs with
             | true, c -> c
             | _ ->
-                let exists = ExistsInEntireHierarchyOfType (fun t -> typeEquiv g t (mkAppTy attr.TyconRef [])) g amap m AllowMultiIntfInstantiations.Yes (mkAppTy tcref [])
+                let exists = ExistsInEntireHierarchyOfType (fun t -> typeEquiv g t (mkAppTy attr.TyconRef [])) g amap m AllowMultiIntfInstantiations.Yes (mkAppTy tcref [])          
                 casmap[tcs] <- exists
                 exists
         | ValueNone -> false  
diff --git a/src/Compiler/Checking/AttributeChecking.fsi b/src/Compiler/Checking/AttributeChecking.fsi
index 622864eff4e..b4a608ef1d1 100644
--- a/src/Compiler/Checking/AttributeChecking.fsi
+++ b/src/Compiler/Checking/AttributeChecking.fsi
@@ -96,7 +96,7 @@ val CheckValAttributes: g: TcGlobals -> x: ValRef -> m: range -> OperationResult
 val CheckRecdFieldInfoAttributes: g: TcGlobals -> x: RecdFieldInfo -> m: range -> OperationResult<unit>
 
 val IsSecurityAttribute:
-    g: TcGlobals -> amap: Import.ImportMap -> casmap: Dictionary<Stamp, bool> -> Attrib -> m: range -> bool
+    g: TcGlobals -> amap: Import.ImportMap -> casmap: IDictionary<Stamp, bool> -> Attrib -> m: range -> bool
 
 val IsSecurityCriticalAttribute: g: TcGlobals -> Attrib -> bool
 
diff --git a/src/Compiler/Checking/AugmentWithHashCompare.fs b/src/Compiler/Checking/AugmentWithHashCompare.fs
index dd81dc0a575..63ba529b220 100644
--- a/src/Compiler/Checking/AugmentWithHashCompare.fs
+++ b/src/Compiler/Checking/AugmentWithHashCompare.fs
@@ -144,10 +144,6 @@ let mkBindThatAddrIfNeeded m thataddrvOpt thatv expr =
         // let thataddrv = &thatv
         mkCompGenLet m thataddrv (mkValAddr m false (mkLocalValRef thatv))  expr
 
-let mkDerefThis g m (thisv: Val) thise =
-    if isByrefTy g thisv.Type then  mkAddrGet m (mkLocalValRef thisv)
-    else thise
-
 let mkCompareTestConjuncts g m exprs =
     match List.tryFrontAndBack exprs with 
     | None -> mkZero g m
@@ -996,7 +992,16 @@ let MakeBindingsForEqualityWithComparerAugmentation (g: TcGlobals) (tycon: Tycon
             // build the hash rhs
             let withcGetHashCodeExpr =
                 let compv, compe = mkCompGenLocal m "comp" g.IEqualityComparer_ty
-                let thisv, hashe = hashf g tcref tycon compe
+
+                // Special case List<T> type to avoid StackOverflow exception , call custom hash code instead
+                let thisv,hashe = 
+                    if tyconRefEq g tcref g.list_tcr_canon && tycon.HasMember g "CustomHashCode" [g.IEqualityComparer_ty] then
+                        let customCodeVal = (tycon.TryGetMember g "CustomHashCode" [g.IEqualityComparer_ty]).Value                  
+                        let tinst, ty = mkMinimalTy g tcref
+                        let thisv, thise = mkThisVar g m ty   
+                        thisv,mkApps g ((exprForValRef m customCodeVal, customCodeVal.Type), (if isNil tinst then [] else [tinst]), [thise; compe], m)
+                    else                     
+                        hashf g tcref tycon compe
                 mkLambdas g m tps [thisv; compv] (hashe, g.int_ty)
                 
             // build the equals rhs
diff --git a/src/Compiler/Checking/CheckComputationExpressions.fs b/src/Compiler/Checking/CheckComputationExpressions.fs
index db8d307381f..a1c89f61dc7 100644
--- a/src/Compiler/Checking/CheckComputationExpressions.fs
+++ b/src/Compiler/Checking/CheckComputationExpressions.fs
@@ -1672,6 +1672,9 @@ let TcComputationExpression (cenv: cenv) env (overallTy: OverallTy) tpenv (mWhol
                 let bindCall = mkSynCall bindName bindRange (bindArgs @ [consumeExpr])
                 translatedCtxt (bindCall |> addBindDebugPoint))
 
+    /// This function is for desugaring into .Bind{N}Return calls if possible
+    /// The outer option indicates if .BindReturn is possible. When it returns None, .BindReturn cannot be used
+    /// The inner option indicates if a custom operation is involved inside
     and convertSimpleReturnToExpr varSpace innerComp =
         match innerComp with 
         | SynExpr.YieldOrReturn ((false, _), returnExpr, m) ->
@@ -1697,7 +1700,8 @@ let TcComputationExpression (cenv: cenv) env (overallTy: OverallTy) tpenv (mWhol
             | Some (thenExpr, None) ->
             let elseExprOptOpt  = 
                 match elseCompOpt with 
-                | None -> Some None 
+                // When we are missing an 'else' part alltogether in case of 'if cond then return exp', we fallback from BindReturn into regular Bind+Return
+                | None -> None 
                 | Some elseComp -> 
                     match convertSimpleReturnToExpr varSpace elseComp with
                     | None -> None // failure
diff --git a/src/Compiler/Checking/CheckDeclarations.fs b/src/Compiler/Checking/CheckDeclarations.fs
index 7ea1c4b3429..d858368cd60 100644
--- a/src/Compiler/Checking/CheckDeclarations.fs
+++ b/src/Compiler/Checking/CheckDeclarations.fs
@@ -46,8 +46,6 @@ open FSharp.Compiler.TypeProviders
 
 type cenv = TcFileState
 
-let TcClassRewriteStackGuardDepth = StackGuard.GetDepthOption "TcClassRewrite"
-
 //-------------------------------------------------------------------------
 // Mutually recursive shapes
 //------------------------------------------------------------------------- 
@@ -563,26 +561,38 @@ module TcRecdUnionAndEnumDeclarations =
         let unionCasesR = unionCases |> List.map (TcUnionCaseDecl cenv env parent thisTy thisTyInst tpenv hasRQAAttribute) 
         unionCasesR |> CheckDuplicates (fun uc -> uc.Id) "union case" 
 
-    let TcEnumDecl cenv env parent thisTy fieldTy (SynEnumCase(attributes=Attributes synAttrs; ident= SynIdent(id,_); value=v; xmlDoc=xmldoc; range=m)) =
+    let MakeEnumCaseSpec cenv env parent attrs thisTy caseRange (caseIdent: Ident) (xmldoc: PreXmlDoc) value =
+        let vis, _ = ComputeAccessAndCompPath 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 attrs = TcAttributes cenv env AttributeTargets.Field synAttrs
-        
-        match v with 
-        | SynConst.Bytes _
-        | SynConst.UInt16s _
-        | SynConst.UserNum _ -> error(Error(FSComp.SR.tcInvalidEnumerationLiteral(), m))
-        | _ -> 
-            let v = TcConst cenv fieldTy m env v
-            let vis, _ = ComputeAccessAndCompPath env None m None None parent
-            let vis = CombineReprAccess parent vis
-            if id.idText = "value__" then errorR(Error(FSComp.SR.tcNotValidEnumCaseName(), id.idRange))
-            let checkXmlDocs = cenv.diagnosticOptions.CheckXmlDocs
-            let xmlDoc = xmldoc.ToXmlDoc(checkXmlDocs, Some [])
-            Construct.NewRecdField true (Some v) id false thisTy false false [] attrs xmlDoc vis false
-      
-    let TcEnumDecls (cenv: cenv) env parent thisTy enumCases =
+        let valueRange = valueExpr.Range
+
+        match valueExpr with
+        | SynExpr.Const (constant = SynConst.Bytes _ | SynConst.UInt16s _ | SynConst.UserNum _) ->
+            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
+        | _ when cenv.g.langVersion.SupportsFeature LanguageFeature.ArithmeticInLiterals ->
+            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
+            | _ -> error(Error(FSComp.SR.tcInvalidEnumerationLiteral(), valueRange))
+        | _ ->
+            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 parent thisTy fieldTy) |> CheckDuplicates (fun f -> f.Id) "enum element"
+        let enumCases' = enumCases |> List.map (TcEnumDecl cenv env tpenv parent thisTy fieldTy) |> CheckDuplicates (fun f -> f.Id) "enum element"
         fieldTy, enumCases'
 
 //-------------------------------------------------------------------------
@@ -1655,6 +1665,30 @@ module MutRecBindingChecking =
         
         defnsEs, envMutRec
 
+let private ReportErrorOnStaticClass (synMembers: SynMemberDefn list) =
+    for mem in synMembers do
+        match mem with
+        | SynMemberDefn.ImplicitCtor(ctorArgs = SynSimplePats.SimplePats(pats = pats)) when (not pats.IsEmpty) ->
+            for pat in pats do
+                warning(Error(FSComp.SR.chkConstructorWithArgumentsOnStaticClasses(), pat.Range))
+        | SynMemberDefn.Member(SynBinding(valData = SynValData(memberFlags = Some memberFlags)), m) when memberFlags.MemberKind = SynMemberKind.Constructor ->
+            warning(Error(FSComp.SR.chkAdditionalConstructorOnStaticClasses(), m))
+        | SynMemberDefn.Member(SynBinding(valData = SynValData(memberFlags = Some memberFlags)), m) when memberFlags.IsInstance ->
+            match memberFlags.MemberKind with
+            | SynMemberKind.PropertyGet | SynMemberKind.PropertySet | SynMemberKind.PropertyGetSet 
+            | SynMemberKind.Member ->
+                warning(Error(FSComp.SR.chkInstanceMemberOnStaticClasses(), m))
+            | _ -> ()
+        | SynMemberDefn.LetBindings(isStatic = false; range = range) ->
+            warning(Error(FSComp.SR.chkInstanceLetBindingOnStaticClasses(), range))
+        | SynMemberDefn.Interface(members= Some(synMemberDefs)) ->
+            for mem in synMemberDefs do
+                match mem with
+                | SynMemberDefn.Member(SynBinding(valData = SynValData(memberFlags = Some memberFlags)), m) when memberFlags.MemberKind = SynMemberKind.Member && memberFlags.IsInstance ->
+                    warning(Error(FSComp.SR.chkImplementingInterfacesOnStaticClasses(), m))
+                | _ -> ()
+        | _ -> ()
+
 /// Check and generalize the interface implementations, members, 'let' definitions in a mutually recursive group of definitions.
 let TcMutRecDefns_Phase2 (cenv: cenv) envInitial mBinds scopem mutRecNSInfo (envMutRec: TcEnv) (mutRecDefns: MutRecDefnsPhase2Data) isMutRec =     
     let g = cenv.g
@@ -1755,7 +1789,22 @@ let TcMutRecDefns_Phase2 (cenv: cenv) envInitial mBinds scopem mutRecNSInfo (env
 
       let binds: MutRecDefnsPhase2Info = 
           (envMutRec, mutRecDefns) ||> MutRecShapes.mapTyconsWithEnv (fun envForDecls tyconData -> 
-              let (MutRecDefnsPhase2DataForTycon(tyconOpt, _, declKind, tcref, _, _, declaredTyconTypars, _, _, _, fixupFinalAttrs)) = tyconData
+              let (MutRecDefnsPhase2DataForTycon(tyconOpt, _x, declKind, tcref, _, _, declaredTyconTypars, synMembers, _, _, fixupFinalAttrs)) = tyconData
+              
+              // If a tye uses both [<Sealed>] and [<AbstractClass>] attributes it means it is a static class.
+              let isStaticClass = HasFSharpAttribute cenv.g cenv.g.attrib_SealedAttribute tcref.Attribs && HasFSharpAttribute cenv.g cenv.g.attrib_AbstractClassAttribute tcref.Attribs
+              if isStaticClass && cenv.g.langVersion.SupportsFeature(LanguageFeature.ErrorReportingOnStaticClasses) then
+                  ReportErrorOnStaticClass synMembers
+                  match tyconOpt with
+                  | Some tycon ->
+                        for slot in tycon.FSharpObjectModelTypeInfo.fsobjmodel_vslots do
+                            warning(Error(FSComp.SR.chkAbstractMembersDeclarationsOnStaticClasses(), slot.Range))
+                            
+                        for fld in tycon.AllFieldsArray do
+                            if not fld.IsStatic then
+                                warning(Error(FSComp.SR.chkExplicitFieldsDeclarationsOnStaticClasses(), fld.Range))
+                  | None -> ()
+              
               let envForDecls = 
                 // This allows to implement protected interface methods if it's a DIM.
                 // Does not need to be hidden behind a lang version as it needs to be possible to
@@ -3449,7 +3498,7 @@ module EstablishTypeDefinitionCores =
                         repr, baseValOpt, safeInitInfo
 
                 | SynTypeDefnSimpleRepr.Enum (decls, m) -> 
-                    let fieldTy, fields' = TcRecdUnionAndEnumDeclarations.TcEnumDecls cenv envinner innerParent thisTy decls
+                    let fieldTy, fields' = TcRecdUnionAndEnumDeclarations.TcEnumDecls cenv envinner tpenv innerParent thisTy decls
                     let kind = TFSharpEnum
                     structLayoutAttributeCheck false
                     noCLIMutableAttributeCheck()
@@ -3458,7 +3507,7 @@ module EstablishTypeDefinitionCores =
                     let vid = ident("value__", m)
                     let vfld = Construct.NewRecdField false None vid false fieldTy false false [] [] XmlDoc.Empty taccessPublic true
                     
-                    let legitEnumTypes = [ g.int32_ty; g.int16_ty; g.sbyte_ty; g.int64_ty; g.char_ty; g.bool_ty; g.uint32_ty; g.uint16_ty; g.byte_ty; g.uint64_ty ]
+                    let legitEnumTypes = [ g.int32_ty; g.int16_ty; g.sbyte_ty; g.int64_ty; g.char_ty; g.uint32_ty; g.uint16_ty; g.byte_ty; g.uint64_ty ]
                     if not (ListSet.contains (typeEquiv g) fieldTy legitEnumTypes) then 
                         errorR(Error(FSComp.SR.tcInvalidTypeForLiteralEnumeration(), m))
 
@@ -4030,6 +4079,7 @@ module TcDeclarations =
     let rec private SplitTyconDefn (SynTypeDefn(typeInfo=synTyconInfo;typeRepr=trepr; members=extraMembers)) =
         let extraMembers = desugarGetSetMembers extraMembers
         let implements1 = List.choose (function SynMemberDefn.Interface (interfaceType=ty) -> Some(ty, ty.Range) | _ -> None) extraMembers
+       
         match trepr with
         | SynTypeDefnRepr.ObjectModel(kind, cspec, m) ->
             let cspec = desugarGetSetMembers cspec
@@ -4047,7 +4097,7 @@ module TcDeclarations =
             let members = 
                 let membersIncludingAutoProps = 
                     cspec |> List.filter (fun memb -> 
-                      match memb with 
+                      match memb with
                       | SynMemberDefn.Interface _
                       | SynMemberDefn.Member _
                       | SynMemberDefn.GetSetMember _
@@ -4837,7 +4887,7 @@ let rec TcModuleOrNamespaceElementNonMutRec (cenv: cenv) parent typeNames scopem
               let moduleEntity = Construct.NewModuleOrNamespace (Some env.eCompPath) vis id xmlDoc modAttrs (MaybeLazy.Strict moduleTy)
 
               // Now typecheck. 
-              let! moduleContents, topAttrsNew, envAtEnd = TcModuleOrNamespaceElements cenv (Parent (mkLocalModuleRef moduleEntity)) endm envForModule xml None [] moduleDefs 
+              let! moduleContents, topAttrsNew, envAtEnd = TcModuleOrNamespaceElements cenv (Parent (mkLocalModuleRef moduleEntity)) endm envForModule xml None [] moduleDefs
 
               // Get the inferred type of the decls and record it in the modul. 
               moduleEntity.entity_modul_type <- MaybeLazy.Strict moduleTyAcc.Value
@@ -4924,8 +4974,7 @@ let rec TcModuleOrNamespaceElementNonMutRec (cenv: cenv) parent typeNames scopem
 
           let! moduleContents, topAttrs, envAtEnd = TcModuleOrNamespaceElements cenv parent endm envNS xml mutRecNSInfo [] defs
 
-          MutRecBindingChecking.TcMutRecDefns_UpdateNSContents nsInfo
-          
+          MutRecBindingChecking.TcMutRecDefns_UpdateNSContents nsInfo 
           let env, openDecls = 
               if isNil enclosingNamespacePath then 
                   envAtEnd, []
@@ -5316,8 +5365,8 @@ let CheckOneImplFile
         use _ =
             Activity.start "CheckDeclarations.CheckOneImplFile"
                 [|
-                    "fileName", fileName
-                    "qualifiedNameOfFile", qualNameOfFile.Text
+                    Activity.Tags.fileName, fileName
+                    Activity.Tags.qualifiedNameOfFile, qualNameOfFile.Text
                 |]
         let cenv =
             cenv.Create (g, isScript, amap, thisCcu, false, Option.isSome rootSigOpt,
@@ -5450,8 +5499,8 @@ let CheckOneSigFile (g, amap, thisCcu, checkForErrors, conditionalDefines, tcSin
     use _ =
         Activity.start "CheckDeclarations.CheckOneSigFile"
             [|
-                "fileName", sigFile.FileName
-                "qualifiedNameOfFile", sigFile.QualifiedName.Text
+                Activity.Tags.fileName, sigFile.FileName
+                Activity.Tags.qualifiedNameOfFile, sigFile.QualifiedName.Text
             |]
     let cenv =
         cenv.Create 
diff --git a/src/Compiler/Checking/CheckExpressions.fs b/src/Compiler/Checking/CheckExpressions.fs
index 53381d07648..4c1c47f53b0 100644
--- a/src/Compiler/Checking/CheckExpressions.fs
+++ b/src/Compiler/Checking/CheckExpressions.fs
@@ -46,14 +46,6 @@ open FSharp.Compiler.TypeRelations
 open FSharp.Compiler.TypeProviders
 #endif
 
-//-------------------------------------------------------------------------
-// Helpers that should be elsewhere
-//-------------------------------------------------------------------------
-
-let mkNilListPat (g: TcGlobals) m ty = TPat_unioncase(g.nil_ucref, [ty], [], m)
-
-let mkConsListPat (g: TcGlobals) ty ph pt = TPat_unioncase(g.cons_ucref, [ty], [ph;pt], unionRanges ph.Range pt.Range)
-
 //-------------------------------------------------------------------------
 // Errors.
 //-------------------------------------------------------------------------
@@ -174,8 +166,6 @@ let ExitFamilyRegion env =
 
 let AreWithinCtorShape env = match env.eCtorInfo with None -> false | Some ctorInfo -> ctorInfo.ctorShapeCounter > 0
 
-let AreWithinImplicitCtor env = match env.eCtorInfo with None -> false | Some ctorInfo -> ctorInfo.ctorIsImplicit
-
 let GetCtorShapeCounter env = match env.eCtorInfo with None -> 0 | Some ctorInfo -> ctorInfo.ctorShapeCounter
 
 let GetRecdInfo env = match env.eCtorInfo with None -> RecdExpr | Some ctorInfo -> if ctorInfo.ctorShapeCounter = 1 then RecdExprIsObjInit else RecdExpr
@@ -471,14 +461,6 @@ let UnifyOverallTypeAndRecover (cenv: cenv) env m overallTy actualTy =
     with exn ->
         errorRecovery exn m
 
-// Calls UnifyTypes, but upon error only does the minimal error recovery
-// so that IntelliSense information can continue to be collected.
-let UnifyTypesAndRecover (cenv: cenv) env m expectedTy actualTy =
-    try
-        UnifyTypes cenv env m expectedTy actualTy
-    with exn ->
-        errorRecovery exn m
-
 /// Make an environment suitable for a module or namespace. Does not create a new accumulator but uses one we already have/
 let MakeInnerEnvWithAcc addOpenToNameEnv env nm moduleTyAcc moduleKind =
     let path = env.ePath @ [nm]
@@ -1015,15 +997,16 @@ let MakeMemberDataAndMangledNameForMemberVal(g, tcref, isExtrinsic, attrs, implS
 
     if not isCompGen && IsLogicalInfixOpName id.idText then
         let m = id.idRange
-        let name = ConvertValLogicalNameToDisplayNameCore id.idText
+        let logicalName = id.idText
+        let displayName = ConvertValLogicalNameToDisplayNameCore logicalName
         // Check symbolic members. Expect valSynData implied arity to be [[2]].
         match SynInfo.AritiesOfArgs valSynData with
-        | [] | [0] -> warning(Error(FSComp.SR.memberOperatorDefinitionWithNoArguments name, m))
+        | [] | [0] -> warning(Error(FSComp.SR.memberOperatorDefinitionWithNoArguments displayName, m))
         | n :: otherArgs ->
-            let opTakesThreeArgs = IsLogicalTernaryOperator name
-            if n<>2 && not opTakesThreeArgs then warning(Error(FSComp.SR.memberOperatorDefinitionWithNonPairArgument(name, n), m))
-            if n<>3 && opTakesThreeArgs then warning(Error(FSComp.SR.memberOperatorDefinitionWithNonTripleArgument(name, n), m))
-            if not (isNil otherArgs) then warning(Error(FSComp.SR.memberOperatorDefinitionWithCurriedArguments name, m))
+            let opTakesThreeArgs = IsLogicalTernaryOperator logicalName
+            if n<>2 && not opTakesThreeArgs then warning(Error(FSComp.SR.memberOperatorDefinitionWithNonPairArgument(displayName, n), m))
+            if n<>3 && opTakesThreeArgs then warning(Error(FSComp.SR.memberOperatorDefinitionWithNonTripleArgument(displayName, n), m))
+            if not (isNil otherArgs) then warning(Error(FSComp.SR.memberOperatorDefinitionWithCurriedArguments displayName, m))
 
     if isExtrinsic && IsLogicalOpName id.idText then
         warning(Error(FSComp.SR.tcMemberOperatorDefinitionInExtrinsic(), id.idRange))
@@ -1209,6 +1192,12 @@ let CheckRequiredProperties (g:TcGlobals) (env: TcEnv) (cenv: TcFileState) (minf
                 let details = NicePrint.multiLineStringOfPropInfos g cenv.amap mMethExpr env.DisplayEnv missingProps
                 errorR(Error(FSComp.SR.tcMissingRequiredMembers details, mMethExpr))
 
+let private HasMethodImplNoInliningAttribute g attrs = 
+            match TryFindFSharpAttribute g g.attrib_MethodImplAttribute attrs with
+            // NO_INLINING = 8
+            | Some (Attrib(_, _, [ AttribInt32Arg flags ], _, _, _, _)) -> (flags &&& 0x8) <> 0x0
+            | _ -> false
+
 let MakeAndPublishVal (cenv: cenv) env (altActualParent, inSig, declKind, valRecInfo, vscheme, attrs, xmlDoc, konst, isGeneratedEventVal) =
 
     let g = cenv.g
@@ -1257,16 +1246,10 @@ let MakeAndPublishVal (cenv: cenv) env (altActualParent, inSig, declKind, valRec
               errorR(Error(FSComp.SR.tcDllImportStubsCannotBeInlined(), m)) 
             ValInline.Never 
         else 
-            let implflags = 
-                match TryFindFSharpAttribute g g.attrib_MethodImplAttribute attrs with
-                | Some (Attrib(_, _, [ AttribInt32Arg flags ], _, _, _, _)) -> flags
-                | _ -> 0x0
-            // MethodImplOptions.NoInlining = 0x8
-            let NO_INLINING = 0x8
-            if (implflags &&& NO_INLINING) <> 0x0 then
-                ValInline.Never
-            else
-                inlineFlag
+            if HasMethodImplNoInliningAttribute g attrs 
+            then ValInline.Never 
+            else inlineFlag             
+        
 
     // CompiledName not allowed on virtual/abstract/override members
     let compiledNameAttrib = TryFindFSharpStringAttribute g g.attrib_CompiledNameAttribute attrs
@@ -1889,10 +1872,6 @@ let ApplyUnionCaseOrExnTypes m (cenv: cenv) env overallTy c =
   ApplyUnionCaseOrExn ((fun (a, b) mArgs args -> mkUnionCaseExpr(a, b, args, unionRanges m mArgs)),
                        (fun a mArgs args -> mkExnExpr (a, args, unionRanges m mArgs))) m cenv env overallTy c
 
-let ApplyUnionCaseOrExnTypesForPat m (cenv: cenv) env overallTy c =
-  ApplyUnionCaseOrExn ((fun (a, b) mArgs args -> TPat_unioncase(a, b, args, unionRanges m mArgs)),
-                       (fun a mArgs args -> TPat_exnconstr(a, args, unionRanges m mArgs))) m cenv env overallTy c
-
 let UnionCaseOrExnCheck (env: TcEnv) numArgTys numArgs m =
   if numArgs <> numArgTys then error (UnionCaseWrongArguments(env.DisplayEnv, numArgTys, numArgs, m))
 
@@ -2204,26 +2183,32 @@ module GeneralizationHelpers =
 // ComputeInlineFlag
 //-------------------------------------------------------------------------
 
-let ComputeInlineFlag (memFlagsOption: SynMemberFlags option) isInline isMutable hasNoCompilerInliningAttribute m =
-    let inlineFlag =
-        let isCtorOrAbstractSlot =
-            match memFlagsOption with
-            | None -> false
-            | Some x -> (x.MemberKind = SynMemberKind.Constructor) || x.IsDispatchSlot || x.IsOverrideOrExplicitImpl
+let ComputeInlineFlag (memFlagsOption: SynMemberFlags option) isInline isMutable g attrs m =
+    let hasNoCompilerInliningAttribute() = HasFSharpAttribute g g.attrib_NoCompilerInliningAttribute attrs  
+    let isCtorOrAbstractSlot() =
+        match memFlagsOption with
+        | None -> false
+        | Some x -> (x.MemberKind = SynMemberKind.Constructor) || x.IsDispatchSlot || x.IsOverrideOrExplicitImpl
 
+    let inlineFlag, reportIncorrectInlineKeywordUsage =
         // Mutable values may never be inlined
         // Constructors may never be inlined
         // Calls to virtual/abstract slots may never be inlined
-        // Values marked with NoCompilerInliningAttribute may never be inlined
-        if isMutable || isCtorOrAbstractSlot || hasNoCompilerInliningAttribute then
-            ValInline.Never 
+        // Values marked with NoCompilerInliningAttribute or [<MethodImpl(MethodImplOptions.NoInlining)>] may never be inlined
+        if isMutable || isCtorOrAbstractSlot() || hasNoCompilerInliningAttribute() then
+            ValInline.Never, errorR
+        elif HasMethodImplNoInliningAttribute g attrs then
+            ValInline.Never, 
+                if g.langVersion.SupportsFeature LanguageFeature.WarningWhenInliningMethodImplNoInlineMarkedFunction
+                then warning
+                else ignore
         elif isInline then
-            ValInline.Always 
+            ValInline.Always, ignore
         else
-            ValInline.Optional
+            ValInline.Optional, ignore
 
     if isInline && (inlineFlag <> ValInline.Always) then 
-        errorR(Error(FSComp.SR.tcThisValueMayNotBeInlined(), m))
+        reportIncorrectInlineKeywordUsage (Error(FSComp.SR.tcThisValueMayNotBeInlined(), m))
 
     inlineFlag
 
@@ -4378,7 +4363,7 @@ and CheckIWSAM (cenv: cenv) (env: TcEnv) checkConstraints iwsam m tcref =
     if iwsam = WarnOnIWSAM.Yes && isInterfaceTy g ty && checkConstraints = CheckCxs then
         let tcref = tcrefOfAppTy g ty
         let meths = AllMethInfosOfTypeInScope ResultCollectionSettings.AllResults cenv.infoReader env.NameEnv None ad IgnoreOverrides m ty
-        if meths |> List.exists (fun meth -> not meth.IsInstance && meth.IsDispatchSlot) then
+        if meths |> List.exists (fun meth -> not meth.IsInstance && meth.IsDispatchSlot && not meth.IsExtensionMember) then
             warning(Error(FSComp.SR.tcUsingInterfaceWithStaticAbstractMethodAsType(tcref.DisplayNameWithStaticParametersAndUnderscoreTypars), m))
 
 and TcLongIdentType kindOpt (cenv: cenv) newOk checkConstraints occ iwsam env tpenv synLongId =
@@ -4550,16 +4535,6 @@ and TcTypeMeasurePower kindOpt (cenv: cenv) newOk checkConstraints occ env tpenv
         let ms, tpenv = TcMeasure cenv newOk checkConstraints occ env tpenv ty m
         TType_measure (Measure.RationalPower (ms, TcSynRationalConst exponent)), tpenv
 
-and TcTypeMeasureDivide kindOpt (cenv: cenv) newOk checkConstraints occ env tpenv typ1 typ2 m =
-    match kindOpt with
-    | Some TyparKind.Type ->
-        errorR(Error(FSComp.SR.tcUnexpectedSymbolInTypeExpression("/"), m))
-        NewErrorType (), tpenv
-    | _ ->
-        let ms1, tpenv = TcMeasure cenv newOk checkConstraints occ env tpenv typ1 m
-        let ms2, tpenv = TcMeasure cenv newOk checkConstraints occ env tpenv typ2 m
-        TType_measure (Measure.Prod(ms1, Measure.Inv ms2)), tpenv
-
 and TcTypeMeasureApp kindOpt (cenv: cenv) newOk checkConstraints occ env tpenv arg1 args postfix m =
     match arg1 with
     | StripParenTypes (SynType.Var(_, m1) | SynType.MeasurePower(_, _, m1)) ->
@@ -7165,13 +7140,14 @@ and TcInterpolatedStringExpr cenv (overallTy: OverallTy) env m tpenv (parts: Syn
         // Type check the expressions filling the holes
 
         if List.isEmpty synFillExprs then
-            let str = mkString g m printfFormatString
-
             if isString then
+                let sb = System.Text.StringBuilder(printfFormatString).Replace("%%", "%")
+                let str = mkString g m (sb.ToString())
                 TcPropagatingExprLeafThenConvert cenv overallTy g.string_ty env (* true *) m (fun () ->
                     str, tpenv
                 )
             else
+                let str = mkString g m printfFormatString
                 mkCallNewFormat g m printerTy printerArgTy printerResidueTy printerResultTy printerTupleTy str, tpenv
         else
             // Type check the expressions filling the holes
@@ -10286,10 +10262,8 @@ and TcNormalizedBinding declKind (cenv: cenv) env tpenv overallTy safeThisValOpt
                 SynValData(valMf, SynValInfo(args, SynArgInfo({Attributes=rotRetSynAttrs; Range=mHead} :: attrs, opt, retId)), valId)
             retAttribs, valAttribs, valSynData
 
-        let isVolatile = HasFSharpAttribute g g.attrib_VolatileFieldAttribute valAttribs
-        let hasNoCompilerInliningAttribute = HasFSharpAttribute g g.attrib_NoCompilerInliningAttribute valAttribs
-
-        let inlineFlag = ComputeInlineFlag memberFlagsOpt isInline isMutable hasNoCompilerInliningAttribute mBinding
+        let isVolatile = HasFSharpAttribute g g.attrib_VolatileFieldAttribute valAttribs     
+        let inlineFlag = ComputeInlineFlag memberFlagsOpt isInline isMutable g valAttribs mBinding
 
         let argAttribs = 
             spatsL |> List.map (SynInfo.InferSynArgInfoFromSimplePats >> List.map (SynInfo.AttribsOfArgData >> TcAttrs AttributeTargets.Parameter false))
@@ -10724,9 +10698,6 @@ and TcAttributesMaybeFailEx canFail (cenv: cenv) env attrTgt attrEx synAttribs =
 and TcAttributesWithPossibleTargets canFail cenv env attrTgt synAttribs =
     TcAttributesWithPossibleTargetsEx canFail cenv env attrTgt (enum 0) synAttribs
 
-and TcAttribute canFail cenv (env: TcEnv) attrTgt (synAttr: SynAttribute) =
-    TcAttributeEx canFail cenv env attrTgt (enum 0) synAttr
-
 and TcAttributesMaybeFail canFail cenv env attrTgt synAttribs =
     TcAttributesMaybeFailEx canFail cenv env attrTgt (enum 0) synAttribs
 
@@ -10951,7 +10922,7 @@ and ComputeIsComplete enclosingDeclaredTypars declaredTypars ty =
 /// Determine if a uniquely-identified-abstract-slot exists for an override member (or interface member implementation) based on the information available
 /// at the syntactic definition of the member (i.e. prior to type inference). If so, we know the expected signature of the override, and the full slotsig
 /// it implements. Apply the inferred slotsig.
-and ApplyAbstractSlotInference (cenv: cenv) (envinner: TcEnv) (baseValOpt: Val option) (argsAndRetTy, m, synTyparDecls, declaredTypars, memberId, tcrefObjTy, renaming, intfSlotTyOpt, valSynData, memberFlags: SynMemberFlags, attribs) =
+and ApplyAbstractSlotInference (cenv: cenv) (envinner: TcEnv) (_: Val option) (argsAndRetTy, m, synTyparDecls, declaredTypars, memberId, tcrefObjTy, renaming, intfSlotTyOpt, valSynData, memberFlags: SynMemberFlags, attribs) =
 
     let g = cenv.g
     let ad = envinner.eAccessRights
@@ -10980,7 +10951,10 @@ and ApplyAbstractSlotInference (cenv: cenv) (envinner: TcEnv) (baseValOpt: Val o
         match memberFlags.MemberKind with
         | SynMemberKind.Member ->
              let dispatchSlots, dispatchSlotsArityMatch =
-                 GetAbstractMethInfosForSynMethodDecl(cenv.infoReader, ad, memberId, m, typToSearchForAbstractMembers, valSynData, memberFlags)
+                if g.langVersion.SupportsFeature(LanguageFeature.ErrorForNonVirtualMembersOverrides) then
+                    GetAbstractMethInfosForSynMethodDecl(cenv.infoReader, ad, memberId, m, typToSearchForAbstractMembers, valSynData, memberFlags, DiscardOnFirstNonOverride)
+                else
+                    GetAbstractMethInfosForSynMethodDecl(cenv.infoReader, ad, memberId, m, typToSearchForAbstractMembers, valSynData, memberFlags,IgnoreOverrides)
 
              let uniqueAbstractMethSigs =
                  match dispatchSlots with
@@ -10998,22 +10972,6 @@ and ApplyAbstractSlotInference (cenv: cenv) (envinner: TcEnv) (baseValOpt: Val o
                      | _ -> [] // check that method to override is sealed is located at CheckOverridesAreAllUsedOnce (typrelns.fs)
                       // We hit this case when it is ambiguous which abstract method is being implemented.
 
-             if g.langVersion.SupportsFeature(LanguageFeature.ErrorForNonVirtualMembersOverrides) then
-                 // Checks if the declaring type inherits from a base class and is not FSharpObjModelTy
-                 // Raises an error if we try to override an non virtual member with the same name in both
-                 match baseValOpt with
-                 | Some ttype when not(isFSharpObjModelTy g ttype.Type) ->
-                    match stripTyEqns g ttype.Type with
-                    | TType_app(tyconRef, _, _) ->
-                        let ilMethods = tyconRef.ILTyconRawMetadata.Methods.AsList()
-                        let nameOpt = ilMethods |> List.tryFind(fun id -> id.Name = memberId.idText)
-                        match nameOpt with
-                        | Some name when not name.IsVirtual ->
-                            errorR(Error(FSComp.SR.tcNoMemberFoundForOverride(), memberId.idRange))
-                        | _ -> ()
-                    | _ -> ()
-                 | _ -> ()
-
              // If we determined a unique member then utilize the type information from the slotsig
              let declaredTypars =
                  match uniqueAbstractMethSigs with
@@ -11422,10 +11380,9 @@ and AnalyzeAndMakeAndPublishRecursiveValue
     let bindingAttribs = TcAttributes cenv env attrTgt bindingSynAttribs
 
     // Allocate the type inference variable for the inferred type
-    let ty = NewInferenceType g
-    let hasNoCompilerInliningAttribute = HasFSharpAttribute g g.attrib_NoCompilerInliningAttribute bindingAttribs
+    let ty = NewInferenceType g  
 
-    let inlineFlag = ComputeInlineFlag memberFlagsOpt isInline isMutable hasNoCompilerInliningAttribute mBinding
+    let inlineFlag = ComputeInlineFlag memberFlagsOpt isInline isMutable g bindingAttribs mBinding
 
     if isMutable then errorR(Error(FSComp.SR.tcOnlyRecordFieldsAndSimpleLetCanBeMutable(), mBinding))
 
@@ -12041,7 +11998,6 @@ let TcAndPublishValSpec (cenv: cenv, env, containerInfo: ContainerInfo, declKind
 
     let attrs = TcAttributes cenv env attrTgt synAttrs
     let newOk = if canInferTypars then NewTyparsOK else NoNewTypars
-    let hasNoCompilerInliningAttribute = HasFSharpAttribute g g.attrib_NoCompilerInliningAttribute attrs
 
     let valinfos, tpenv = TcValSpec cenv env declKind newOk containerInfo memFlagsOpt None tpenv synValSig attrs
     let denv = env.DisplayEnv
@@ -12050,7 +12006,7 @@ let TcAndPublishValSpec (cenv: cenv, env, containerInfo: ContainerInfo, declKind
 
         let (ValSpecResult (altActualParent, memberInfoOpt, id, enclosingDeclaredTypars, declaredTypars, ty, prelimValReprInfo, declKind)) = valSpecResult
 
-        let inlineFlag = ComputeInlineFlag (memberInfoOpt |> Option.map (fun (PrelimMemberInfo(memberInfo, _, _)) -> memberInfo.MemberFlags)) isInline mutableFlag hasNoCompilerInliningAttribute m
+        let inlineFlag = ComputeInlineFlag (memberInfoOpt |> Option.map (fun (PrelimMemberInfo(memberInfo, _, _)) -> memberInfo.MemberFlags)) isInline mutableFlag g attrs m
 
         let freeInType = freeInTypeLeftToRight g false ty
 
diff --git a/src/Compiler/Checking/CheckFormatStrings.fs b/src/Compiler/Checking/CheckFormatStrings.fs
index 8652e305761..8d287145dcb 100644
--- a/src/Compiler/Checking/CheckFormatStrings.fs
+++ b/src/Compiler/Checking/CheckFormatStrings.fs
@@ -48,6 +48,13 @@ let newInfo () =
     addZeros       = false
     precision      = false}
 
+let escapeDotnetFormatString str =
+    str
+    // We need to double '{' and '}', because even if they were escaped in the
+    // original string, extra curly braces were stripped away by the F# lexer.
+    |> Seq.collect (fun x -> if x = '{' || x = '}' then [x;x] else [x])
+    |> System.String.Concat
+
 let parseFormatStringInternal
         (m: range)
         (fragRanges: range list)
@@ -55,7 +62,7 @@ let parseFormatStringInternal
         isInterpolated
         isFormattableString
         (context: FormatStringCheckContext option)
-        fmt
+        (fmt: string)
         printerArgTy
         printerResidueTy = 
 
@@ -86,6 +93,8 @@ let parseFormatStringInternal
     // there are no accurate intra-string ranges available for exact error message locations within the string.
     // The 'm' range passed as an input is however accurate and covers the whole string.
     //
+    let escapeFormatStringEnabled = g.langVersion.SupportsFeature Features.LanguageFeature.EscapeDotnetFormattableStrings
+
     let fmt, fragments = 
 
         //printfn "--------------------" 
@@ -175,7 +184,7 @@ let parseFormatStringInternal
         | _ -> 
             // Don't muck with the fmt when there is no source code context to go get the original
             // source code (i.e. when compiling or background checking)
-            fmt, [ (0, 1, m) ]
+            (if escapeFormatStringEnabled then escapeDotnetFormatString fmt else fmt), [ (0, 1, m) ]
 
     let len = fmt.Length
 
diff --git a/src/Compiler/Checking/InfoReader.fs b/src/Compiler/Checking/InfoReader.fs
index 27eb5c2547e..5a6b63722cc 100644
--- a/src/Compiler/Checking/InfoReader.fs
+++ b/src/Compiler/Checking/InfoReader.fs
@@ -311,6 +311,9 @@ type FindMemberFlag =
     | IgnoreOverrides 
     /// Get overrides instead of abstract slots when measuring whether a class/interface implements all its required slots. 
     | PreferOverrides
+    /// Similar to "IgnoreOverrides", but filters the items bottom-to-top,
+    /// and discards all when finds first non-virtual member which hides one above it in hirearchy.
+    | DiscardOnFirstNonOverride
 
 /// The input list is sorted from most-derived to least-derived type, so any System.Object methods 
 /// are at the end of the list. Return a filtered list where prior/subsequent members matching by name and 
@@ -561,9 +564,17 @@ type InfoReader(g: TcGlobals, amap: Import.ImportMap) as this =
     /// Filter the overrides of methods or properties, either keeping the overrides or keeping the dispatch slots.
     static let FilterOverrides findFlag (isVirt:'a->bool, isNewSlot, isDefiniteOverride, isFinal, equivSigs, nmf:'a->string) items = 
         let equivVirts x y = isVirt x && isVirt y && equivSigs x y
+        let filterDefiniteOverrides = List.filter(isDefiniteOverride >> not)
 
-        match findFlag with 
-        | PreferOverrides -> 
+        match findFlag with
+        | DiscardOnFirstNonOverride ->
+            items
+            |> List.map filterDefiniteOverrides
+            |> ExcludeItemsInSuperTypesBasedOnEquivTestWithItemsInSubTypes nmf (fun newItem priorItem ->
+                equivSigs newItem priorItem &&
+                isVirt newItem && not (isVirt priorItem)
+            ) 
+        | PreferOverrides ->
             items
             // For each F#-declared override, get rid of any equivalent abstract member in the same type
             // This is because F# abstract members with default overrides give rise to two members with the
@@ -583,7 +594,7 @@ type InfoReader(g: TcGlobals, amap: Import.ImportMap) as this =
             items
               // Remove any F#-declared overrides. These may occur in the same type as the abstract member (unlike with .NET metadata)
               // Include any 'newslot' declared methods.
-              |> List.map (List.filter (fun x -> not (isDefiniteOverride x))) 
+              |> List.map filterDefiniteOverrides
 
               // Remove any virtuals that are signature-equivalent to virtuals in subtypes, except for newslots
               // That is, keep if it's 
diff --git a/src/Compiler/Checking/InfoReader.fsi b/src/Compiler/Checking/InfoReader.fsi
index da24ec26d9e..2d6489e70c9 100644
--- a/src/Compiler/Checking/InfoReader.fsi
+++ b/src/Compiler/Checking/InfoReader.fsi
@@ -89,6 +89,10 @@ type FindMemberFlag =
     /// Get overrides instead of abstract slots when measuring whether a class/interface implements all its required slots.
     | PreferOverrides
 
+    /// Similar to "IgnoreOverrides", but filters the items bottom-to-top,
+    /// and discards all when finds first non-virtual member which hides one above it in hirearchy.
+    | DiscardOnFirstNonOverride
+
 /// An InfoReader is an object to help us read and cache infos.
 /// We create one of these for each file we typecheck.
 type InfoReader =
diff --git a/src/Compiler/Checking/MethodCalls.fs b/src/Compiler/Checking/MethodCalls.fs
index c7523e7ba50..870443d32b9 100644
--- a/src/Compiler/Checking/MethodCalls.fs
+++ b/src/Compiler/Checking/MethodCalls.fs
@@ -1806,9 +1806,9 @@ module ProvidedMethodCalls =
              expr: Tainted<ProvidedExpr>) = 
 
         let varConv =
-            // note: using paramVars.Length as assumed initial size, but this might not 
-            // be the optimal value; this wasn't checked before obsoleting Dictionary.ofList
-            let dict = Dictionary.newWithSize paramVars.Length
+            // note: Assuming the size based on paramVars
+            // Doubling to decrease chance of collisions
+            let dict = Dictionary.newWithSize (paramVars.Length*2)
             for v, e in Seq.zip (paramVars |> Seq.map (fun x -> x.PUntaint(id, m))) (Option.toList thisArg @ allArgs) do
                 dict.Add(v, (None, e))
             dict
diff --git a/src/Compiler/Checking/MethodOverrides.fs b/src/Compiler/Checking/MethodOverrides.fs
index e317772dac4..58aa619bf04 100644
--- a/src/Compiler/Checking/MethodOverrides.fs
+++ b/src/Compiler/Checking/MethodOverrides.fs
@@ -927,7 +927,7 @@ let FinalTypeDefinitionChecksAtEndOfInferenceScope (infoReader: InfoReader, nenv
 
 /// Get the methods relevant to determining if a uniquely-identified-override exists based on the syntactic information 
 /// at the member signature prior to type inference. This is used to pre-assign type information if it does 
-let GetAbstractMethInfosForSynMethodDecl(infoReader: InfoReader, ad, memberName: Ident, bindm, typToSearchForAbstractMembers, valSynData, memberFlags: SynMemberFlags) =
+let GetAbstractMethInfosForSynMethodDecl(infoReader: InfoReader, ad, memberName: Ident, bindm, typToSearchForAbstractMembers, valSynData, memberFlags: SynMemberFlags, findFlag: FindMemberFlag) =
 
     let g = infoReader.g
     if not memberFlags.IsInstance && memberFlags.IsOverrideOrExplicitImpl then
@@ -939,7 +939,7 @@ let GetAbstractMethInfosForSynMethodDecl(infoReader: InfoReader, ad, memberName:
         | _, Some(SlotImplSet(_, dispatchSlotsKeyed, _, _)) -> 
             NameMultiMap.find  memberName.idText dispatchSlotsKeyed |> List.map (fun reqdSlot -> reqdSlot.MethodInfo)
         | ty, None -> 
-            GetIntrinsicMethInfosOfType infoReader (Some memberName.idText) ad AllowMultiIntfInstantiations.Yes IgnoreOverrides bindm ty
+            GetIntrinsicMethInfosOfType infoReader (Some memberName.idText) ad AllowMultiIntfInstantiations.Yes findFlag bindm ty
     let dispatchSlots = minfos |> List.filter (fun minfo -> minfo.IsDispatchSlot)
     let valReprSynArities = SynInfo.AritiesOfArgs valSynData
 
diff --git a/src/Compiler/Checking/MethodOverrides.fsi b/src/Compiler/Checking/MethodOverrides.fsi
index 1c671e6bdb5..d18a8cdc6f1 100644
--- a/src/Compiler/Checking/MethodOverrides.fsi
+++ b/src/Compiler/Checking/MethodOverrides.fsi
@@ -156,7 +156,8 @@ val GetAbstractMethInfosForSynMethodDecl:
     bindm: range *
     typToSearchForAbstractMembers: (TType * SlotImplSet option) *
     valSynData: SynValInfo *
-    memberFlags: SynMemberFlags ->
+    memberFlags: SynMemberFlags *
+    findFlag: FindMemberFlag ->
         MethInfo list * MethInfo list
 
 /// Get the properties relevant to determining if a uniquely-identified-override exists based on the syntactic information
diff --git a/src/Compiler/Checking/NameResolution.fs b/src/Compiler/Checking/NameResolution.fs
index ad78b5ca5c5..6bc0b3e73b7 100644
--- a/src/Compiler/Checking/NameResolution.fs
+++ b/src/Compiler/Checking/NameResolution.fs
@@ -2693,6 +2693,7 @@ let rec ResolveLongIdentInTypePrim (ncenv: NameResolver) nenv lookupKind (resInf
 
     match nestedSearchAccessible with
     | Result res when not (isNil res) -> nestedSearchAccessible
+    | Exception _ -> nestedSearchAccessible
     | _ ->
         let suggestMembers (addToBuffer: string -> unit) =
             for p in ExtensionPropInfosOfTypeInScope ResultCollectionSettings.AllResults ncenv.InfoReader nenv None LookupIsInstance.Ambivalent ad m ty do
@@ -3867,7 +3868,8 @@ let ResolveExprDotLongIdentAndComputeRange (sink: TcResultsSink) (ncenv: NameRes
                 match findFlag, item with
                 | FindMemberFlag.PreferOverrides, _
                 | _, NonOverridable() -> item, itemRange, false
-                | FindMemberFlag.IgnoreOverrides, _ ->
+                | FindMemberFlag.IgnoreOverrides, _
+                | FindMemberFlag.DiscardOnFirstNonOverride, _ ->
                     let _, item, _, itemRange = resolveExpr FindMemberFlag.PreferOverrides
                     item, itemRange, true
 
@@ -3915,7 +3917,6 @@ let FakeInstantiationGenerator (_m: range) gps = List.map mkTyparTy gps
 
 // note: using local refs is ok since it is only used by VS
 let ItemForModuleOrNamespaceRef v = Item.ModuleOrNamespaces [v]
-let ItemForPropInfo (pinfo: PropInfo) = Item.Property (pinfo.PropertyName, [pinfo])
 
 let IsTyconUnseenObsoleteSpec ad g amap m (x: TyconRef) allowObsolete =
     not (IsEntityAccessible amap m ad x) ||
diff --git a/src/Compiler/Checking/NicePrint.fs b/src/Compiler/Checking/NicePrint.fs
index 6f2bcb62f80..6f02548b084 100644
--- a/src/Compiler/Checking/NicePrint.fs
+++ b/src/Compiler/Checking/NicePrint.fs
@@ -62,12 +62,6 @@ module internal PrintUtilities =
             s + ".0" 
         else s
 
-    let layoutsL (ls: Layout list) : Layout =
-        match ls with
-        | [] -> emptyL
-        | [x] -> x
-        | x :: xs -> List.fold (^^) x xs 
-
     // Layout a curried function type. Over multiple lines breaking takes some care, e.g.
     //
     // val SampleFunctionTupledAllBreakA:
@@ -1387,8 +1381,6 @@ module PrintTastMemberOrVals =
     let prettyLayoutOfValOrMemberNoInst denv infoReader v =
         prettyLayoutOfValOrMember denv infoReader emptyTyparInst v |> snd
 
-let layoutTrait denv x = x |> PrintTypes.layoutTrait denv
-
 let layoutTyparConstraint denv x = x |> PrintTypes.layoutTyparConstraint denv
 
 let outputType denv os x = x |> PrintTypes.layoutType denv |> bufferL os
diff --git a/src/Compiler/Checking/PatternMatchCompilation.fs b/src/Compiler/Checking/PatternMatchCompilation.fs
index 8d59e3301dc..1f7a2c29c44 100644
--- a/src/Compiler/Checking/PatternMatchCompilation.fs
+++ b/src/Compiler/Checking/PatternMatchCompilation.fs
@@ -81,8 +81,6 @@ and MatchClause =
     member c.Target = let (MatchClause(_, _, tg, _)) = c in tg
     member c.BoundVals = let (MatchClause(_p, _whenOpt, TTarget(vs, _, _), _m)) = c in vs
 
-let debug = false
-
 //---------------------------------------------------------------------------
 // Nasty stuff to permit obscure generic bindings such as
 //     let x, y = [], []
@@ -892,14 +890,6 @@ let rec layoutPat pat =
     | TPat_tuple (_, pats, _, _)
     | TPat_array (pats, _, _) -> Layout.bracketL (Layout.tupleL (List.map layoutPat pats))
     | _ -> Layout.wordL (TaggedText.tagText "?")
-
-let layoutPath _p = Layout.wordL (TaggedText.tagText "<path>")
-
-let layoutActive (Active (path, _subexpr, pat)) =
-    Layout.(--) (Layout.wordL (TaggedText.tagText "Active")) (Layout.tupleL [layoutPath path; layoutPat pat])
-
-let layoutFrontier (Frontier (i, actives, _)) =
-    Layout.(--) (Layout.wordL (TaggedText.tagText "Frontier ")) (Layout.tupleL [intL i; Layout.listL layoutActive actives])
 #endif
 
 let mkFrontiers investigations clauseNumber =
@@ -988,8 +978,6 @@ let rec isPatternDisjunctive inpPat =
 // The algorithm
 //---------------------------------------------------------------------------
 
-let getDiscrim (EdgeDiscrim(_, discrim, _)) = discrim
-
 let CompilePatternBasic
         (g: TcGlobals) denv amap tcVal infoReader mExpr mMatch
         warnOnUnused
diff --git a/src/Compiler/Checking/PostInferenceChecks.fs b/src/Compiler/Checking/PostInferenceChecks.fs
index 9338abd28f5..bb833eebabd 100644
--- a/src/Compiler/Checking/PostInferenceChecks.fs
+++ b/src/Compiler/Checking/PostInferenceChecks.fs
@@ -302,12 +302,24 @@ let BindVal cenv env (v: Val) =
     //printfn "binding %s..." v.DisplayName
     let alreadyDone = cenv.boundVals.ContainsKey v.Stamp
     cenv.boundVals[v.Stamp] <- 1
+    
+    let topLevelBindingHiddenBySignatureFile () =
+        let parentHasSignatureFile () =
+            match v.TryDeclaringEntity with
+            | ParentNone -> false
+            | Parent p ->
+                match p.TryDeref with
+                | ValueNone -> false
+                | ValueSome e -> e.HasSignatureFile
+
+        v.IsModuleBinding && not v.HasSignatureFile && parentHasSignatureFile ()
+    
     if not env.external &&
        not alreadyDone &&
        cenv.reportErrors && 
        not v.HasBeenReferenced && 
-       not v.IsCompiledAsTopLevel && 
-       not (v.DisplayName.StartsWithOrdinal("_")) && 
+       (not v.IsCompiledAsTopLevel || topLevelBindingHiddenBySignatureFile ()) &&
+       not (v.DisplayName.StartsWithOrdinal("_")) &&
        not v.IsCompilerGenerated then 
 
         if v.IsCtorThisVal then
@@ -676,9 +688,6 @@ let CheckTypeNoInnerByrefs cenv env m ty = CheckType PermitByRefType.NoInnerByRe
 let CheckTypeInstNoByrefs cenv env m tyargs =
     tyargs |> List.iter (CheckTypeNoByrefs cenv env m)
 
-let CheckTypeInstPermitAllByrefs cenv env m tyargs =
-    tyargs |> List.iter (CheckTypePermitAllByrefs cenv env m)
-
 let CheckTypeInstNoInnerByrefs cenv env m tyargs =
     tyargs |> List.iter (CheckTypeNoInnerByrefs cenv env m)
 
@@ -1819,11 +1828,6 @@ and CheckExprsPermitByRefLike cenv env exprs : Limit =
     |> List.map (CheckExprPermitByRefLike cenv env)
     |> CombineLimits
 
-and CheckExprsPermitReturnableByRef cenv env exprs : Limit = 
-    exprs 
-    |> List.map (CheckExprPermitReturnableByRef cenv env)
-    |> CombineLimits
-
 and CheckExprPermitByRefLike cenv env expr : Limit = 
     CheckExpr cenv env expr PermitByRefExpr.Yes
 
@@ -2215,10 +2219,6 @@ let CheckModuleBinding cenv env (TBind(v, e, _) as bind) =
 
     CheckBinding cenv { env with returnScope = 1 } true PermitByRefExpr.Yes bind |> ignore
 
-let CheckModuleBindings cenv env binds = 
-    for bind in binds do
-        CheckModuleBinding cenv env bind
-
 //--------------------------------------------------------------------------
 // check tycons
 //--------------------------------------------------------------------------
diff --git a/src/Compiler/Checking/QuotationTranslator.fs b/src/Compiler/Checking/QuotationTranslator.fs
index 80c7e52e7bf..063609d0232 100644
--- a/src/Compiler/Checking/QuotationTranslator.fs
+++ b/src/Compiler/Checking/QuotationTranslator.fs
@@ -22,7 +22,7 @@ open System.Collections.Generic
 
 module QP = QuotationPickler
 
-let verboseCReflect = condition "VERBOSE_CREFLECT"
+let verboseCReflect = isEnvVarSet "VERBOSE_CREFLECT"
 
 [<RequireQualifiedAccess>]
 type IsReflectedDefinition =
diff --git a/src/Compiler/CodeGen/EraseClosures.fs b/src/Compiler/CodeGen/EraseClosures.fs
index a0c022a01a8..b53526183b8 100644
--- a/src/Compiler/CodeGen/EraseClosures.fs
+++ b/src/Compiler/CodeGen/EraseClosures.fs
@@ -103,16 +103,6 @@ let stripSupportedAbstraction lambdas =
         tys, [], rest
     | rest -> [], [], rest
 
-// This must correspond to stripSupportedAbstraction
-let isSupportedDirectCall apps =
-    match apps with
-    | Apps_app (_, Apps_done _) -> true
-    | Apps_app (_, Apps_app (_, Apps_done _)) -> true
-    | Apps_app (_, Apps_app (_, Apps_app (_, Apps_done _))) -> true
-    | Apps_app (_, Apps_app (_, Apps_app (_, Apps_app (_, Apps_done _)))) -> true
-    | Apps_tyapp _ -> false
-    | _ -> false
-
 // --------------------------------------------------------------------
 // Prelude for function types.  Only use System.Func for now, prepare
 // for more refined types later.
@@ -226,17 +216,6 @@ let mkCallBlockForMultiValueApp cenv doTailCall (argTys, retTy) =
              I_call(doTailCall, mr, None))
     ]
 
-let mkMethSpecForClosureCall cenv (clospec: IlxClosureSpec) =
-    let tyargsl, argTys, rstruct = stripSupportedAbstraction clospec.FormalLambdas
-
-    if not (isNil tyargsl) then
-        failwith "mkMethSpecForClosureCall: internal error"
-
-    let retTyR = mkTyOfLambdas cenv rstruct
-    let argTysR = typesOfILParams argTys
-    let minstR = clospec.GenericArgs
-    mkILInstanceMethSpecInTy (clospec.ILType, "Invoke", argTysR, retTyR, minstR)
-
 // --------------------------------------------------------------------
 // Translate instructions....
 // --------------------------------------------------------------------
diff --git a/src/Compiler/CodeGen/EraseUnions.fs b/src/Compiler/CodeGen/EraseUnions.fs
index 626ddd49758..6781518feff 100644
--- a/src/Compiler/CodeGen/EraseUnions.fs
+++ b/src/Compiler/CodeGen/EraseUnions.fs
@@ -235,8 +235,6 @@ let mkTagFieldFormalType (ilg: ILGlobals) _cuspec = ilg.typ_Int32
 
 let mkTagFieldId ilg cuspec = "_tag", mkTagFieldType ilg cuspec
 
-let mkTailOrNullId baseTy = "tail", constFormalFieldTy baseTy
-
 let altOfUnionSpec (cuspec: IlxUnionSpec) cidx =
     try
         cuspec.Alternative cidx
diff --git a/src/Compiler/CodeGen/IlxGen.fs b/src/Compiler/CodeGen/IlxGen.fs
index 01edf861376..584c627b206 100644
--- a/src/Compiler/CodeGen/IlxGen.fs
+++ b/src/Compiler/CodeGen/IlxGen.fs
@@ -6,6 +6,8 @@ module internal FSharp.Compiler.IlxGen
 open System.IO
 open System.Reflection
 open System.Collections.Generic
+open System.Collections.Concurrent
+open System.Threading
 
 open FSharp.Compiler.IO
 open Internal.Utilities
@@ -42,6 +44,9 @@ open FSharp.Compiler.TypeRelations
 
 let IlxGenStackGuardDepth = StackGuard.GetDepthOption "IlxGen"
 
+let getEmptyStackGuard () =
+    StackGuard(IlxGenStackGuardDepth, "IlxAssemblyGenerator")
+
 let IsNonErasedTypar (tp: Typar) = not tp.IsErased
 
 let DropErasedTypars (tps: Typar list) = tps |> List.filter IsNonErasedTypar
@@ -233,7 +238,7 @@ type IlxGenIntraAssemblyInfo =
         /// 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: Dictionary<ILMethodRef, ILFieldSpec>
+        StaticFieldInfo: ConcurrentDictionary<ILMethodRef, ILFieldSpec>
     }
 
 /// Helper to make sure we take tailcalls in some situations
@@ -293,6 +298,9 @@ type IlxGenOptions =
 
         /// Whenever possible, use callvirt instead of call
         alwaysCallVirt: bool
+
+        /// When set to true, the IlxGen will delay generation of method bodies and generated them later in parallel (parallelized across files)
+        parallelIlxGenEnabled: bool
     }
 
 /// Compilation environment for compiling a fragment of an assembly
@@ -328,11 +336,14 @@ type cenv =
         intraAssemblyInfo: IlxGenIntraAssemblyInfo
 
         /// Cache methods with SecurityAttribute applied to them, to prevent unnecessary calls to ExistsInEntireHierarchyOfType
-        casApplied: Dictionary<Stamp, bool>
+        casApplied: IDictionary<Stamp, bool>
 
         /// Used to apply forced inlining optimizations to witnesses generated late during codegen
         mutable optimizeDuringCodeGen: bool -> Expr -> Expr
 
+        /// Delayed Method Generation - which can later be parallelized across multiple files
+        delayedGenMethods: Queue<unit -> unit>
+
         /// Guard the stack and move to a new one if necessary
         mutable stackGuard: StackGuard
 
@@ -358,9 +369,6 @@ let mkTypeOfExpr cenv m ilTy =
         m
     )
 
-let mkGetNameExpr cenv (ilt: ILType) m =
-    mkAsmExpr ([ I_ldstr ilt.BasicQualifiedName ], [], [], [ cenv.g.string_ty ], m)
-
 let useCallVirt (cenv: cenv) boxity (mspec: ILMethodSpec) isBaseCall =
     cenv.options.alwaysCallVirt
     && (boxity = AsObject)
@@ -477,12 +485,6 @@ let CompLocForInitClass cloc =
         Namespace = None
     }
 
-let CompLocForImplicitMainMethod cloc =
-    { cloc with
-        Enclosing = [ TypeNameForImplicitMainMethod cloc ]
-        Namespace = None
-    }
-
 let CompLocForPrivateImplementationDetails cloc =
     { cloc with
         Enclosing = [ TypeNameForPrivateImplementationDetails cloc ]
@@ -839,9 +841,6 @@ and GenParamTypes cenv m tyenv isSlotSig tys =
 
 and GenTypeArgs cenv m tyenv tyargs = GenTypeArgsAux cenv m tyenv tyargs
 
-and GenTypePermitVoidAux cenv m tyenv ty =
-    GenTypeAux cenv m tyenv VoidOK PtrTypesNotOK ty
-
 // Static fields generally go in a private InitializationCodeAndBackingFields section. This is to ensure all static
 // fields are initialized only in their class constructors (we generate one primary
 // cctor for each file to ensure initialization coherence across the file, regardless
@@ -1229,6 +1228,12 @@ and IlxGenEnv =
 
         /// Indicates that the .locals init flag should be set on a method and all its nested methods and lambdas
         initLocals: bool
+
+        /// Delay code gen for files.
+        delayCodeGen: bool
+
+        /// Collection of code-gen functions where each inner array represents codegen (method bodies) functions for a single file
+        delayedFileGenReverse: list<(unit -> unit)[]>
     }
 
     override _.ToString() = "<IlxGenEnv>"
@@ -1262,16 +1267,6 @@ let AddSignatureRemapInfo _msg (rpi, mhi) eenv =
         sigToImplRemapInfo = (mkRepackageRemapping rpi, mhi) :: eenv.sigToImplRemapInfo
     }
 
-let OutputStorage (pps: TextWriter) s =
-    match s with
-    | StaticPropertyWithField _ -> pps.Write "(top)"
-    | StaticProperty _ -> pps.Write "(top)"
-    | Method _ -> pps.Write "(top)"
-    | Local _ -> pps.Write "(local)"
-    | Arg _ -> pps.Write "(arg)"
-    | Env _ -> pps.Write "(env)"
-    | Null -> pps.Write "(null)"
-
 //--------------------------------------------------------------------------
 // Augment eenv with values
 //--------------------------------------------------------------------------
@@ -1493,13 +1488,7 @@ let ComputeFieldSpecForVal
 
     match optIntraAssemblyInfo with
     | None -> generate ()
-    | Some intraAssemblyInfo ->
-        match intraAssemblyInfo.StaticFieldInfo.TryGetValue ilGetterMethRef with
-        | true, res -> res
-        | _ ->
-            let res = generate ()
-            intraAssemblyInfo.StaticFieldInfo[ ilGetterMethRef ] <- res
-            res
+    | Some iai -> iai.StaticFieldInfo.GetOrAdd(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
@@ -1961,10 +1950,12 @@ type TypeDefBuilder(tdef: ILTypeDef, tdefDiscards) =
             gmethods.Add(mkILClassCtor body)
 
 and TypeDefsBuilder() =
-    let tdefs: HashMultiMap<string, int * (TypeDefBuilder * bool)> =
-        HashMultiMap(0, HashIdentity.Structural)
+
+    let tdefs =
+        ConcurrentDictionary<string, list<int * (TypeDefBuilder * bool)>>(HashIdentity.Structural)
 
     let mutable countDown = System.Int32.MaxValue
+    let mutable countUp = -1
 
     member b.Close() =
         //The order we emit type definitions is not deterministic since it is using the reverse of a range from a hash table. We should use an approximation of source order.
@@ -1972,7 +1963,7 @@ and TypeDefsBuilder() =
         // However, for some tests FSI generated code appears sensitive to the order, especially for nested types.
 
         [
-            for b, eliminateIfEmpty in HashRangeSorted tdefs do
+            for _, (b, eliminateIfEmpty) in tdefs.Values |> Seq.collect id |> Seq.sortBy fst do
                 let tdef = b.Close()
                 // Skip the <PrivateImplementationDetails$> type if it is empty
                 if
@@ -1988,7 +1979,7 @@ and TypeDefsBuilder() =
 
     member b.FindTypeDefBuilder nm =
         try
-            tdefs[nm] |> snd |> fst
+            tdefs[nm] |> List.head |> snd |> fst
         with :? KeyNotFoundException ->
             failwith ("FindTypeDefBuilder: " + nm + " not found")
 
@@ -2001,51 +1992,24 @@ and TypeDefsBuilder() =
     member b.AddTypeDef(tdef: ILTypeDef, eliminateIfEmpty, addAtEnd, tdefDiscards) =
         let idx =
             if addAtEnd then
-                (countDown <- countDown - 1
-                 countDown)
+                Interlocked.Decrement(&countDown)
             else
-                tdefs.Count
+                Interlocked.Increment(&countUp)
 
-        tdefs.Add(tdef.Name, (idx, (TypeDefBuilder(tdef, tdefDiscards), eliminateIfEmpty)))
+        let newVal = idx, (TypeDefBuilder(tdef, tdefDiscards), eliminateIfEmpty)
+
+        tdefs.AddOrUpdate(tdef.Name, [ newVal ], (fun key oldList -> newVal :: oldList))
+        |> ignore
 
 type AnonTypeGenerationTable() =
-    // Dictionary is safe here as it will only be used during the codegen stage - will happen on a single thread.
     let dict =
-        Dictionary<Stamp, ILMethodRef * ILMethodRef[] * ILType>(HashIdentity.Structural)
-
-    member _.Table = dict
+        ConcurrentDictionary<Stamp, Lazy<ILMethodRef * ILMethodRef[] * ILType>>(HashIdentity.Structural)
 
-/// Assembly generation buffers
-type AssemblyBuilder(cenv: cenv, anonTypeTable: AnonTypeGenerationTable) as mgbuf =
-    let g = cenv.g
-    // The Abstract IL table of types
-    let gtdefs = TypeDefsBuilder()
-
-    // The definitions of top level values, as quotations.
-    // Dictionary is safe here as it will only be used during the codegen stage - will happen on a single thread.
-    let mutable reflectedDefinitions: Dictionary<Val, string * int * Expr> =
-        Dictionary(HashIdentity.Reference)
+    let extraBindingsToGenerate = ConcurrentStack()
 
-    let mutable extraBindingsToGenerate = []
-
-    // A memoization table for generating value types for big constant arrays
-    let rawDataValueTypeGenerator =
-        MemoizationTable<CompileLocation * int, ILTypeSpec>(
-            (fun (cloc, size) ->
-                let name =
-                    CompilerGeneratedName("T" + string (newUnique ()) + "_" + string size + "Bytes") // Type names ending ...$T<unique>_37Bytes
-
-                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)
-                mgbuf.AddTypeDef(vtref, vtdef, false, true, None)
-                vtspec),
-            keyComparer = HashIdentity.Structural
-        )
-
-    let generateAnonType genToStringMethod (isStruct, ilTypeRef, nms) =
+    let generateAnonType cenv (mgbuf: AssemblyBuilder) genToStringMethod (isStruct, ilTypeRef, nms) =
 
+        let g = cenv.g
         let propTys = [ for i, nm in Array.indexed nms -> nm, ILType.TypeVar(uint16 i) ]
 
         // Note that this alternative below would give the same names as C#, but the generated
@@ -2257,30 +2221,81 @@ type AssemblyBuilder(cenv: cenv, anonTypeTable: AnonTypeGenerationTable) as mgbu
             mgbuf.AddTypeDef(ilTypeRef, ilTypeDef, false, true, None)
 
             let extraBindings =
-                [
+                [|
                     yield! AugmentWithHashCompare.MakeBindingsForCompareAugmentation g tycon
                     yield! AugmentWithHashCompare.MakeBindingsForCompareWithComparerAugmentation g tycon
                     yield! AugmentWithHashCompare.MakeBindingsForEqualityWithComparerAugmentation g tycon
                     yield! AugmentWithHashCompare.MakeBindingsForEqualsAugmentation g tycon
-                ]
+                |]
 
             let optimizedExtraBindings =
                 extraBindings
-                |> List.map (fun (TBind (a, b, c)) ->
+                |> Array.map (fun (TBind (a, b, c)) ->
                     // Disable method splitting for bindings related to anonymous records
                     TBind(a, cenv.optimizeDuringCodeGen true b, c))
+                |> Array.rev
 
-            extraBindingsToGenerate <- optimizedExtraBindings @ extraBindingsToGenerate
+            extraBindingsToGenerate.PushRange(optimizedExtraBindings)
 
         (ilCtorRef, ilMethodRefs, ilTy)
 
+    member this.GenerateAnonType(cenv, mgbuf, genToStringMethod, anonInfo: AnonRecdTypeInfo) =
+        let isStruct = evalAnonInfoIsStruct anonInfo
+        let key = anonInfo.Stamp
+
+        let at =
+            dict.GetOrAdd(key, lazy (generateAnonType cenv mgbuf genToStringMethod (isStruct, anonInfo.ILTypeRef, anonInfo.SortedNames)))
+
+        at.Force() |> ignore
+
+    member this.LookupAnonType(cenv, mgbuf, genToStringMethod, anonInfo: AnonRecdTypeInfo) =
+        match dict.TryGetValue anonInfo.Stamp with
+        | true, res -> res.Value
+        | _ ->
+            if anonInfo.ILTypeRef.Scope.IsLocalRef then
+                failwithf "the anonymous record %A has not been generated in the pre-phase of generating this module" anonInfo.ILTypeRef
+
+            this.GenerateAnonType(cenv, mgbuf, genToStringMethod, anonInfo)
+            dict[anonInfo.Stamp].Value
+
+    member _.GrabExtraBindingsToGenerate() =
+        let result = extraBindingsToGenerate.ToArray()
+        extraBindingsToGenerate.Clear()
+        result
+
+/// Assembly generation buffers
+and AssemblyBuilder(cenv: cenv, anonTypeTable: AnonTypeGenerationTable) as mgbuf =
+    let g = cenv.g
+    // The Abstract IL table of types
+    let gtdefs = TypeDefsBuilder()
+
+    // The definitions of top level values, as quotations
+    let reflectedDefinitions =
+        new StampedDictionary<Val, string * Expr>(HashIdentity.Reference)
+
+    // A memoization table for generating value types for big constant arrays
+    let rawDataValueTypeGenerator =
+        MemoizationTable<CompileLocation * int, ILTypeSpec>(
+            (fun (cloc, size) ->
+                let name =
+                    CompilerGeneratedName("T" + string (newUnique ()) + "_" + string size + "Bytes") // Type names ending ...$T<unique>_37Bytes
+
+                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)
+                mgbuf.AddTypeDef(vtref, vtdef, false, true, None)
+                vtspec),
+            keyComparer = HashIdentity.Structural
+        )
+
     let mutable explicitEntryPointInfo: ILTypeRef option = None
 
     /// static init fields on script modules.
-    let mutable scriptInitFspecs: (ILFieldSpec * range) list = []
+    let scriptInitFspecs = ConcurrentStack<ILFieldSpec * range>()
 
     member _.AddScriptInitFieldSpec(fieldSpec, range) =
-        scriptInitFspecs <- (fieldSpec, range) :: scriptInitFspecs
+        scriptInitFspecs.Push((fieldSpec, range))
 
     /// This initializes the script in #load and fsc command-line order causing their
     /// side effects to be executed.
@@ -2301,7 +2316,7 @@ type AssemblyBuilder(cenv: cenv, anonTypeTable: AnonTypeGenerationTable) as mgbu
                     []
                 )
 
-            scriptInitFspecs |> List.iter InitializeCompiledScript
+            scriptInitFspecs |> Seq.iter InitializeCompiledScript
         | None -> ()
 
     member _.GenerateRawDataValueType(cloc, size) =
@@ -2312,29 +2327,13 @@ type AssemblyBuilder(cenv: cenv, anonTypeTable: AnonTypeGenerationTable) as mgbu
         rawDataValueTypeGenerator.Apply((cloc, size))
 
     member _.GenerateAnonType(genToStringMethod, anonInfo: AnonRecdTypeInfo) =
-        let isStruct = evalAnonInfoIsStruct anonInfo
-        let key = anonInfo.Stamp
-
-        if not (anonTypeTable.Table.ContainsKey key) then
-            let info =
-                generateAnonType genToStringMethod (isStruct, anonInfo.ILTypeRef, anonInfo.SortedNames)
-
-            anonTypeTable.Table[ key ] <- info
+        anonTypeTable.GenerateAnonType(cenv, mgbuf, genToStringMethod, anonInfo)
 
     member this.LookupAnonType(genToStringMethod, anonInfo: AnonRecdTypeInfo) =
-        match anonTypeTable.Table.TryGetValue anonInfo.Stamp with
-        | true, res -> res
-        | _ ->
-            if anonInfo.ILTypeRef.Scope.IsLocalRef then
-                failwithf "the anonymous record %A has not been generated in the pre-phase of generating this module" anonInfo.ILTypeRef
-
-            this.GenerateAnonType(genToStringMethod, anonInfo)
-            anonTypeTable.Table[anonInfo.Stamp]
+        anonTypeTable.LookupAnonType(cenv, mgbuf, genToStringMethod, anonInfo)
 
     member _.GrabExtraBindingsToGenerate() =
-        let result = extraBindingsToGenerate
-        extraBindingsToGenerate <- []
-        result
+        anonTypeTable.GrabExtraBindingsToGenerate()
 
     member _.AddTypeDef(tref: ILTypeRef, tdef, eliminateIfEmpty, addAtEnd, tdefDiscards) =
         gtdefs
@@ -2345,14 +2344,10 @@ type AssemblyBuilder(cenv: cenv, anonTypeTable: AnonTypeGenerationTable) as mgbu
         gtdefs.FindNestedTypeDefBuilder(tref).GetCurrentFields()
 
     member _.AddReflectedDefinition(vspec: Val, expr) =
-        // preserve order by storing index of item
-        let n = reflectedDefinitions.Count
-        reflectedDefinitions.Add(vspec, (vspec.CompiledName cenv.g.CompilerGlobalState, n, expr))
+        reflectedDefinitions.Add(vspec, (vspec.CompiledName cenv.g.CompilerGlobalState, expr))
 
     member _.ReplaceNameOfReflectedDefinition(vspec, newName) =
-        match reflectedDefinitions.TryGetValue vspec with
-        | true, (name, n, expr) when name <> newName -> reflectedDefinitions[vspec] <- (newName, n, expr)
-        | _ -> ()
+        reflectedDefinitions.UpdateIfExists(vspec, (fun (oldName, expr) -> if newName = oldName then None else Some(newName, expr)))
 
     member _.AddMethodDef(tref: ILTypeRef, ilMethodDef) =
         gtdefs.FindNestedTypeDefBuilder(tref).AddMethodDef(ilMethodDef)
@@ -2366,8 +2361,8 @@ type AssemblyBuilder(cenv: cenv, anonTypeTable: AnonTypeGenerationTable) as mgbu
         let instrs =
             [
                 yield!
-                    (if condition "NO_ADD_FEEFEE_TO_CCTORS" then []
-                     elif condition "ADD_SEQPT_TO_CCTORS" then seqpt
+                    (if isEnvVarSet "NO_ADD_FEEFEE_TO_CCTORS" then []
+                     elif isEnvVarSet "ADD_SEQPT_TO_CCTORS" then seqpt
                      else feefee) // mark start of hidden code
                 yield mkLdcInt32 0
                 yield mkNormalStsfld fspec
@@ -2392,7 +2387,7 @@ type AssemblyBuilder(cenv: cenv, anonTypeTable: AnonTypeGenerationTable) as mgbu
         // old implementation adds new element to the head of list so result was accumulated in reversed order
         let orderedReflectedDefinitions =
             [
-                for KeyValue (vspec, (name, n, expr)) in reflectedDefinitions -> n, ((name, vspec), expr)
+                for (vspec, (n, (name, expr))) in reflectedDefinitions.GetAll() -> n, ((name, vspec), expr)
             ]
             |> List.sortBy (fst >> (~-)) // invert the result to get 'order-by-descending' behavior (items in list are 0..* so we don't need to worry about int.MinValue)
             |> List.map snd
@@ -2648,7 +2643,8 @@ type CodeGenBuffer(m: range, mgbuf: AssemblyBuilder, methodName, alreadyUsedArgs
                     i2)
 
         let codeLabels =
-            let dict = Dictionary.newWithSize (codeLabelToPC.Count + codeLabelToCodeLabel.Count)
+            let dict =
+                Dictionary.newWithSize ((codeLabelToPC.Count + codeLabelToCodeLabel.Count) * 2)
 
             for kvp in codeLabelToPC do
                 dict.Add(kvp.Key, lab2pc 0 kvp.Key)
@@ -2822,7 +2818,6 @@ let LocalScope nm cgbuf (f: Mark * Mark -> 'a) : 'a =
     res
 
 let compileSequenceExpressions = true // try (System.Environment.GetEnvironmentVariable("FSHARP_COMPILED_SEQ") <> null) with _ -> false
-let compileStateMachineExpressions = true // try (System.Environment.GetEnvironmentVariable("FSHARP_COMPILED_STATEMACHINES") <> null) with _ -> false
 
 //-------------------------------------------------------------------------
 // Sequence Point Logic
@@ -3109,6 +3104,23 @@ and CodeGenMethodForExpr cenv mgbuf (entryPointInfo, methodName, eenv, alreadyUs
 
     code
 
+and DelayCodeGenMethodForExpr cenv mgbuf ((_, _, eenv, _, _, _, _) as args) =
+    let change3rdOutOf7 (a1, a2, _, a4, a5, a6, a7) newA3 = (a1, a2, newA3, a4, a5, a6, a7)
+
+    if eenv.delayCodeGen then
+        let cenv =
+            { cenv with
+                stackGuard = getEmptyStackGuard ()
+            }
+        // Once this is lazily-evaluated later, it should not put things in queue. They would not be picked up by anyone.
+        let newArgs = change3rdOutOf7 args { eenv with delayCodeGen = false }
+
+        let lazyMethodBody = lazy (CodeGenMethodForExpr cenv mgbuf newArgs)
+        cenv.delayedGenMethods.Enqueue(fun () -> lazyMethodBody.Force() |> ignore)
+        lazyMethodBody
+    else
+        notlazy (CodeGenMethodForExpr cenv mgbuf args)
+
 //--------------------------------------------------------------------------
 // Generate sequels
 //--------------------------------------------------------------------------
@@ -8180,19 +8192,6 @@ and GenBinding cenv cgbuf eenv (bind: Binding) (isStateVar: bool) =
     GenDebugPointForBind cenv cgbuf bind
     GenBindingAfterDebugPoint cenv cgbuf eenv bind isStateVar None
 
-and ComputeMemberAccessRestrictedBySig eenv vspec =
-    let isHidden =
-        // Anything hidden by a signature gets assembly visibility
-        IsHiddenVal eenv.sigToImplRemapInfo vspec
-        ||
-        // Anything that's not a module or member binding gets assembly visibility
-        not vspec.IsMemberOrModuleBinding
-        ||
-        // Compiler generated members for class function 'let' bindings get assembly visibility
-        vspec.IsIncrClassGeneratedMember
-
-    ComputeMemberAccess isHidden
-
 and ComputeMethodAccessRestrictedBySig eenv vspec =
     let isHidden =
         // Anything hidden by a signature gets assembly visibility
@@ -8349,10 +8348,10 @@ and GenBindingAfterDebugPoint cenv cgbuf eenv bind isStateVar startMarkOpt =
         cgbuf.mgbuf.AddOrMergePropertyDef(ilGetterMethSpec.MethodRef.DeclaringTypeRef, ilPropDef, m)
 
         let ilMethodDef =
-            let ilCode =
-                CodeGenMethodForExpr cenv cgbuf.mgbuf ([], ilGetterMethSpec.Name, eenv, 0, None, rhsExpr, Return)
+            let ilLazyCode =
+                DelayCodeGenMethodForExpr cenv cgbuf.mgbuf ([], ilGetterMethSpec.Name, eenv, 0, None, rhsExpr, Return)
 
-            let ilMethodBody = MethodBody.IL(lazy ilCode)
+            let ilMethodBody = MethodBody.IL(ilLazyCode)
 
             (mkILStaticMethod ([], ilGetterMethSpec.Name, access, [], mkILReturn ilTy, ilMethodBody))
                 .WithSpecialName
@@ -9069,11 +9068,11 @@ and GenMethodForBinding
                 | [ h ] -> Some h
                 | _ -> None
 
-            let ilCodeLazy =
-                CodeGenMethodForExpr cenv mgbuf (tailCallInfo, mspec.Name, eenvForMeth, 0, selfValOpt, bodyExpr, sequel)
+            let ilLazyCode =
+                DelayCodeGenMethodForExpr cenv mgbuf (tailCallInfo, mspec.Name, eenvForMeth, 0, selfValOpt, bodyExpr, sequel)
 
             // This is the main code generation for most methods
-            false, MethodBody.IL(notlazy ilCodeLazy), false
+            false, MethodBody.IL(ilLazyCode), false
 
     // Do not generate DllImport attributes into the code - they are implicit from the P/Invoke
     let attrs =
@@ -10277,7 +10276,13 @@ and GenImplFile cenv (mgbuf: AssemblyBuilder) mainInfoOpt eenv (implFile: Checke
 
         AddBindingsForLocalModuleOrNamespaceType allocVal clocCcu eenv signature
 
-    eenvafter
+    let eenvfinal =
+        { eenvafter with
+            delayedFileGenReverse = (cenv.delayedGenMethods |> Array.ofSeq) :: eenvafter.delayedFileGenReverse
+        }
+
+    cenv.delayedGenMethods.Clear()
+    eenvfinal
 
 and GenForceWholeFileInitializationAsPartOfCCtor cenv (mgbuf: AssemblyBuilder) (lazyInitInfo: ResizeArray<_>) tref imports m =
     // Authoring a .cctor with effects forces the cctor for the 'initialization' module by doing a dummy store & load of a field
@@ -11555,18 +11560,19 @@ let CodegenAssembly cenv eenv mgbuf implFiles =
     | None -> ()
     | Some (firstImplFiles, lastImplFile) ->
 
-        // Generate the assembly sequentially, implementation file by implementation file.
-        //
-        // NOTE: In theory this could be done in parallel, except for the presence of linear
-        // state in the AssemblyBuilder
         let eenv = List.fold (GenImplFile cenv mgbuf None) eenv firstImplFiles
         let eenv = GenImplFile cenv mgbuf cenv.options.mainMethodInfo eenv lastImplFile
 
+        eenv.delayedFileGenReverse
+        |> Array.ofList
+        |> Array.rev
+        |> ArrayParallel.iter (fun genMeths -> genMeths |> Array.iter (fun gen -> gen ()))
+
         // Some constructs generate residue types and bindings. Generate these now. They don't result in any
         // top-level initialization code.
         let extraBindings = mgbuf.GrabExtraBindingsToGenerate()
         //printfn "#extraBindings = %d" extraBindings.Length
-        if not (isNil extraBindings) then
+        if extraBindings.Length > 0 then
             let mexpr = TMDefs [ for b in extraBindings -> TMDefLet(b, range0) ]
 
             let _emptyTopInstrs, _emptyTopCode =
@@ -11619,6 +11625,8 @@ let GetEmptyIlxGenEnv (g: TcGlobals) ccu =
         isInLoop = false
         initLocals = true
         imports = None
+        delayCodeGen = true
+        delayedFileGenReverse = []
     }
 
 type IlxGenResults =
@@ -11631,6 +11639,43 @@ type IlxGenResults =
         quotationResourceInfo: (ILTypeRef list * byte[]) list
     }
 
+let private GenerateResourcesForQuotations reflectedDefinitions cenv =
+    match reflectedDefinitions with
+    | [] -> []
+    | _ ->
+        let qscope =
+            QuotationTranslator.QuotationGenerationScope.Create(
+                cenv.g,
+                cenv.amap,
+                cenv.viewCcu,
+                cenv.tcVal,
+                QuotationTranslator.IsReflectedDefinition.Yes
+            )
+
+        let defns =
+            reflectedDefinitions
+            |> List.choose (fun ((methName, v), e) ->
+                try
+                    let mbaseR, astExpr =
+                        QuotationTranslator.ConvReflectedDefinition qscope methName v e
+
+                    Some(mbaseR, astExpr)
+                with QuotationTranslator.InvalidQuotedTerm e ->
+                    warning e
+                    None)
+
+        let referencedTypeDefs, typeSplices, exprSplices = qscope.Close()
+
+        for _typeSplice, m in typeSplices do
+            error (InternalError("A free type variable was detected in a reflected definition", m))
+
+        for _exprSplice, m in exprSplices do
+            error (Error(FSComp.SR.ilReflectedDefinitionsCannotUseSliceOperator (), m))
+
+        let defnsResourceBytes = defns |> QuotationPickler.PickleDefns
+
+        [ (referencedTypeDefs, defnsResourceBytes) ]
+
 let GenerateCode (cenv, anonTypeTable, eenv, CheckedAssemblyAfterOptimization implFiles, assemAttribs, moduleAttribs) =
 
     use _ = UseBuildPhase BuildPhase.IlxGen
@@ -11642,6 +11687,7 @@ let GenerateCode (cenv, anonTypeTable, eenv, CheckedAssemblyAfterOptimization im
     let eenv =
         { eenv with
             cloc = CompLocForFragment cenv.options.fragName cenv.viewCcu
+            delayCodeGen = cenv.options.parallelIlxGenEnabled
         }
 
     // Generate the PrivateImplementationDetails type
@@ -11664,45 +11710,7 @@ let GenerateCode (cenv, anonTypeTable, eenv, CheckedAssemblyAfterOptimization im
         GenAttrs cenv eenv (assemAttribs |> List.filter (fun a -> not (IsAssemblyVersionAttribute g a)))
 
     let tdefs, reflectedDefinitions = mgbuf.Close()
-
-    // Generate the quotations
-    let quotationResourceInfo =
-        match reflectedDefinitions with
-        | [] -> []
-        | _ ->
-            let qscope =
-                QuotationTranslator.QuotationGenerationScope.Create(
-                    g,
-                    cenv.amap,
-                    cenv.viewCcu,
-                    cenv.tcVal,
-                    QuotationTranslator.IsReflectedDefinition.Yes
-                )
-
-            let defns =
-                reflectedDefinitions
-                |> List.choose (fun ((methName, v), e) ->
-                    try
-                        let mbaseR, astExpr =
-                            QuotationTranslator.ConvReflectedDefinition qscope methName v e
-
-                        Some(mbaseR, astExpr)
-                    with QuotationTranslator.InvalidQuotedTerm e ->
-                        warning e
-                        None)
-
-            let referencedTypeDefs, typeSplices, exprSplices = qscope.Close()
-
-            for _typeSplice, m in typeSplices do
-                error (InternalError("A free type variable was detected in a reflected definition", m))
-
-            for _exprSplice, m in exprSplices do
-                error (Error(FSComp.SR.ilReflectedDefinitionsCannotUseSliceOperator (), m))
-
-            let defnsResourceBytes = defns |> QuotationPickler.PickleDefns
-
-            [ (referencedTypeDefs, defnsResourceBytes) ]
-
+    let quotationResourceInfo = GenerateResourcesForQuotations reflectedDefinitions cenv
     let ilNetModuleAttrs = GenAttrs cenv eenv moduleAttribs
 
     let casApplied = Dictionary<Stamp, bool>()
@@ -11851,14 +11859,12 @@ type IlxAssemblyGenerator(amap: ImportMap, tcGlobals: TcGlobals, tcVal: Constrai
     // The incremental state held by the ILX code generator
     let mutable ilxGenEnv = GetEmptyIlxGenEnv tcGlobals ccu
     let anonTypeTable = AnonTypeGenerationTable()
-    // Dictionaries are safe here as they will only be used during the codegen stage - will happen on a single thread.
+
     let intraAssemblyInfo =
         {
-            StaticFieldInfo = Dictionary<_, _>(HashIdentity.Structural)
+            StaticFieldInfo = ConcurrentDictionary<_, _>(HashIdentity.Structural)
         }
 
-    let casApplied = Dictionary<Stamp, bool>()
-
     let cenv =
         {
             g = tcGlobals
@@ -11874,11 +11880,12 @@ type IlxAssemblyGenerator(amap: ImportMap, tcGlobals: TcGlobals, tcVal: Constrai
             ilUnitTy = None
             namedDebugPointsForInlinedCode = Map.empty
             amap = amap
-            casApplied = casApplied
+            casApplied = ConcurrentDictionary<Stamp, bool>()
             intraAssemblyInfo = intraAssemblyInfo
             optionsOpt = None
             optimizeDuringCodeGen = (fun _flag expr -> expr)
-            stackGuard = StackGuard(IlxGenStackGuardDepth, "IlxAssemblyGenerator")
+            stackGuard = getEmptyStackGuard ()
+            delayedGenMethods = Queue()
         }
 
     /// Register a set of referenced assemblies with the ILX code generator
diff --git a/src/Compiler/CodeGen/IlxGen.fsi b/src/Compiler/CodeGen/IlxGen.fsi
index d68463e9ca7..4658dd0693b 100644
--- a/src/Compiler/CodeGen/IlxGen.fsi
+++ b/src/Compiler/CodeGen/IlxGen.fsi
@@ -59,6 +59,9 @@ type internal IlxGenOptions =
 
         /// Indicates that, whenever possible, use callvirt instead of call
         alwaysCallVirt: bool
+
+        /// When set to true, the IlxGen will delay generation of method bodies and generate them later in parallel (parallelized across files)
+        parallelIlxGenEnabled: bool
     }
 
 /// The results of the ILX compilation of one fragment of an assembly
diff --git a/src/Compiler/Driver/CompilerConfig.fs b/src/Compiler/Driver/CompilerConfig.fs
index 91a2e9fde3d..aee2d46e095 100644
--- a/src/Compiler/Driver/CompilerConfig.fs
+++ b/src/Compiler/Driver/CompilerConfig.fs
@@ -5,6 +5,7 @@ module internal FSharp.Compiler.CompilerConfig
 
 open System
 open System.Collections.Concurrent
+open System.Runtime.InteropServices
 open System.IO
 open Internal.Utilities
 open Internal.Utilities.FSharpEnvironment
@@ -47,6 +48,10 @@ let FSharpScriptFileSuffixes = [ ".fsscript"; ".fsx" ]
 let FSharpIndentationAwareSyntaxFileSuffixes =
     [ ".fs"; ".fsscript"; ".fsx"; ".fsi" ]
 
+let FSharpExperimentalFeaturesEnabledAutomatically =
+    String.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable("FSHARP_EXPERIMENTAL_FEATURES"))
+    |> not
+
 //--------------------------------------------------------------------------
 // General file name resolver
 //--------------------------------------------------------------------------
@@ -223,12 +228,7 @@ type TimeStampCache(defaultTimeStamp: DateTime) =
         if ok then
             v
         else
-            let v =
-                try
-                    FileSystem.GetLastWriteTimeShim fileName
-                with :? FileNotFoundException ->
-                    defaultTimeStamp
-
+            let v = FileSystem.GetLastWriteTimeShim fileName
             files[fileName] <- v
             v
 
@@ -300,7 +300,7 @@ type ImportedAssembly =
         IsProviderGenerated: bool
         mutable TypeProviders: Tainted<ITypeProvider> list
 #endif
-        FSharpOptimizationData: Microsoft.FSharp.Control.Lazy<Option<Optimizer.LazyModuleInfo>>
+        FSharpOptimizationData: Microsoft.FSharp.Control.Lazy<Optimizer.LazyModuleInfo option>
     }
 
 type AvailableImportedAssembly =
@@ -508,6 +508,7 @@ type TcConfigBuilder =
         mutable deterministic: bool
         mutable concurrentBuild: bool
         mutable parallelCheckingWithSignatureFiles: bool
+        mutable parallelIlxGen: bool
         mutable emitMetadataAssembly: MetadataAssemblyGeneration
         mutable preferredUiLang: string option
         mutable lcid: int option
@@ -517,6 +518,7 @@ type TcConfigBuilder =
 
         /// show times between passes?
         mutable showTimes: bool
+        mutable writeTimesToFile: string option
         mutable showLoadedAssemblies: bool
         mutable continueAfterParseFailure: bool
 
@@ -587,6 +589,8 @@ type TcConfigBuilder =
         mutable exiter: Exiter
 
         mutable parallelReferenceResolution: ParallelReferenceResolution
+
+        mutable captureIdentifiersWhenParsing: bool
     }
 
     // Directories to start probing in
@@ -733,13 +737,15 @@ type TcConfigBuilder =
             emitTailcalls = true
             deterministic = false
             concurrentBuild = true
-            parallelCheckingWithSignatureFiles = false
+            parallelCheckingWithSignatureFiles = FSharpExperimentalFeaturesEnabledAutomatically
+            parallelIlxGen = FSharpExperimentalFeaturesEnabledAutomatically
             emitMetadataAssembly = MetadataAssemblyGeneration.None
             preferredUiLang = None
             lcid = None
             productNameForBannerText = FSharpProductName
             showBanner = true
             showTimes = false
+            writeTimesToFile = None
             showLoadedAssemblies = false
             continueAfterParseFailure = false
 #if !NO_TYPEPROVIDERS
@@ -775,6 +781,7 @@ type TcConfigBuilder =
             xmlDocInfoLoader = None
             exiter = QuitProcessExiter
             parallelReferenceResolution = ParallelReferenceResolution.Off
+            captureIdentifiersWhenParsing = false
         }
 
     member tcConfigB.FxResolver =
@@ -1129,27 +1136,20 @@ type TcConfig private (data: TcConfigBuilder, validate: bool) =
                         yield clrFacades
 
                 | None ->
-                    // "there is no really good notion of runtime directory on .NETCore"
-#if NETSTANDARD
-                    let runtimeRoot = Path.GetDirectoryName(typeof<Object>.Assembly.Location)
-#else
-                    let runtimeRoot =
-                        System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory()
-#endif
-                    let runtimeRootWithoutSlash = runtimeRoot.TrimEnd('/', '\\')
-                    let runtimeRootFacades = Path.Combine(runtimeRootWithoutSlash, "Facades")
-                    let runtimeRootWPF = Path.Combine(runtimeRootWithoutSlash, "WPF")
-
                     match data.resolutionEnvironment with
                     | LegacyResolutionEnvironment.CompilationAndEvaluation ->
                         // Default compilation-and-execution-time references on .NET Framework and Mono, e.g. for F# Interactive
-                        //
                         // In the current way of doing things, F# Interactive refers to implementation assemblies.
+                        let runtimeRoot = RuntimeEnvironment.GetRuntimeDirectory().TrimEnd('/', '\\')
                         yield runtimeRoot
 
+                        let runtimeRootFacades = Path.Combine(runtimeRoot, "Facades")
+
                         if FileSystem.DirectoryExistsShim runtimeRootFacades then
                             yield runtimeRootFacades // System.Runtime.dll is in /usr/lib/mono/4.5/Facades
 
+                        let runtimeRootWPF = Path.Combine(runtimeRoot, "WPF")
+
                         if FileSystem.DirectoryExistsShim runtimeRootWPF then
                             yield runtimeRootWPF // PresentationCore.dll is in C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF
 
@@ -1287,6 +1287,7 @@ type TcConfig private (data: TcConfigBuilder, validate: bool) =
     member _.deterministic = data.deterministic
     member _.concurrentBuild = data.concurrentBuild
     member _.parallelCheckingWithSignatureFiles = data.parallelCheckingWithSignatureFiles
+    member _.parallelIlxGen = data.parallelIlxGen
     member _.emitMetadataAssembly = data.emitMetadataAssembly
     member _.pathMap = data.pathMap
     member _.langVersion = data.langVersion
@@ -1296,6 +1297,7 @@ type TcConfig private (data: TcConfigBuilder, validate: bool) =
     member _.productNameForBannerText = data.productNameForBannerText
     member _.showBanner = data.showBanner
     member _.showTimes = data.showTimes
+    member _.writeTimesToFile = data.writeTimesToFile
     member _.showLoadedAssemblies = data.showLoadedAssemblies
     member _.continueAfterParseFailure = data.continueAfterParseFailure
 #if !NO_TYPEPROVIDERS
@@ -1319,6 +1321,7 @@ type TcConfig private (data: TcConfigBuilder, validate: bool) =
     member _.xmlDocInfoLoader = data.xmlDocInfoLoader
     member _.exiter = data.exiter
     member _.parallelReferenceResolution = data.parallelReferenceResolution
+    member _.captureIdentifiersWhenParsing = data.captureIdentifiersWhenParsing
 
     static member Create(builder, validate) =
         use _ = UseBuildPhase BuildPhase.Parameter
diff --git a/src/Compiler/Driver/CompilerConfig.fsi b/src/Compiler/Driver/CompilerConfig.fsi
index 70abf7beb63..89f2cf81537 100644
--- a/src/Compiler/Driver/CompilerConfig.fsi
+++ b/src/Compiler/Driver/CompilerConfig.fsi
@@ -414,6 +414,8 @@ type TcConfigBuilder =
 
         mutable parallelCheckingWithSignatureFiles: bool
 
+        mutable parallelIlxGen: bool
+
         mutable emitMetadataAssembly: MetadataAssemblyGeneration
 
         mutable preferredUiLang: string option
@@ -426,6 +428,8 @@ type TcConfigBuilder =
 
         mutable showTimes: bool
 
+        mutable writeTimesToFile: string option
+
         mutable showLoadedAssemblies: bool
 
         mutable continueAfterParseFailure: bool
@@ -489,6 +493,8 @@ type TcConfigBuilder =
         mutable exiter: Exiter
 
         mutable parallelReferenceResolution: ParallelReferenceResolution
+
+        mutable captureIdentifiersWhenParsing: bool
     }
 
     static member CreateNew:
@@ -734,6 +740,8 @@ type TcConfig =
 
     member parallelCheckingWithSignatureFiles: bool
 
+    member parallelIlxGen: bool
+
     member emitMetadataAssembly: MetadataAssemblyGeneration
 
     member pathMap: PathMap
@@ -748,6 +756,8 @@ type TcConfig =
 
     member showTimes: bool
 
+    member writeTimesToFile: string option
+
     member showLoadedAssemblies: bool
 
     member continueAfterParseFailure: bool
@@ -854,6 +864,8 @@ type TcConfig =
 
     member parallelReferenceResolution: ParallelReferenceResolution
 
+    member captureIdentifiersWhenParsing: 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>]
@@ -890,3 +902,6 @@ val FSharpScriptFileSuffixes: string list
 val FSharpIndentationAwareSyntaxFileSuffixes: string list
 
 val FSharpMLCompatFileSuffixes: string list
+
+/// Indicates whether experimental features should be enabled automatically
+val FSharpExperimentalFeaturesEnabledAutomatically: bool
diff --git a/src/Compiler/Driver/CompilerImports.fs b/src/Compiler/Driver/CompilerImports.fs
index 22162611f0c..4def1237b11 100644
--- a/src/Compiler/Driver/CompilerImports.fs
+++ b/src/Compiler/Driver/CompilerImports.fs
@@ -106,15 +106,6 @@ let GetResourceNameAndOptimizationDataFunc (r: ILResource) =
 let IsReflectedDefinitionsResource (r: ILResource) =
     r.Name.StartsWithOrdinal(QuotationPickler.SerializedReflectedDefinitionsResourceNameBase)
 
-let MakeILResource rName bytes =
-    {
-        Name = rName
-        Location = ILResourceLocation.Local(ByteStorage.FromByteArray(bytes))
-        Access = ILResourceAccess.Public
-        CustomAttrsStored = storeILCustomAttrs emptyILCustomAttrs
-        MetadataIndex = NoMetadataIdx
-    }
-
 let PickleToResource inMem file (g: TcGlobals) compress scope rName p x =
     let file = PathMap.apply g.pathMap file
 
@@ -338,7 +329,7 @@ type ImportedAssembly =
         IsProviderGenerated: bool
         mutable TypeProviders: Tainted<ITypeProvider> list
 #endif
-        FSharpOptimizationData: Microsoft.FSharp.Control.Lazy<Option<Optimizer.LazyModuleInfo>>
+        FSharpOptimizationData: Microsoft.FSharp.Control.Lazy<Optimizer.LazyModuleInfo option>
     }
 
 type AvailableImportedAssembly =
diff --git a/src/Compiler/Driver/CompilerImports.fsi b/src/Compiler/Driver/CompilerImports.fsi
index 30bb4333f77..f9fa17487ae 100644
--- a/src/Compiler/Driver/CompilerImports.fsi
+++ b/src/Compiler/Driver/CompilerImports.fsi
@@ -116,7 +116,7 @@ type ImportedAssembly =
       IsProviderGenerated: bool
       mutable TypeProviders: Tainted<ITypeProvider> list
 #endif
-      FSharpOptimizationData: Lazy<Option<LazyModuleInfo>> }
+      FSharpOptimizationData: Lazy<LazyModuleInfo option> }
 
 /// Tables of assembly resolutions
 [<Sealed>]
diff --git a/src/Compiler/Driver/CompilerOptions.fs b/src/Compiler/Driver/CompilerOptions.fs
index 4fc6fbf1f11..b9c97e17bfa 100644
--- a/src/Compiler/Driver/CompilerOptions.fs
+++ b/src/Compiler/Driver/CompilerOptions.fs
@@ -70,7 +70,7 @@ and CompilerOption =
         name: string *
         argumentDescriptionString: string *
         actionSpec: OptionSpec *
-        deprecationError: Option<exn> *
+        deprecationError: exn option *
         helpText: string option
 
 and CompilerOptionBlock =
@@ -509,7 +509,6 @@ let ParseCompilerOptions (collectOtherArgument: string -> unit, blocks: Compiler
 // Compiler options
 //--------------------------------------------------------------------------
 
-let lexFilterVerbose = false
 let mutable enableConsoleColoring = true // global state
 
 let setFlag r n =
@@ -710,11 +709,9 @@ let tagModule = "module"
 let tagFile = "<file>"
 let tagFileList = "<file;...>"
 let tagDirList = "<dir;...>"
-let tagPathList = "<path;...>"
 let tagResInfo = "<resinfo>"
 let tagFullPDBOnlyPortable = "{full|pdbonly|portable|embedded}"
 let tagWarnList = "<warn;...>"
-let tagSymbolList = "<symbol;...>"
 let tagAddress = "<address>"
 let tagAlgorithm = "{SHA1|SHA256}"
 let tagInt = "<n>"
@@ -770,24 +767,6 @@ let inputFileFlagsBoth (tcConfigB: TcConfigBuilder) =
         )
     ]
 
-let referenceFlagAbbrev (tcConfigB: TcConfigBuilder) =
-    CompilerOption(
-        "r",
-        tagFile,
-        OptionString(fun s -> tcConfigB.AddReferencedAssemblyByPath(rangeStartup, s)),
-        None,
-        Some(FSComp.SR.optsShortFormOf ("--reference"))
-    )
-
-let compilerToolFlagAbbrev (tcConfigB: TcConfigBuilder) =
-    CompilerOption(
-        "t",
-        tagFile,
-        OptionString(fun s -> tcConfigB.AddCompilerToolsByPath s),
-        None,
-        Some(FSComp.SR.optsShortFormOf ("--compilertool"))
-    )
-
 let inputFileFlagsFsc tcConfigB = inputFileFlagsBoth tcConfigB
 
 let inputFileFlagsFsiBase (_tcConfigB: TcConfigBuilder) =
@@ -1395,6 +1374,7 @@ let testFlag tcConfigB =
             | "ContinueAfterParseFailure" -> tcConfigB.continueAfterParseFailure <- true
             | "ParallelOff" -> tcConfigB.concurrentBuild <- false
             | "ParallelCheckingWithSignatureFilesOn" -> tcConfigB.parallelCheckingWithSignatureFiles <- true
+            | "ParallelIlxGen" -> tcConfigB.parallelIlxGen <- true
             | "ParallelOptimization" ->
                 tcConfigB.optSettings <-
                     { tcConfigB.optSettings with
@@ -1747,6 +1727,15 @@ let internalFlags (tcConfigB: TcConfigBuilder) =
             None
         )
 
+        // "Write timing profiles for compilation to a file"
+        CompilerOption(
+            "times",
+            tagFile,
+            OptionString(fun s -> tcConfigB.writeTimesToFile <- Some s),
+            Some(InternalCommandLineOption("times", rangeCmdArgs)),
+            None
+        )
+
 #if !NO_TYPEPROVIDERS
         // "Display information about extension type resolution")
         CompilerOption(
@@ -2301,6 +2290,23 @@ let GetCoreFsiCompilerOptions (tcConfigB: TcConfigBuilder) =
         )
     ]
 
+let CheckAndReportSourceFileDuplicates (sourceFiles: ResizeArray<string>) =
+    let visited = Dictionary.newWithSize (sourceFiles.Count * 2)
+    let count = sourceFiles.Count
+
+    [
+        for i = 0 to (count - 1) do
+            let source = sourceFiles[i]
+
+            match visited.TryGetValue source with
+            | true, duplicatePosition ->
+
+                warning (Error(FSComp.SR.buildDuplicateFile (source, i + 1, count, duplicatePosition + 1, count), range0))
+            | false, _ ->
+                visited.Add(source, i)
+                yield source
+    ]
+
 let ApplyCommandLineArgs (tcConfigB: TcConfigBuilder, sourceFiles: string list, argv) =
     try
         let sourceFilesAcc = ResizeArray sourceFiles
@@ -2310,113 +2316,56 @@ let ApplyCommandLineArgs (tcConfigB: TcConfigBuilder, sourceFiles: string list,
                 sourceFilesAcc.Add name
 
         ParseCompilerOptions(collect, GetCoreServiceCompilerOptions tcConfigB, argv)
-        ResizeArray.toList sourceFilesAcc
+        sourceFilesAcc |> CheckAndReportSourceFileDuplicates
     with e ->
         errorRecovery e range0
         sourceFiles
 
-//----------------------------------------------------------------------------
-// PrintWholeAssemblyImplementation
-//----------------------------------------------------------------------------
-
-let mutable showTermFileCount = 0
-
-let PrintWholeAssemblyImplementation (tcConfig: TcConfig) outfile header expr =
-    if tcConfig.showTerms then
-        if tcConfig.writeTermsToFiles then
-            let fileName = outfile + ".terms"
-
-            use f =
-                FileSystem
-                    .OpenFileForWriteShim(fileName + "-" + string showTermFileCount + "-" + header, FileMode.Create)
-                    .GetWriter()
-
-            showTermFileCount <- showTermFileCount + 1
-            LayoutRender.outL f (Display.squashTo 192 (DebugPrint.implFilesL expr))
-        else
-            dprintf "\n------------------\nshowTerm: %s:\n" header
-            LayoutRender.outL stderr (Display.squashTo 192 (DebugPrint.implFilesL expr))
-            dprintf "\n------------------\n"
-
 //----------------------------------------------------------------------------
 // ReportTime
 //----------------------------------------------------------------------------
 
-let mutable tPrev: (DateTime * DateTime * float * int[]) option = None
-let mutable nPrev: (string * IDisposable) option = None
-
-let ReportTime (tcConfig: TcConfig) descr =
-    match nPrev with
-    | None -> ()
-    | Some (prevDescr, prevActivity) ->
-        use _ = prevActivity // Finish the previous diagnostics activity by .Dispose() at the end of this block
-
-        if tcConfig.pause then
-            dprintf "[done '%s', entering '%s'] press <enter> to continue... " prevDescr descr
-            Console.ReadLine() |> ignore
-        // Intentionally putting this right after the pause so a debugger can be attached.
-        match tcConfig.simulateException with
-        | Some ("fsc-oom") -> raise (OutOfMemoryException())
-        | Some ("fsc-an") -> raise (ArgumentNullException("simulated"))
-        | Some ("fsc-invop") -> raise (InvalidOperationException())
-        | Some ("fsc-av") -> raise (AccessViolationException())
-        | Some ("fsc-aor") -> raise (ArgumentOutOfRangeException())
-        | Some ("fsc-dv0") -> raise (DivideByZeroException())
-        | Some ("fsc-nfn") -> raise (NotFiniteNumberException())
-        | Some ("fsc-oe") -> raise (OverflowException())
-        | Some ("fsc-atmm") -> raise (ArrayTypeMismatchException())
-        | Some ("fsc-bif") -> raise (BadImageFormatException())
-        | Some ("fsc-knf") -> raise (System.Collections.Generic.KeyNotFoundException())
-        | Some ("fsc-ior") -> raise (IndexOutOfRangeException())
-        | Some ("fsc-ic") -> raise (InvalidCastException())
-        | Some ("fsc-ip") -> raise (InvalidProgramException())
-        | Some ("fsc-ma") -> raise (MemberAccessException())
-        | Some ("fsc-ni") -> raise (NotImplementedException())
-        | Some ("fsc-nr") -> raise (NullReferenceException())
-        | Some ("fsc-oc") -> raise (OperationCanceledException())
-        | Some ("fsc-fail") -> failwith "simulated"
-        | _ -> ()
-
-    if (tcConfig.showTimes || verbose) then
-        // Note that timing calls are relatively expensive on the startup path so we don't
-        // make this call unless showTimes has been turned on.
-        let p = Process.GetCurrentProcess()
-        let utNow = p.UserProcessorTime.TotalSeconds
-        let tNow = DateTime.Now
-        let maxGen = GC.MaxGeneration
-        let gcNow = [| for i in 0..maxGen -> GC.CollectionCount i |]
-        let wsNow = p.WorkingSet64 / 1000000L
-
-        let tStart =
-            match tPrev, nPrev with
-            | Some (tStart, tPrev, utPrev, gcPrev), Some (prevDescr, _) ->
-                let spanGC = [| for i in 0..maxGen -> GC.CollectionCount i - gcPrev[i] |]
-                let t = tNow - tStart
-                let tDelta = tNow - tPrev
-                let utDelta = utNow - utPrev
-
-                printf
-                    "Real: %4.1f Realdelta: %4.1f Cpu: %4.1f Cpudelta: %4.1f Mem: %3d"
-                    t.TotalSeconds
-                    tDelta.TotalSeconds
-                    utNow
-                    utDelta
-                    wsNow
-
-                printfn
-                    " G0: %3d G1: %2d G2: %2d [%s]"
-                    spanGC[Operators.min 0 maxGen]
-                    spanGC[Operators.min 1 maxGen]
-                    spanGC[Operators.min 2 maxGen]
-                    prevDescr
-
-                tStart
-
-            | _ -> DateTime.Now
-
-        tPrev <- Some(tStart, tNow, utNow, gcNow)
-
-    nPrev <- Some(descr, Activity.startNoTags descr)
+let private SimulateException simulateConfig =
+    match simulateConfig with
+    | Some ("fsc-oom") -> raise (OutOfMemoryException())
+    | Some ("fsc-an") -> raise (ArgumentNullException("simulated"))
+    | Some ("fsc-invop") -> raise (InvalidOperationException())
+    | Some ("fsc-av") -> raise (AccessViolationException())
+    | Some ("fsc-aor") -> raise (ArgumentOutOfRangeException())
+    | Some ("fsc-dv0") -> raise (DivideByZeroException())
+    | Some ("fsc-nfn") -> raise (NotFiniteNumberException())
+    | Some ("fsc-oe") -> raise (OverflowException())
+    | Some ("fsc-atmm") -> raise (ArrayTypeMismatchException())
+    | Some ("fsc-bif") -> raise (BadImageFormatException())
+    | Some ("fsc-knf") -> raise (System.Collections.Generic.KeyNotFoundException())
+    | Some ("fsc-ior") -> raise (IndexOutOfRangeException())
+    | Some ("fsc-ic") -> raise (InvalidCastException())
+    | Some ("fsc-ip") -> raise (InvalidProgramException())
+    | Some ("fsc-ma") -> raise (MemberAccessException())
+    | Some ("fsc-ni") -> raise (NotImplementedException())
+    | Some ("fsc-nr") -> raise (NullReferenceException())
+    | Some ("fsc-oc") -> raise (OperationCanceledException())
+    | Some ("fsc-fail") -> failwith "simulated"
+    | _ -> ()
+
+let ReportTime =
+    let mutable nPrev = None
+
+    fun (tcConfig: TcConfig) descr ->
+        nPrev
+        |> Option.iter (fun (prevDescr, prevAct) ->
+            use _ = prevAct
+
+            if tcConfig.pause then
+                dprintf "[done '%s', entering '%s'] press <enter> to continue... " prevDescr descr
+                Console.ReadLine() |> ignore
+            // Intentionally putting this right after the pause so a debugger can be attached.
+            SimulateException tcConfig.simulateException)
+
+        if descr <> "Exiting" then
+            nPrev <- Some(descr, Activity.Profiling.startAndMeasureEnvironmentStats descr)
+        else
+            nPrev <- None
 
 let ignoreFailureOnMono1_1_16 f =
     try
diff --git a/src/Compiler/Driver/CompilerOptions.fsi b/src/Compiler/Driver/CompilerOptions.fsi
index 0915d999032..bb2034b93d5 100644
--- a/src/Compiler/Driver/CompilerOptions.fsi
+++ b/src/Compiler/Driver/CompilerOptions.fsi
@@ -36,7 +36,7 @@ and CompilerOption =
         name: string *
         argumentDescriptionString: string *
         actionSpec: OptionSpec *
-        deprecationError: Option<exn> *
+        deprecationError: exn option *
         helpText: string option
 
 and CompilerOptionBlock =
@@ -66,6 +66,8 @@ val GetCoreFsiCompilerOptions: TcConfigBuilder -> CompilerOptionBlock list
 
 val GetCoreServiceCompilerOptions: TcConfigBuilder -> CompilerOptionBlock list
 
+val CheckAndReportSourceFileDuplicates: ResizeArray<string> -> string list
+
 /// Apply args to TcConfigBuilder and return new list of source files
 val ApplyCommandLineArgs: tcConfigB: TcConfigBuilder * sourceFiles: string list * argv: string list -> string list
 
@@ -89,7 +91,7 @@ val DoWithColor: ConsoleColor -> (unit -> 'T) -> 'T
 
 val DoWithDiagnosticColor: FSharpDiagnosticSeverity -> (unit -> 'T) -> 'T
 
-val ReportTime: TcConfig -> string -> unit
+val ReportTime: (TcConfig -> string -> unit)
 
 val GetAbbrevFlagSet: TcConfigBuilder -> bool -> Set<string>
 
diff --git a/src/Compiler/Driver/CreateILModule.fs b/src/Compiler/Driver/CreateILModule.fs
index 7aad1268a74..60c588263e4 100644
--- a/src/Compiler/Driver/CreateILModule.fs
+++ b/src/Compiler/Driver/CreateILModule.fs
@@ -65,7 +65,11 @@ module AttributeHelpers =
 //----------------------------------------------------------------------------
 
 /// Represents the configuration settings used to perform strong-name signing
-type StrongNameSigningInfo = StrongNameSigningInfo of delaysign: bool * publicsign: bool * signer: string option * container: string option
+type StrongNameSigningInfo =
+    | StrongNameSigningInfo of delaysign: bool * publicsign: bool * signer: byte array option * container: string option
+
+let GetStrongNameSigningInfo (delaysign, publicsign, signer, container) =
+    StrongNameSigningInfo(delaysign, publicsign, signer, container)
 
 /// Validate the attributes and configuration settings used to perform strong-name signing
 let ValidateKeySigningAttributes (tcConfig: TcConfig, tcGlobals, topAttrs) =
@@ -91,14 +95,24 @@ let ValidateKeySigningAttributes (tcConfig: TcConfig, tcGlobals, topAttrs) =
 
     // if signer is set via an attribute, validate that it wasn't set via an option
     let signer =
-        match signerAttrib with
-        | Some signer ->
-            if tcConfig.signer.IsSome && tcConfig.signer <> Some signer then
-                warning (Error(FSComp.SR.fscKeyFileWarning (), rangeCmdArgs))
-                tcConfig.signer
-            else
-                Some signer
-        | None -> tcConfig.signer
+        let signerFile =
+            match signerAttrib with
+            | Some signer ->
+                if tcConfig.signer.IsSome && tcConfig.signer <> Some signer then
+                    warning (Error(FSComp.SR.fscKeyFileWarning (), rangeCmdArgs))
+                    tcConfig.signer
+                else
+                    Some signer
+            | None -> tcConfig.signer
+
+        match signerFile with
+        | Some signerPath ->
+            try
+                Some(FileSystem.OpenFileForReadShim(signerPath).ReadAllBytes())
+            with _ ->
+                // Note :: don't use errorR here since we really want to fail and not produce a binary
+                error (Error(FSComp.SR.fscKeyFileCouldNotBeOpened signerPath, rangeCmdArgs))
+        | None -> None
 
     // if container is set via an attribute, validate that it wasn't set via an option, and that they keyfile wasn't set
     // if keyfile was set, use that instead (silently)
@@ -127,15 +141,11 @@ let GetStrongNameSigner signingInfo =
     | None ->
         match signer with
         | None -> None
-        | Some s ->
-            try
-                if publicsign || delaysign then
-                    Some(ILStrongNameSigner.OpenPublicKeyOptions s publicsign)
-                else
-                    Some(ILStrongNameSigner.OpenKeyPairFile s)
-            with _ ->
-                // Note :: don't use errorR here since we really want to fail and not produce a binary
-                error (Error(FSComp.SR.fscKeyFileCouldNotBeOpened s, rangeCmdArgs))
+        | Some bytes ->
+            if publicsign || delaysign then
+                Some(ILStrongNameSigner.OpenPublicKeyOptions bytes publicsign)
+            else
+                Some(ILStrongNameSigner.OpenKeyPairFile bytes)
 
 //----------------------------------------------------------------------------
 // Building the contents of the finalized IL module
diff --git a/src/Compiler/Driver/CreateILModule.fsi b/src/Compiler/Driver/CreateILModule.fsi
index eba0ab0251e..8290b90086d 100644
--- a/src/Compiler/Driver/CreateILModule.fsi
+++ b/src/Compiler/Driver/CreateILModule.fsi
@@ -15,6 +15,10 @@ open FSharp.Compiler.TypedTree
 /// Represents the configuration settings used to perform strong-name signing
 type StrongNameSigningInfo
 
+/// Get the SigningInfo for specific values(delaysign, tcConfig.publicsign, signer, container)
+val GetStrongNameSigningInfo:
+    delaysign: bool * publicsign: bool * signer: byte array option * container: string option -> StrongNameSigningInfo
+
 /// Validate the attributes and configuration settings used to perform strong-name signing
 val ValidateKeySigningAttributes: tcConfig: TcConfig * tcGlobals: TcGlobals * TopAttribs -> StrongNameSigningInfo
 
diff --git a/src/Compiler/Driver/FxResolver.fs b/src/Compiler/Driver/FxResolver.fs
index ce2474a7085..a9ddac4a7ad 100644
--- a/src/Compiler/Driver/FxResolver.fs
+++ b/src/Compiler/Driver/FxResolver.fs
@@ -382,16 +382,16 @@ type internal FxResolver
 
     let tryGetNetCoreRefsPackDirectoryRoot () = tryNetCoreRefsPackDirectoryRoot.Force()
 
+    let getTfmNumber (v: string) =
+        let arr = v.Split([| '.' |], 3)
+        arr[0] + "." + arr[1]
+
     // Tries to figure out the tfm for the compiler instance.
     // On coreclr it uses the deps.json file
     //
     // On-demand because (a) some FxResolver are ephemeral (b) we want to avoid recomputation
-    let tryGetRunningTfm =
+    let tryGetRunningTfm () =
         let runningTfmOpt =
-            let getTfmNumber (v: string) =
-                let arr = v.Split([| '.' |], 3)
-                arr[0] + "." + arr[1]
-
             // Compute TFM from System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription
             // System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription;;
             // val it: string = ".NET 6.0.7"
@@ -548,6 +548,24 @@ type internal FxResolver
         assemblyReferences |> List.iter traverseDependencies
         assemblies
 
+    let tryGetTfmFromSdkDir (sdkDir: string) =
+        let dotnetConfigFile = Path.Combine(sdkDir, "dotnet.runtimeconfig.json")
+
+        try
+            use stream = FileSystem.OpenFileForReadShim(dotnetConfigFile)
+            let dotnetConfig = stream.ReadAllText()
+            let pattern = "\"tfm\": \""
+
+            let startPos =
+                dotnetConfig.IndexOf(pattern, StringComparison.OrdinalIgnoreCase)
+                + pattern.Length
+
+            let endPos = dotnetConfig.IndexOf("\"", startPos)
+            let tfm = dotnetConfig[startPos .. endPos - 1]
+            tfm
+        with _ ->
+            tryGetRunningTfm ()
+
     // This list is the default set of references for "non-project" files.
     //
     // These DLLs are
@@ -799,12 +817,37 @@ type internal FxResolver
             RequireFxResolverLock(fxtok, "assuming all member require lock")
             tryGetSdkDir () |> replayWarnings)
 
-    /// Gets the selected target framework moniker, e.g netcore3.0, net472, and the running rid of the current machine
+    /// Gets
+    ///    1. The Target Framework Moniker (TFM) used for scripting (e.g netcore3.0, net472)
+    ///    2. The running RID of the current machine (e.g. win-x64)
+    ///
+    /// When analyzing scripts for editing, this is **not** necessarily the running TFM. Rather, it is the TFM to use for analysing
+    /// a script.
+    ///
+    /// Summary:
+    /// - When running scripts (isInteractive = true) this is identical to the running TFM.
+    ///
+    /// - When analyzing .NET Core scripts (isInteractive = false, tryGetSdkDir is Some),
+    ///   the scripting TFM is determined from dotnet.runtimeconfig.json in the SDK directory
+    ///
+    /// - Otherwise, the running TFM is used. That is, if editing with .NET Framework/Core-based tooling a script is assumed
+    ///   to be .NET Framework/Core respectively.
+    ///
+    /// The RID returned is always the RID of the running machine.
     member _.GetTfmAndRid() =
         fxlock.AcquireLock(fun fxtok ->
             RequireFxResolverLock(fxtok, "assuming all member require lock")
 
-            let runningTfm = tryGetRunningTfm
+            // Interactive processes read their own configuration to find the running tfm
+            let targetTfm =
+                if isInteractive then
+                    tryGetRunningTfm ()
+                else
+                    let sdkDir = tryGetSdkDir () |> replayWarnings
+
+                    match sdkDir with
+                    | Some dir -> tryGetTfmFromSdkDir dir
+                    | None -> tryGetRunningTfm ()
 
             // Coreclr has mechanism for getting rid
             //      System.Runtime.InteropServices.RuntimeInformation.RuntimeIdentifier
@@ -855,7 +898,7 @@ type internal FxResolver
                     | Architecture.Arm64 -> baseRid + "-arm64"
                     | _ -> baseRid + "-arm"
 
-            runningTfm, runningRid)
+            targetTfm, runningRid)
 
     static member ClearStaticCaches() =
         desiredDotNetSdkVersionForDirectoryCache.Clear()
@@ -878,7 +921,7 @@ type internal FxResolver
             let defaultReferences =
                 if assumeDotNetFramework then
                     getDotNetFrameworkDefaultReferences useFsiAuxLib, assumeDotNetFramework
-                else if useSdkRefs then
+                elif useSdkRefs then
                     // Go fetch references
                     let sdkDir = tryGetSdkRefsPackDirectory () |> replayWarnings
 
diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index fb960dcbcc7..9baa8b4a96e 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -522,6 +522,7 @@ let GenerateIlxCode
             isInteractive = tcConfig.isInteractive
             isInteractiveItExpr = isInteractiveItExpr
             alwaysCallVirt = tcConfig.alwaysCallVirt
+            parallelIlxGenEnabled = tcConfig.parallelIlxGen && not (tcConfig.deterministic)
         }
 
     ilxGenerator.GenerateCode(ilxGenOpts, optimizedImpls, topAttrs.assemblyAttrs, topAttrs.netModuleAttrs)
diff --git a/src/Compiler/Driver/ParseAndCheckInputs.fs b/src/Compiler/Driver/ParseAndCheckInputs.fs
index ac36b76477c..45fb1ab34f7 100644
--- a/src/Compiler/Driver/ParseAndCheckInputs.fs
+++ b/src/Compiler/Driver/ParseAndCheckInputs.fs
@@ -413,7 +413,8 @@ let ParseInput
         lexbuf: UnicodeLexing.Lexbuf,
         defaultNamespace,
         fileName,
-        isLastCompiland
+        isLastCompiland,
+        identCapture
     ) =
     // The assert below is almost ok, but it fires in two cases:
     //  - fsi.exe sometimes passes "stdin" as a dummy file name
@@ -433,25 +434,29 @@ let ParseInput
         let input =
             let identStore = HashSet<string>()
 
-            let identCaptureLexer x =
-                let token = lexer x
-
-                match token with
-                | Parser.token.PERCENT_OP ident
-                | Parser.token.FUNKY_OPERATOR_NAME ident
-                | Parser.token.ADJACENT_PREFIX_OP ident
-                | Parser.token.PLUS_MINUS_OP ident
-                | Parser.token.INFIX_AMP_OP ident
-                | Parser.token.INFIX_STAR_DIV_MOD_OP ident
-                | Parser.token.PREFIX_OP ident
-                | Parser.token.INFIX_BAR_OP ident
-                | Parser.token.INFIX_AT_HAT_OP ident
-                | Parser.token.INFIX_COMPARE_OP ident
-                | Parser.token.INFIX_STAR_STAR_OP ident
-                | Parser.token.IDENT ident -> identStore.Add ident |> ignore
-                | _ -> ()
-
-                token
+            let lexer =
+                if identCapture then
+                    (fun x ->
+                        let token = lexer x
+
+                        match token with
+                        | Parser.token.PERCENT_OP ident
+                        | Parser.token.FUNKY_OPERATOR_NAME ident
+                        | Parser.token.ADJACENT_PREFIX_OP ident
+                        | Parser.token.PLUS_MINUS_OP ident
+                        | Parser.token.INFIX_AMP_OP ident
+                        | Parser.token.INFIX_STAR_DIV_MOD_OP ident
+                        | Parser.token.PREFIX_OP ident
+                        | Parser.token.INFIX_BAR_OP ident
+                        | Parser.token.INFIX_AT_HAT_OP ident
+                        | Parser.token.INFIX_COMPARE_OP ident
+                        | Parser.token.INFIX_STAR_STAR_OP ident
+                        | Parser.token.IDENT ident -> identStore.Add ident |> ignore
+                        | _ -> ()
+
+                        token)
+                else
+                    lexer
 
             if FSharpMLCompatFileSuffixes |> List.exists (FileSystemUtils.checkSuffix fileName) then
                 if lexbuf.SupportsFeature LanguageFeature.MLCompatRevisions then
@@ -461,14 +466,14 @@ let ParseInput
 
             // Call the appropriate parser - for signature files or implementation files
             if FSharpImplFileSuffixes |> List.exists (FileSystemUtils.checkSuffix fileName) then
-                let impl = Parser.implementationFile identCaptureLexer lexbuf
+                let impl = Parser.implementationFile lexer lexbuf
 
                 let tripleSlashComments =
                     LexbufLocalXmlDocStore.ReportInvalidXmlDocPositions(lexbuf)
 
                 PostParseModuleImpls(defaultNamespace, fileName, isLastCompiland, impl, lexbuf, tripleSlashComments, Set identStore)
             elif FSharpSigFileSuffixes |> List.exists (FileSystemUtils.checkSuffix fileName) then
-                let intfs = Parser.signatureFile identCaptureLexer lexbuf
+                let intfs = Parser.signatureFile lexer lexbuf
 
                 let tripleSlashComments =
                     LexbufLocalXmlDocStore.ReportInvalidXmlDocPositions(lexbuf)
@@ -640,7 +645,8 @@ let ParseOneInputLexbuf (tcConfig: TcConfig, lexResourceManager, lexbuf, fileNam
                         lexbuf,
                         None,
                         fileName,
-                        isLastCompiland
+                        isLastCompiland,
+                        tcConfig.captureIdentifiersWhenParsing
                     )
 
                 // Report the statistics for testing purposes
@@ -1205,7 +1211,7 @@ let CheckOneInputAux
     cancellable {
         try
             use _ =
-                Activity.start "ParseAndCheckInputs.CheckOneInput" [| "fileName", inp.FileName |]
+                Activity.start "ParseAndCheckInputs.CheckOneInput" [| Activity.Tags.fileName, inp.FileName |]
 
             CheckSimulateException tcConfig
 
diff --git a/src/Compiler/Driver/ParseAndCheckInputs.fsi b/src/Compiler/Driver/ParseAndCheckInputs.fsi
index 166191d363e..13ed6801ad2 100644
--- a/src/Compiler/Driver/ParseAndCheckInputs.fsi
+++ b/src/Compiler/Driver/ParseAndCheckInputs.fsi
@@ -39,7 +39,8 @@ val ParseInput:
     lexbuf: Lexbuf *
     defaultNamespace: string option *
     fileName: string *
-    isLastCompiland: (bool * bool) ->
+    isLastCompiland: (bool * bool) *
+    identCapture: bool ->
         ParsedInput
 
 /// A general routine to process hash directives
diff --git a/src/Compiler/Driver/StaticLinking.fs b/src/Compiler/Driver/StaticLinking.fs
index 17bc4882768..972f55fc70c 100644
--- a/src/Compiler/Driver/StaticLinking.fs
+++ b/src/Compiler/Driver/StaticLinking.fs
@@ -98,7 +98,7 @@ type TypeForwarding(tcImports: TcImports) =
 
     member _.TypeForwardILTypeRef tref = typeForwardILTypeRef tref
 
-let debugStaticLinking = condition "FSHARP_DEBUG_STATIC_LINKING"
+let debugStaticLinking = isEnvVarSet "FSHARP_DEBUG_STATIC_LINKING"
 
 let StaticLinkILModules
     (
diff --git a/src/Compiler/Driver/fsc.fs b/src/Compiler/Driver/fsc.fs
index e8ec56fa5a5..d59676d082e 100644
--- a/src/Compiler/Driver/fsc.fs
+++ b/src/Compiler/Driver/fsc.fs
@@ -536,6 +536,7 @@ let main1
         // Rather than start processing, just collect names, then process them.
         try
             let files = ProcessCommandLineFlags(tcConfigB, lcidFromCodePage, argv)
+            let files = CheckAndReportSourceFileDuplicates(ResizeArray.ofList files)
             AdjustForScriptCompile(tcConfigB, files, lexResourceManager, dependencyProvider)
         with e ->
             errorRecovery e rangeStartup
@@ -576,6 +577,20 @@ let main1
             delayForFlagsLogger.CommitDelayedDiagnostics(diagnosticsLoggerProvider, tcConfigB, exiter)
             exiter.Exit 1
 
+    if tcConfig.showTimes then
+        Activity.Profiling.addConsoleListener () |> disposables.Register
+
+    tcConfig.writeTimesToFile
+    |> Option.iter (fun f ->
+        Activity.CsvExport.addCsvFileListener f |> disposables.Register
+
+        Activity.start
+            "FSC compilation"
+            [
+                Activity.Tags.project, tcConfig.outputFile |> Option.defaultValue String.Empty
+            ]
+        |> disposables.Register)
+
     let diagnosticsLogger = diagnosticsLoggerProvider.CreateLogger(tcConfigB, exiter)
 
     // Install the global error logger and never remove it. This logger does have all command-line flags considered.
@@ -588,7 +603,7 @@ let main1
         AbortOnError(diagnosticsLogger, exiter)
 
     // Resolve assemblies
-    ReportTime tcConfig "Import mscorlib and FSharp.Core.dll"
+    ReportTime tcConfig "Import mscorlib+FSharp.Core"
     let foundationalTcConfigP = TcConfigProvider.Constant tcConfig
 
     let sysRes, otherRes, knownUnresolved =
@@ -762,7 +777,7 @@ let main2
     if tcConfig.printSignature || tcConfig.printAllSignatureFiles then
         InterfaceFileWriter.WriteInterfaceFile(tcGlobals, tcConfig, InfoReader(tcGlobals, tcImports.GetImportMap()), typedImplFiles)
 
-    ReportTime tcConfig "Write XML document signatures"
+    ReportTime tcConfig "Write XML doc signatures"
 
     if tcConfig.xmlDocOutputFile.IsSome then
         XmlDocWriter.ComputeXmlDocSigs(tcGlobals, generatedCcu)
@@ -1087,7 +1102,6 @@ let main6
                             pdbfile = None
                             emitTailcalls = tcConfig.emitTailcalls
                             deterministic = tcConfig.deterministic
-                            showTimes = tcConfig.showTimes
                             portablePDB = false
                             embeddedPDB = false
                             embedAllSource = tcConfig.embedAllSource
@@ -1118,7 +1132,6 @@ let main6
                             pdbfile = pdbfile
                             emitTailcalls = tcConfig.emitTailcalls
                             deterministic = tcConfig.deterministic
-                            showTimes = tcConfig.showTimes
                             portablePDB = tcConfig.portablePDB
                             embeddedPDB = tcConfig.embeddedPDB
                             embedAllSource = tcConfig.embedAllSource
diff --git a/src/Compiler/FSComp.txt b/src/Compiler/FSComp.txt
index 1c3623d2a1f..46379fc0eb4 100644
--- a/src/Compiler/FSComp.txt
+++ b/src/Compiler/FSComp.txt
@@ -1558,6 +1558,9 @@ featureLowercaseDUWhenRequireQualifiedAccess,"Allow lowercase DU when RequireQua
 featureMatchNotAllowedForUnionCaseWithNoData,"Pattern match discard is not allowed for union case that takes no data."
 featureCSharpExtensionAttributeNotRequired,"Allow implicit Extension attribute on declaring types, modules"
 featureErrorForNonVirtualMembersOverrides,"Raises errors for non-virtual members overrides"
+featureWarningWhenInliningMethodImplNoInlineMarkedFunction,"Raises warnings when 'let inline ... =' is used together with [<MethodImpl(MethodImplOptions.NoInlining)>] attribute. Function is not getting inlined."
+featureArithmeticInLiterals,"Allow arithmetic and logical operations in literals"
+featureErrorReportingOnStaticClasses,"Error reporting on static classes"
 3353,fsiInvalidDirective,"Invalid directive '#%s %s'"
 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."
@@ -1661,3 +1664,12 @@ reprStateMachineInvalidForm,"The state machine has an unexpected form"
 3548,matchNotAllowedForUnionCaseWithNoData,"Pattern discard is not allowed for union case that takes no data."
 3549,tcSynTypeOrInvalidInDeclaration,"SynType.Or is not permitted in this declaration"
 3550,chkDuplicatedMethodParameter,"Duplicate parameter. The parameter '%s' has been used more that once in this method."
+featureEscapeBracesInFormattableString,"Escapes curly braces before calling FormattableStringFactory.Create when interpolated string literal is typed as FormattableString"
+3551,buildDuplicateFile,"The source file '%s' (at position %d/%d) already appeared in the compilation list (at position %d/%d). Please verify that it is included only once in the project file."
+3552,chkConstructorWithArgumentsOnStaticClasses,"If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Constructor with arguments is not allowed."
+3553,chkAdditionalConstructorOnStaticClasses,"If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Additional constructor is not allowed."
+3554,chkInstanceMemberOnStaticClasses,"If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Instance members are not allowed."
+3555,chkInstanceLetBindingOnStaticClasses,"If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Instance let bindings are not allowed."
+3556,chkImplementingInterfacesOnStaticClasses,"If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Implementing interfaces is not allowed."
+3557,chkAbstractMembersDeclarationsOnStaticClasses,"If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Abstract member declarations are not allowed."
+3558,chkExplicitFieldsDeclarationsOnStaticClasses,"If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Explicit field declarations are not allowed."
\ No newline at end of file
diff --git a/src/Compiler/FSharp.Compiler.Service.fsproj b/src/Compiler/FSharp.Compiler.Service.fsproj
index 149f320b423..9ad8af1ee5c 100644
--- a/src/Compiler/FSharp.Compiler.Service.fsproj
+++ b/src/Compiler/FSharp.Compiler.Service.fsproj
@@ -80,6 +80,7 @@
     <InternalsVisibleTo Include="LanguageServiceProfiling" />
     <InternalsVisibleTo Include="FSharp.Compiler.Benchmarks" />
     <InternalsVisibleTo Include="HistoricalBenchmark" />
+    <InternalsVisibleTo Include="FSharp.Test.Utilities" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/Compiler/Facilities/CompilerLocation.fs b/src/Compiler/Facilities/CompilerLocation.fs
index 24141252ee8..9531acb2cae 100644
--- a/src/Compiler/Facilities/CompilerLocation.fs
+++ b/src/Compiler/Facilities/CompilerLocation.fs
@@ -48,11 +48,6 @@ module internal FSharpEnvironment =
         let ofString s =
             if String.IsNullOrEmpty(s) then None else Some(s)
 
-    // MaxPath accounts for the null-terminating character, for example, the maximum path on the D drive is "D:\<256 chars>\0".
-    // See: ndp\clr\src\BCL\System\IO\Path.cs
-    let maxPath = 260
-    let maxDataLength = (System.Text.UTF32Encoding()).GetMaxByteCount(maxPath)
-
     let internal tryCurrentDomain () =
         let pathFromCurrentDomain = AppDomain.CurrentDomain.BaseDirectory
 
diff --git a/src/Compiler/Facilities/LanguageFeatures.fs b/src/Compiler/Facilities/LanguageFeatures.fs
index 14302b05132..e7654bea422 100644
--- a/src/Compiler/Facilities/LanguageFeatures.fs
+++ b/src/Compiler/Facilities/LanguageFeatures.fs
@@ -57,7 +57,11 @@ type LanguageFeature =
     | MatchNotAllowedForUnionCaseWithNoData
     | CSharpExtensionAttributeNotRequired
     | ErrorForNonVirtualMembersOverrides
-
+    | WarningWhenInliningMethodImplNoInlineMarkedFunction
+    | EscapeDotnetFormattableStrings
+    | ArithmeticInLiterals
+    | ErrorReportingOnStaticClasses
+ 
 /// LanguageVersion management
 type LanguageVersion(versionText) =
 
@@ -130,6 +134,10 @@ type LanguageVersion(versionText) =
                 LanguageFeature.MatchNotAllowedForUnionCaseWithNoData, previewVersion
                 LanguageFeature.CSharpExtensionAttributeNotRequired, previewVersion
                 LanguageFeature.ErrorForNonVirtualMembersOverrides, previewVersion
+                LanguageFeature.WarningWhenInliningMethodImplNoInlineMarkedFunction, previewVersion
+                LanguageFeature.EscapeDotnetFormattableStrings, previewVersion
+                LanguageFeature.ArithmeticInLiterals, previewVersion
+                LanguageFeature.ErrorReportingOnStaticClasses, previewVersion
 
             ]
 
@@ -240,6 +248,10 @@ type LanguageVersion(versionText) =
         | LanguageFeature.MatchNotAllowedForUnionCaseWithNoData -> FSComp.SR.featureMatchNotAllowedForUnionCaseWithNoData ()
         | LanguageFeature.CSharpExtensionAttributeNotRequired -> FSComp.SR.featureCSharpExtensionAttributeNotRequired  ()
         | LanguageFeature.ErrorForNonVirtualMembersOverrides -> FSComp.SR.featureErrorForNonVirtualMembersOverrides  ()
+        | LanguageFeature.WarningWhenInliningMethodImplNoInlineMarkedFunction -> FSComp.SR.featureWarningWhenInliningMethodImplNoInlineMarkedFunction ()
+        | LanguageFeature.EscapeDotnetFormattableStrings -> FSComp.SR.featureEscapeBracesInFormattableString ()
+        | LanguageFeature.ArithmeticInLiterals -> FSComp.SR.featureArithmeticInLiterals ()
+        | LanguageFeature.ErrorReportingOnStaticClasses -> FSComp.SR.featureErrorReportingOnStaticClasses ()
 
     /// Get a version string associated with the given feature.
     static member GetFeatureVersionString feature =
diff --git a/src/Compiler/Facilities/LanguageFeatures.fsi b/src/Compiler/Facilities/LanguageFeatures.fsi
index f471f371b95..d070a8b4e36 100644
--- a/src/Compiler/Facilities/LanguageFeatures.fsi
+++ b/src/Compiler/Facilities/LanguageFeatures.fsi
@@ -47,6 +47,10 @@ type LanguageFeature =
     | MatchNotAllowedForUnionCaseWithNoData
     | CSharpExtensionAttributeNotRequired
     | ErrorForNonVirtualMembersOverrides
+    | WarningWhenInliningMethodImplNoInlineMarkedFunction
+    | EscapeDotnetFormattableStrings
+    | ArithmeticInLiterals
+    | ErrorReportingOnStaticClasses
 
 /// LanguageVersion management
 type LanguageVersion =
diff --git a/src/Compiler/Interactive/FSIstrings.txt b/src/Compiler/Interactive/FSIstrings.txt
index 2d41ffcc406..c357f835be5 100644
--- a/src/Compiler/Interactive/FSIstrings.txt
+++ b/src/Compiler/Interactive/FSIstrings.txt
@@ -56,6 +56,4 @@ shadowCopyReferences,"Prevents references from being locked by the F# Interactiv
 fsiOperationCouldNotBeCompleted,"Operation could not be completed due to earlier error"
 fsiOperationFailed,"Operation failed. The error text has been printed in the error stream. To return the corresponding FSharpDiagnostic use the EvalInteractionNonThrowing, EvalScriptNonThrowing or EvalExpressionNonThrowing"
 fsiMultiAssemblyEmitOption,"Emit multiple assemblies (on by default)"
-fsiMultiAssemblyEmitOptionOffByDefault,"Emit multiple assemblies (off by default for .NET Framework)"
-2303,fsiInternalAccess,"Accessing the internal type, method or field '%s' from a previous evaluation in F# Interactive is deprecated and may cause subsequent access errors. To enable the legacy generation of a single dynamic assembly that can access internals, use the '--multiemit-' option."
 2304,fsiEntryPointWontBeInvoked,"Functions with [<EntryPoint>] are not invoked in FSI. '%s' was not invoked. Execute '%s <args>' in order to invoke '%s' with the appropriate string array of command line arguments."
diff --git a/src/Compiler/Interactive/fsi.fs b/src/Compiler/Interactive/fsi.fs
index 0485d4e06e5..30a55989edf 100644
--- a/src/Compiler/Interactive/fsi.fs
+++ b/src/Compiler/Interactive/fsi.fs
@@ -41,6 +41,7 @@ open FSharp.Compiler.CompilerConfig
 open FSharp.Compiler.CompilerDiagnostics
 open FSharp.Compiler.CompilerImports
 open FSharp.Compiler.CompilerGlobalState
+open FSharp.Compiler.CreateILModule
 open FSharp.Compiler.DependencyManager
 open FSharp.Compiler.Diagnostics
 open FSharp.Compiler.EditorServices
@@ -938,31 +939,22 @@ type internal FsiCommandLineOptions(fsi: FsiEvaluationSessionHostConfig,
       ]
 
     /// These options follow the FsiCoreCompilerOptions in the help blocks
-    let fsiUsageSuffix tcConfigB =
-      [PublicOptions(FSComp.SR.optsHelpBannerInputFiles(),
-        [CompilerOption("--","", OptionRest recordExplicitArg, None,
-                                 Some (FSIstrings.SR.fsiRemaining()));
-        ]);
-       PublicOptions(FSComp.SR.optsHelpBannerMisc(),
-        [   CompilerOption("help", tagNone,
-                                 OptionConsoleOnly (displayHelpFsi tcConfigB), None, Some (FSIstrings.SR.fsiHelp()))
-        ]);
-       PrivateOptions(
-        [   CompilerOption("?", tagNone, OptionConsoleOnly (displayHelpFsi tcConfigB), None, None); // "Short form of --help");
+    let fsiUsageSuffix tcConfigB = [
+        PublicOptions(FSComp.SR.optsHelpBannerInputFiles(), [CompilerOption("--","", OptionRest recordExplicitArg, None, Some (FSIstrings.SR.fsiRemaining())); ]);
+        PublicOptions(FSComp.SR.optsHelpBannerMisc(), [ CompilerOption("help", tagNone, OptionConsoleOnly (displayHelpFsi tcConfigB), None, Some (FSIstrings.SR.fsiHelp())) ]);
+        PrivateOptions([
+            CompilerOption("?", tagNone, OptionConsoleOnly (displayHelpFsi tcConfigB), None, None); // "Short form of --help");
             CompilerOption("help", tagNone, OptionConsoleOnly (displayHelpFsi tcConfigB), None, None); // "Short form of --help");
             CompilerOption("full-help", tagNone, OptionConsoleOnly (displayHelpFsi tcConfigB), None, None); // "Short form of --help");
         ]);
-       PublicOptions(FSComp.SR.optsHelpBannerAdvanced(),
-        [CompilerOption("exec",                 "", OptionUnit (fun () -> interact <- false), None, Some (FSIstrings.SR.fsiExec()))
-         CompilerOption("gui",                  tagNone, OptionSwitch(fun flag -> gui <- (flag = OptionSwitch.On)),None,Some (FSIstrings.SR.fsiGui()))
-         CompilerOption("quiet",                "", OptionUnit (fun () -> tcConfigB.noFeedback <- true), None,Some (FSIstrings.SR.fsiQuiet()));
-         CompilerOption("readline",             tagNone, OptionSwitch(fun flag -> enableConsoleKeyProcessing <- (flag = OptionSwitch.On)),           None, Some(FSIstrings.SR.fsiReadline()))
-         CompilerOption("quotations-debug",     tagNone, OptionSwitch(fun switch -> tcConfigB.emitDebugInfoInQuotations <- switch = OptionSwitch.On),None, Some(FSIstrings.SR.fsiEmitDebugInfoInQuotations()))
-         CompilerOption("shadowcopyreferences", tagNone, OptionSwitch(fun flag -> tcConfigB.shadowCopyReferences <- flag = OptionSwitch.On),         None, Some(FSIstrings.SR.shadowCopyReferences()))
-         if FSharpEnvironment.isRunningOnCoreClr then
-             CompilerOption("multiemit", tagNone, OptionSwitch(fun flag -> tcConfigB.fsiMultiAssemblyEmit <- flag = OptionSwitch.On),         None, Some(FSIstrings.SR.fsiMultiAssemblyEmitOption()))
-         else
-            CompilerOption("multiemit", tagNone, OptionSwitch(fun flag -> tcConfigB.fsiMultiAssemblyEmit <- flag = OptionSwitch.On),         None, Some(FSIstrings.SR.fsiMultiAssemblyEmitOptionOffByDefault()))
+        PublicOptions(FSComp.SR.optsHelpBannerAdvanced(), [
+            CompilerOption("exec",                 "", OptionUnit (fun () -> interact <- false), None, Some (FSIstrings.SR.fsiExec()))
+            CompilerOption("gui",                  tagNone, OptionSwitch(fun flag -> gui <- (flag = OptionSwitch.On)),None,Some (FSIstrings.SR.fsiGui()))
+            CompilerOption("quiet",                "", OptionUnit (fun () -> tcConfigB.noFeedback <- true), None,Some (FSIstrings.SR.fsiQuiet()));
+            CompilerOption("readline",             tagNone, OptionSwitch(fun flag -> enableConsoleKeyProcessing <- (flag = OptionSwitch.On)),           None, Some(FSIstrings.SR.fsiReadline()))
+            CompilerOption("quotations-debug",     tagNone, OptionSwitch(fun switch -> tcConfigB.emitDebugInfoInQuotations <- switch = OptionSwitch.On),None, Some(FSIstrings.SR.fsiEmitDebugInfoInQuotations()))
+            CompilerOption("shadowcopyreferences", tagNone, OptionSwitch(fun flag -> tcConfigB.shadowCopyReferences <- flag = OptionSwitch.On),         None, Some(FSIstrings.SR.shadowCopyReferences()))
+            CompilerOption("multiemit", tagNone, OptionSwitch(fun flag -> tcConfigB.fsiMultiAssemblyEmit <- flag = OptionSwitch.On),                    None, Some(FSIstrings.SR.fsiMultiAssemblyEmitOption()))
         ]);
       ]
 
@@ -1360,14 +1352,12 @@ type internal FsiDynamicCompiler(
 
     let dynamicCcuName = "FSI-ASSEMBLY"
 
-    let maxInternalsVisibleTo = 30 // In multi-assembly emit, how many future interactions can access internals with a warning
-
     let valueBoundEvent = Control.Event<_>()
 
     let mutable fragmentId = 0
-
     static let mutable dynamicAssemblyId = 0
-    
+    static let maxVersion = int Int16.MaxValue
+
     let mutable prevIt : ValRef option = None
 
     let dynamicAssemblies = ResizeArray<Assembly>()
@@ -1390,8 +1380,6 @@ type internal FsiDynamicCompiler(
 
     let rangeStdin0 = rangeN stdinMockFileName 0
 
-    //let _writer = moduleBuilder.GetSymWriter()
-
     let infoReader = InfoReader(tcGlobals,tcImports.GetImportMap())
 
     let reportedAssemblies = Dictionary<string, DateTime>()
@@ -1406,43 +1394,28 @@ type internal FsiDynamicCompiler(
                  Some { man with  CustomAttrsStored = storeILCustomAttrs (mkILCustomAttrs codegenResults.ilAssemAttrs) }) }
 
     /// Generate one assembly using multi-assembly emit
-    let EmitInMemoryAssembly (tcConfig: TcConfig, emEnv: ILMultiInMemoryAssemblyEmitEnv, ilxMainModule: ILModuleDef, m) =
-        
-        // The name of the assembly is "FSI-ASSEMBLY1" etc
-        dynamicAssemblyId <- dynamicAssemblyId + 1
-
-        let multiAssemblyName = ilxMainModule.ManifestOfAssembly.Name + string dynamicAssemblyId
+    let EmitInMemoryAssembly (tcConfig: TcConfig, emEnv: ILMultiInMemoryAssemblyEmitEnv, ilxMainModule: ILModuleDef) =
+        let multiAssemblyName = ilxMainModule.ManifestOfAssembly.Name
 
         // Adjust the assembly name of this fragment, and add InternalsVisibleTo attributes to 
-        // allow internals access by multiple future assemblies
+        // allow internals access by all future assemblies with the same name (and only differing in version)
         let manifest =
             let manifest = ilxMainModule.Manifest.Value
-            let attrs =
-                [ for i in 1..maxInternalsVisibleTo do
-                    let fwdAssemblyName = ilxMainModule.ManifestOfAssembly.Name + string (dynamicAssemblyId + i)
-                    tcGlobals.MakeInternalsVisibleToAttribute(fwdAssemblyName)
-                    yield! manifest.CustomAttrs.AsList() ]
+            let attrs = [
+                tcGlobals.MakeInternalsVisibleToAttribute(ilxMainModule.ManifestOfAssembly.Name)
+                yield! manifest.CustomAttrs.AsList()
+                ]
             { manifest with 
-                Name = multiAssemblyName 
+                Name = multiAssemblyName
+                // Because the coreclr loader will not load a higher assembly make versions go downwards
+                Version = Some (parseILVersion $"0.0.0.{maxVersion - dynamicAssemblyId}")
                 CustomAttrsStored = storeILCustomAttrs (mkILCustomAttrs attrs)
             }
 
-        let ilxMainModule = { ilxMainModule with Manifest = Some manifest }
-
-        // Check access of internals across fragments and give warning
-        let refs = computeILRefs ilGlobals ilxMainModule
+        // The name of the assembly is "FSI-ASSEMBLY" for all submissions. This number is used for the Version 
+        dynamicAssemblyId <- (dynamicAssemblyId + 1) % maxVersion
 
-        for tref in refs.TypeReferences do
-            if emEnv.IsLocalInternalType(tref) then
-                warning(Error((FSIstrings.SR.fsiInternalAccess(tref.FullName)), m))
-
-        for mref in refs.MethodReferences do
-            if emEnv.IsLocalInternalMethod(mref) then
-                warning(Error((FSIstrings.SR.fsiInternalAccess(mref.Name)), m))
-
-        for fref in refs.FieldReferences do
-            if emEnv.IsLocalInternalField(fref) then
-                warning(Error((FSIstrings.SR.fsiInternalAccess(fref.Name)), m))
+        let ilxMainModule = { ilxMainModule with Manifest = Some manifest }
 
         // Rewrite references to local types to their respective dynamic assemblies
         let ilxMainModule =
@@ -1457,8 +1430,7 @@ type internal FsiDynamicCompiler(
               // but needs to be set for some logic of ilwrite to function.
               pdbfile = (if tcConfig.debuginfo then Some (multiAssemblyName + ".pdb") else None)
               emitTailcalls = tcConfig.emitTailcalls
-              deterministic = tcConfig.deterministic
-              showTimes = tcConfig.showTimes
+              deterministic = tcConfig.deterministic           
               // we always use portable for F# Interactive debug emit
               portablePDB = true
               // we don't use embedded for F# Interactive debug emit
@@ -1483,7 +1455,6 @@ type internal FsiDynamicCompiler(
             match pdbBytes with
             | None -> Assembly.Load(assemblyBytes)
             | Some pdbBytes -> Assembly.Load(assemblyBytes, pdbBytes)
-
         dynamicAssemblies.Add(asm)
 
         let loadedTypes = [ for t in asm.GetTypes() -> t]
@@ -1501,18 +1472,18 @@ type internal FsiDynamicCompiler(
                     yield! loop (enc@[tdef]) ntdef  ]
             [ for tdef in ilxMainModule.TypeDefs do yield! loop [] tdef ]
                                 
-        // Make the 'exec' functions for the entry point initializations
-        let execs = 
+        let execs =
             [ for edef in entries do
                 if edef.ArgCount = 0 then
-                    yield
-                      (fun () -> 
+                    yield (fun () -> 
                         let typ = asm.GetType(edef.DeclaringTypeRef.BasicQualifiedName)
                         try
                             ignore (typ.InvokeMember (edef.Name, BindingFlags.InvokeMethod ||| BindingFlags.Public ||| BindingFlags.NonPublic ||| BindingFlags.Static, null, null, [| |], Globalization.CultureInfo.InvariantCulture))
                             None
-                        with :? TargetInvocationException as e ->
-                            Some e.InnerException) ]
+                        with
+                            | :? TargetInvocationException as e ->
+                                Some e.InnerException)
+            ]
 
         emEnv.AddModuleDef asm ilScopeRef ilxMainModule
 
@@ -1563,7 +1534,7 @@ type internal FsiDynamicCompiler(
 
             | MultipleInMemoryAssemblies emEnv ->
 
-                let execs  = EmitInMemoryAssembly (tcConfig, emEnv, ilxMainModule, m)
+                let execs  = EmitInMemoryAssembly (tcConfig, emEnv, ilxMainModule)
 
                 MultipleInMemoryAssemblies emEnv, execs
 
@@ -1732,11 +1703,10 @@ type internal FsiDynamicCompiler(
 
     let nextFragmentId() =
         fragmentId <- fragmentId + 1
-        fragmentId
+        $"%04d{fragmentId}"
 
-    let mkFragmentPath m i =
-        // NOTE: this text shows in exn traces and type names. Make it clear and fixed width
-        [mkSynId m (FsiDynamicModulePrefix + sprintf "%04d" i)]
+    let mkFragmentPath m fragmentId =
+        [mkSynId m (FsiDynamicModulePrefix + fragmentId())]
 
     let processContents istate declaredImpls =
         let tcState = istate.tcState
@@ -1851,12 +1821,17 @@ type internal FsiDynamicCompiler(
 
     member _.DynamicAssemblies = dynamicAssemblies.ToArray()
 
-    member _.FindDynamicAssembly(simpleAssemName) =
-        dynamicAssemblies |> ResizeArray.tryFind (fun asm -> asm.GetName().Name = simpleAssemName)
+    member _.FindDynamicAssembly (name, useFullName: bool) =
+        let getName (assemblyName: AssemblyName) =
+            if useFullName then
+                assemblyName.FullName
+            else
+                assemblyName.Name
+
+        dynamicAssemblies |> ResizeArray.tryFind (fun asm -> getName (asm.GetName()) = name)
 
     member _.EvalParsedSourceFiles (ctok, diagnosticsLogger, istate, inputs, m) =
-        let i = nextFragmentId()
-        let prefix = mkFragmentPath m i
+        let prefix = mkFragmentPath m nextFragmentId
         // Ensure the path includes the qualifying name
         let inputs = inputs |> List.map (PrependPathToInput prefix)
         let isIncrementalFragment = false
@@ -1866,9 +1841,8 @@ type internal FsiDynamicCompiler(
     /// Evaluate the given definitions and produce a new interactive state.
     member _.EvalParsedDefinitions (ctok, diagnosticsLogger: DiagnosticsLogger, istate, showTypes, isInteractiveItExpr, defs: SynModuleDecl list) =
         let fileName = stdinMockFileName
-        let i = nextFragmentId()
         let m = match defs with [] -> rangeStdin0 | _ -> List.reduce unionRanges [for d in defs -> d.Range] 
-        let prefix = mkFragmentPath m i
+        let prefix = mkFragmentPath m nextFragmentId
         let prefixPath = pathOfLid prefix
         let impl = SynModuleOrNamespace(prefix,false, SynModuleOrNamespaceKind.NamedModule,defs,PreXmlDoc.Empty,[],None,m, { LeadingKeyword = SynModuleOrNamespaceLeadingKeyword.None })
         let isLastCompiland = true
@@ -2222,9 +2196,8 @@ type internal FsiDynamicCompiler(
             let ty = List.head tys
             let amap = istate.tcImports.GetImportMap()
 
-            let i = nextFragmentId()
             let m = rangeStdin0
-            let prefix = mkFragmentPath m i
+            let prefix = mkFragmentPath m nextFragmentId
             let prefixPath = pathOfLid prefix
             let qualifiedName = ComputeQualifiedNameOfFileFromUniquePath (m,prefixPath)
 
@@ -2469,9 +2442,15 @@ type internal MagicAssemblyResolution () =
             if simpleAssemName.EndsWith(".XmlSerializers", StringComparison.OrdinalIgnoreCase) ||
                simpleAssemName = "UIAutomationWinforms" then null
             else
-                match fsiDynamicCompiler.FindDynamicAssembly(simpleAssemName) with
+                // Check dynamic assemblies by exact version
+                match fsiDynamicCompiler.FindDynamicAssembly(fullAssemName, true) with
                 | Some asm -> asm
                 | None ->
+                // Check dynamic assemblies by simple name
+                match fsiDynamicCompiler.FindDynamicAssembly(simpleAssemName, false) with
+                | Some asm -> asm
+                | None ->
+                
 
                 // Otherwise continue
                 let assemblyReferenceTextDll = (simpleAssemName + ".dll")
@@ -3400,26 +3379,19 @@ type FsiEvaluationSession (fsi: FsiEvaluationSessionHostConfig, argv:string[], i
     do tcConfigB.useFsiAuxLib <- fsi.UseFsiAuxLib
     do tcConfigB.conditionalDefines <- "INTERACTIVE" :: tcConfigB.conditionalDefines
 
-#if NETSTANDARD
+
     do tcConfigB.SetUseSdkRefs true
     do tcConfigB.useSimpleResolution <- true
     do if isRunningOnCoreClr then SetTargetProfile tcConfigB "netcore" // always assume System.Runtime codegen
-#endif
-
-    // Preset: --multiemit- on .NET Framework and Mono
-    do if not isRunningOnCoreClr then
-        tcConfigB.fsiMultiAssemblyEmit <- false
 
     // Preset: --optimize+ -g --tailcalls+ (see 4505)
     do SetOptimizeSwitch tcConfigB OptionSwitch.On
     do SetDebugSwitch    tcConfigB (Some "pdbonly") OptionSwitch.On
     do SetTailcallSwitch tcConfigB OptionSwitch.On
 
-#if NETSTANDARD
     // set platform depending on whether the current process is a 64-bit process.
     // BUG 429882 : FsiAnyCPU.exe issues warnings (x64 v MSIL) when referencing 64-bit assemblies
     do tcConfigB.platform <- if IntPtr.Size = 8 then Some AMD64 else Some X86
-#endif
 
     let fsiStdinSyphon = FsiStdinSyphon(errorWriter)
     let fsiConsoleOutput = FsiConsoleOutput(tcConfigB, outWriter, errorWriter)
@@ -3754,7 +3726,7 @@ type FsiEvaluationSession (fsi: FsiEvaluationSessionHostConfig, argv:string[], i
     /// A background thread is started by this thread to read from the inReader and/or console reader.
 
     member x.Run() =
-        progress <- condition "FSHARP_INTERACTIVE_PROGRESS"
+        progress <- isEnvVarSet "FSHARP_INTERACTIVE_PROGRESS"
 
         // Explanation: When Run is called we do a bunch of processing. For fsi.exe
         // and fsiAnyCpu.exe there are no other active threads at this point, so we can assume this is the
diff --git a/src/Compiler/Interactive/xlf/FSIstrings.txt.cs.xlf b/src/Compiler/Interactive/xlf/FSIstrings.txt.cs.xlf
index 667a5ed5a7b..97dcca71c4c 100644
--- a/src/Compiler/Interactive/xlf/FSIstrings.txt.cs.xlf
+++ b/src/Compiler/Interactive/xlf/FSIstrings.txt.cs.xlf
@@ -7,11 +7,6 @@
         <target state="translated">Funkce s [&lt;EntryPoint&gt;] nejsou vyvolány v FSI. {0} nebylo vyvoláno. Pokud chcete vyvolat {2} s příslušným polem řetězců argumentů příkazového řádku, spusťte příkaz{1} &lt;args&gt;.</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiInternalAccess">
-        <source>Accessing the internal type, method or field '{0}' from a previous evaluation in F# Interactive is deprecated and may cause subsequent access errors. To enable the legacy generation of a single dynamic assembly that can access internals, use the '--multiemit-' option.</source>
-        <target state="translated">Přístup k internímu typu, metodě nebo poli {0} z předchozího vyhodnocení ve F# Interactive je zastaralý a může způsobit následné chyby přístupu. Pokud chcete povolit starší generaci jednoho dynamického sestavení, které má přístup k interním sestavením, použijte možnost --multiemit-.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiIntroPackageSourceUriInfo">
         <source>Include package source uri when searching for packages</source>
         <target state="translated">Při vyhledávání balíčků zahrnout identifikátor zdroje balíčku</target>
@@ -22,11 +17,6 @@
         <target state="translated">Vymazat obrazovku</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiMultiAssemblyEmitOptionOffByDefault">
-        <source>Emit multiple assemblies (off by default for .NET Framework)</source>
-        <target state="translated">Vygenerovat více sestavení (pro .NET Framework je to ve výchozím nastavení vypnuto)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiOperationCouldNotBeCompleted">
         <source>Operation could not be completed due to earlier error</source>
         <target state="translated">Operaci nešlo dokončit z důvodu dřívější chyby.</target>
diff --git a/src/Compiler/Interactive/xlf/FSIstrings.txt.de.xlf b/src/Compiler/Interactive/xlf/FSIstrings.txt.de.xlf
index f6553e896d1..a3d73b0e675 100644
--- a/src/Compiler/Interactive/xlf/FSIstrings.txt.de.xlf
+++ b/src/Compiler/Interactive/xlf/FSIstrings.txt.de.xlf
@@ -7,11 +7,6 @@
         <target state="translated">Funktionen mit [&lt;EntryPoint&gt;] werden in FSI nicht aufgerufen. '{0}' wurde nicht aufgerufen. Führen Sie '{1} &lt;args&gt;' aus, um '{2}' mit dem entsprechenden String-Array von Befehlszeilenargumenten aufzurufen.</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiInternalAccess">
-        <source>Accessing the internal type, method or field '{0}' from a previous evaluation in F# Interactive is deprecated and may cause subsequent access errors. To enable the legacy generation of a single dynamic assembly that can access internals, use the '--multiemit-' option.</source>
-        <target state="translated">Der Zugriff auf den internen Typ, die Methode oder das Feld “{0}” aus einer vorherigen Auswertung in F# Interactive ist veraltet und kann zu nachfolgenden Zugriffsfehlern führen. Verwenden Sie die Option “--multiemit-”, um die Legacygenerierung einer einzelnen dynamischen Assembly zu aktivieren, die auf Interne zugreifen kann.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiIntroPackageSourceUriInfo">
         <source>Include package source uri when searching for packages</source>
         <target state="translated">URI der Paketquelle bei Suche nach Paketen einschließen</target>
@@ -22,11 +17,6 @@
         <target state="translated">Bildschirm löschen</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiMultiAssemblyEmitOptionOffByDefault">
-        <source>Emit multiple assemblies (off by default for .NET Framework)</source>
-        <target state="translated">Ausgeben mehrerer Assemblys (standardmäßig deaktiviert für .NET Framework)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiOperationCouldNotBeCompleted">
         <source>Operation could not be completed due to earlier error</source>
         <target state="translated">Der Vorgang konnte aufgrund eines vorherigen Fehlers nicht abgeschlossen werden.</target>
diff --git a/src/Compiler/Interactive/xlf/FSIstrings.txt.es.xlf b/src/Compiler/Interactive/xlf/FSIstrings.txt.es.xlf
index 913c5217e13..190ff245baa 100644
--- a/src/Compiler/Interactive/xlf/FSIstrings.txt.es.xlf
+++ b/src/Compiler/Interactive/xlf/FSIstrings.txt.es.xlf
@@ -7,11 +7,6 @@
         <target state="translated">Las funciones con [&lt;EntryPoint&gt;] no se invocan en FSI. “{0}” no se invocó. Ejecute “{1} &lt;args&gt;” para invocar “{2}” con la matriz adecuada de cadenas de argumentos de línea de comandos.</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiInternalAccess">
-        <source>Accessing the internal type, method or field '{0}' from a previous evaluation in F# Interactive is deprecated and may cause subsequent access errors. To enable the legacy generation of a single dynamic assembly that can access internals, use the '--multiemit-' option.</source>
-        <target state="translated">El acceso al tipo, método o campo interno “{0}” de una evaluación anterior en F# interactivo está en desuso y puede provocar errores de acceso posteriores. Para habilitar la generación heredada de un único ensamblado dinámico que pueda acceder a elementos internos, use la opción “--multiemit-”.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiIntroPackageSourceUriInfo">
         <source>Include package source uri when searching for packages</source>
         <target state="translated">Incluir el URI de origen del paquete al buscar paquetes</target>
@@ -22,11 +17,6 @@
         <target state="translated">Borrar pantalla</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiMultiAssemblyEmitOptionOffByDefault">
-        <source>Emit multiple assemblies (off by default for .NET Framework)</source>
-        <target state="translated">Emitir varios ensamblados (desactivado de forma predeterminada para .NET Framework)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiOperationCouldNotBeCompleted">
         <source>Operation could not be completed due to earlier error</source>
         <target state="translated">La operación no se pudo completar debido a un error anterior</target>
diff --git a/src/Compiler/Interactive/xlf/FSIstrings.txt.fr.xlf b/src/Compiler/Interactive/xlf/FSIstrings.txt.fr.xlf
index e83c98d04a5..38d7a20d8e9 100644
--- a/src/Compiler/Interactive/xlf/FSIstrings.txt.fr.xlf
+++ b/src/Compiler/Interactive/xlf/FSIstrings.txt.fr.xlf
@@ -7,11 +7,6 @@
         <target state="translated">Les fonctions avec [&lt;EntryPoint&gt;] ne sont pas appelées dans FSI. '{0}' n’a pas été appelée. Exécutez '{1} &lt;args&gt;' pour appeler '{2}' avec le tableau de chaînes approprié d’arguments de ligne de commande.</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiInternalAccess">
-        <source>Accessing the internal type, method or field '{0}' from a previous evaluation in F# Interactive is deprecated and may cause subsequent access errors. To enable the legacy generation of a single dynamic assembly that can access internals, use the '--multiemit-' option.</source>
-        <target state="translated">L’accès au type interne, à la méthode ou au champ «{0}» d’une évaluation précédente dans F# Interactive est déconseillé et peut entraîner des erreurs d’accès ultérieures. Pour activer la génération héritée d’un assemblée dynamique unique qui peut accéder aux éléments internes, utilisez l’option « --multiemit- ».</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiIntroPackageSourceUriInfo">
         <source>Include package source uri when searching for packages</source>
         <target state="translated">Inclure l'URI de source de package au moment de la recherche des packages</target>
@@ -22,11 +17,6 @@
         <target state="translated">Effacer l'écran</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiMultiAssemblyEmitOptionOffByDefault">
-        <source>Emit multiple assemblies (off by default for .NET Framework)</source>
-        <target state="translated">Émettre plusieurs assemblées (désactivé par défaut pour .NET Framework)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiOperationCouldNotBeCompleted">
         <source>Operation could not be completed due to earlier error</source>
         <target state="translated">Impossible d'exécuter l'opération en raison d'une erreur antérieure</target>
diff --git a/src/Compiler/Interactive/xlf/FSIstrings.txt.it.xlf b/src/Compiler/Interactive/xlf/FSIstrings.txt.it.xlf
index f59a4e13f44..9c916837e52 100644
--- a/src/Compiler/Interactive/xlf/FSIstrings.txt.it.xlf
+++ b/src/Compiler/Interactive/xlf/FSIstrings.txt.it.xlf
@@ -7,11 +7,6 @@
         <target state="translated">Le funzioni con [&lt;EntryPoint&gt;] non vengono richiamate in FSI. '{0}' non è stato richiamato. Eseguire '{1} &lt;args&gt;' per richiamare '{2}' con la matrice di stringhe appropriata degli argomenti della riga di comando.</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiInternalAccess">
-        <source>Accessing the internal type, method or field '{0}' from a previous evaluation in F# Interactive is deprecated and may cause subsequent access errors. To enable the legacy generation of a single dynamic assembly that can access internals, use the '--multiemit-' option.</source>
-        <target state="translated">L'accesso al tipo, al metodo o al campo interno '{0}' da una valutazione precedente in F# Interactive è deprecato e potrebbe causare errori di accesso successivi. Per abilitare la generazione legacy di un singolo assembly dinamico che può accedere agli elementi interni, usare l'opzione '--multiemit-'.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiIntroPackageSourceUriInfo">
         <source>Include package source uri when searching for packages</source>
         <target state="translated">Includi l'URI di origine pacchetti durante la ricerca di pacchetti</target>
@@ -22,11 +17,6 @@
         <target state="translated">Cancella schermata</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiMultiAssemblyEmitOptionOffByDefault">
-        <source>Emit multiple assemblies (off by default for .NET Framework)</source>
-        <target state="translated">Creare più assembly (disattivato per impostazione predefinita per .NET Framework)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiOperationCouldNotBeCompleted">
         <source>Operation could not be completed due to earlier error</source>
         <target state="translated">Non è stato possibile completare l'operazione a causa di un errore precedente</target>
diff --git a/src/Compiler/Interactive/xlf/FSIstrings.txt.ja.xlf b/src/Compiler/Interactive/xlf/FSIstrings.txt.ja.xlf
index 4bd3f98f44f..eab626f267e 100644
--- a/src/Compiler/Interactive/xlf/FSIstrings.txt.ja.xlf
+++ b/src/Compiler/Interactive/xlf/FSIstrings.txt.ja.xlf
@@ -7,11 +7,6 @@
         <target state="translated">[&lt;EntryPoint&gt;] を含む関数は FSI では呼び出されません。'{0}' は呼び出されませんでした。コマンド ライン引数の適切な文字列配列を使用して '{2}' を呼び出すには、'{1} &lt;args&gt;' を実行してください。</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiInternalAccess">
-        <source>Accessing the internal type, method or field '{0}' from a previous evaluation in F# Interactive is deprecated and may cause subsequent access errors. To enable the legacy generation of a single dynamic assembly that can access internals, use the '--multiemit-' option.</source>
-        <target state="translated">F# インタラクティブの以前の評価から内部型、メソッド、またはフィールド `{0}` にアクセスすることは非推奨であり、その後のアクセス エラーが発生する可能性があります。内部にアクセスできる単一の動的アセンブリのレガシ生成を有効にするには、`--multiemit-` オプションを使用します。</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiIntroPackageSourceUriInfo">
         <source>Include package source uri when searching for packages</source>
         <target state="translated">パッケージの検索時にパッケージ ソースの URI を含める</target>
@@ -22,11 +17,6 @@
         <target state="translated">画面をクリアする</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiMultiAssemblyEmitOptionOffByDefault">
-        <source>Emit multiple assemblies (off by default for .NET Framework)</source>
-        <target state="translated">複数のアセンブリを出力する (.NET Frameworkの場合は既定でオフ)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiOperationCouldNotBeCompleted">
         <source>Operation could not be completed due to earlier error</source>
         <target state="translated">以前のエラーが原因で操作を完了できませんでした</target>
diff --git a/src/Compiler/Interactive/xlf/FSIstrings.txt.ko.xlf b/src/Compiler/Interactive/xlf/FSIstrings.txt.ko.xlf
index 5a6c0bb8f4f..be891b98188 100644
--- a/src/Compiler/Interactive/xlf/FSIstrings.txt.ko.xlf
+++ b/src/Compiler/Interactive/xlf/FSIstrings.txt.ko.xlf
@@ -7,11 +7,6 @@
         <target state="translated">[&lt;EntryPoint&gt;]가 있는 함수는 FSI에서 호출되지 않습니다. '{0}'이(가) 호출되지 않았습니다. 명령줄 인수의 적절한 문자열 배열로 '{2}'을(를) 호출하려면 '{1}&lt;args&gt;'를 실행하세요.</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiInternalAccess">
-        <source>Accessing the internal type, method or field '{0}' from a previous evaluation in F# Interactive is deprecated and may cause subsequent access errors. To enable the legacy generation of a single dynamic assembly that can access internals, use the '--multiemit-' option.</source>
-        <target state="translated">F# 대화형의 이전 평가에서 내부 형식, 메서드 또는 필드 '{0}'에 액세스하는 것은 더 이상 사용되지 않으며 후속 액세스 오류가 발생할 수 있습니다. 내부에 액세스할 수 있는 단일 동적 어셈블리의 레거시 생성을 사용하도록 설정하려면 '--multiemit-' 옵션을 사용합니다.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiIntroPackageSourceUriInfo">
         <source>Include package source uri when searching for packages</source>
         <target state="translated">패키지를 검색할 때 패키지 원본 URI 포함</target>
@@ -22,11 +17,6 @@
         <target state="translated">화면 지우기</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiMultiAssemblyEmitOptionOffByDefault">
-        <source>Emit multiple assemblies (off by default for .NET Framework)</source>
-        <target state="translated">여러 어셈블리 내보내기(기본적으로 .NET Framework 해제)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiOperationCouldNotBeCompleted">
         <source>Operation could not be completed due to earlier error</source>
         <target state="translated">이전 오류로 인해 작업을 완료할 수 없습니다.</target>
diff --git a/src/Compiler/Interactive/xlf/FSIstrings.txt.pl.xlf b/src/Compiler/Interactive/xlf/FSIstrings.txt.pl.xlf
index b6cd0fa6659..58adec37da4 100644
--- a/src/Compiler/Interactive/xlf/FSIstrings.txt.pl.xlf
+++ b/src/Compiler/Interactive/xlf/FSIstrings.txt.pl.xlf
@@ -7,11 +7,6 @@
         <target state="translated">Funkcje z elementem [&lt;EntryPoint&gt;] nie są wywoływane w interfejsie FSI. „{0}” nie został wywołany. Wykonaj polecenie „{1} &lt;args&gt;”, aby wywołać „{2}” z odpowiednią tablicą ciągów argumentów wiersza polecenia.</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiInternalAccess">
-        <source>Accessing the internal type, method or field '{0}' from a previous evaluation in F# Interactive is deprecated and may cause subsequent access errors. To enable the legacy generation of a single dynamic assembly that can access internals, use the '--multiemit-' option.</source>
-        <target state="translated">Uzyskiwanie dostępu do typu wewnętrznego, metody lub pola „{0}“ z poprzedniej oceny w programie F# Interactive jest przestarzałe i może powodować kolejne błędy dostępu. Aby włączyć starszą generację pojedynczego zestawu dynamicznego, który może uzyskiwać dostęp wewnętrzny, użyj opcji „--multiemit-“.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiIntroPackageSourceUriInfo">
         <source>Include package source uri when searching for packages</source>
         <target state="translated">Uwzględnij identyfikator URI źródła pakietów podczas wyszukiwania pakietów</target>
@@ -22,11 +17,6 @@
         <target state="translated">Wyczyść ekran</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiMultiAssemblyEmitOptionOffByDefault">
-        <source>Emit multiple assemblies (off by default for .NET Framework)</source>
-        <target state="translated">Emituj wiele zestawów (domyślnie wyłączone dla programu .NET Framework)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiOperationCouldNotBeCompleted">
         <source>Operation could not be completed due to earlier error</source>
         <target state="translated">Nie udało się ukończyć operacji z powodu wcześniejszego błędu</target>
diff --git a/src/Compiler/Interactive/xlf/FSIstrings.txt.pt-BR.xlf b/src/Compiler/Interactive/xlf/FSIstrings.txt.pt-BR.xlf
index 3ae204efd46..b080a196f7c 100644
--- a/src/Compiler/Interactive/xlf/FSIstrings.txt.pt-BR.xlf
+++ b/src/Compiler/Interactive/xlf/FSIstrings.txt.pt-BR.xlf
@@ -7,11 +7,6 @@
         <target state="translated">As funções com [&lt;EntryPoint&gt;] não são invocadas no FSI. '{0}' não foi invocado. Execute '{1} &lt;args&gt;' para invocar '{2}' com a matriz de cadeia de caracteres apropriada dos argumentos da linha de comando.</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiInternalAccess">
-        <source>Accessing the internal type, method or field '{0}' from a previous evaluation in F# Interactive is deprecated and may cause subsequent access errors. To enable the legacy generation of a single dynamic assembly that can access internals, use the '--multiemit-' option.</source>
-        <target state="translated">O acesso ao tipo, método ou campo interno '{0}' de uma avaliação anterior em F# Interativo é preterido e pode causar erros de acesso subsequentes. Para habilitar a geração herdada de uma única assembly dinâmica que possa acessar os elementos internos, use a opção '--multiemit-'.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiIntroPackageSourceUriInfo">
         <source>Include package source uri when searching for packages</source>
         <target state="translated">Incluir o URI de origem do pacote ao pesquisar pacotes</target>
@@ -22,11 +17,6 @@
         <target state="translated">Limpar tela</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiMultiAssemblyEmitOptionOffByDefault">
-        <source>Emit multiple assemblies (off by default for .NET Framework)</source>
-        <target state="translated">Emitir várias montagens (desligadas por padrão para .NET Framework)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiOperationCouldNotBeCompleted">
         <source>Operation could not be completed due to earlier error</source>
         <target state="translated">Não foi possível concluir a operação devido a um erro anterior</target>
diff --git a/src/Compiler/Interactive/xlf/FSIstrings.txt.ru.xlf b/src/Compiler/Interactive/xlf/FSIstrings.txt.ru.xlf
index 34c69c3e70a..e46822530d8 100644
--- a/src/Compiler/Interactive/xlf/FSIstrings.txt.ru.xlf
+++ b/src/Compiler/Interactive/xlf/FSIstrings.txt.ru.xlf
@@ -7,11 +7,6 @@
         <target state="translated">Функции с [&lt;EntryPoint&gt;] не вызываются в FSI. "{0}" не вызван. Выполните "{1} &lt;args&gt;", чтобы вызвать "{2}" с соответствующим строковым массивом аргументов командной строки.</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiInternalAccess">
-        <source>Accessing the internal type, method or field '{0}' from a previous evaluation in F# Interactive is deprecated and may cause subsequent access errors. To enable the legacy generation of a single dynamic assembly that can access internals, use the '--multiemit-' option.</source>
-        <target state="translated">Доступ ко внутреннему типу, методу или полю \"{0}\" из предыдущей оценки в F# Interactive является нерекомендуемым и может привести к последующим ошибкам доступа. Чтобы включить устаревшее создание одной динамической сборки, которая может получать доступ ко внутренним данным, используйте параметр \"--multiemit-\".</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiIntroPackageSourceUriInfo">
         <source>Include package source uri when searching for packages</source>
         <target state="translated">Включать исходный URI пакета при поиске пакетов</target>
@@ -22,11 +17,6 @@
         <target state="translated">Очистить экран</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiMultiAssemblyEmitOptionOffByDefault">
-        <source>Emit multiple assemblies (off by default for .NET Framework)</source>
-        <target state="translated">Выпуск нескольких сборок (отключено по умолчанию для .NET Framework)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiOperationCouldNotBeCompleted">
         <source>Operation could not be completed due to earlier error</source>
         <target state="translated">Операция не может быть завершена из-за предыдущей ошибки</target>
diff --git a/src/Compiler/Interactive/xlf/FSIstrings.txt.tr.xlf b/src/Compiler/Interactive/xlf/FSIstrings.txt.tr.xlf
index e064e5d942c..3222a474ef5 100644
--- a/src/Compiler/Interactive/xlf/FSIstrings.txt.tr.xlf
+++ b/src/Compiler/Interactive/xlf/FSIstrings.txt.tr.xlf
@@ -7,11 +7,6 @@
         <target state="translated">[&lt;EntryPoint&gt;] ile işlevler, FSI'de çağrılmaz. '{0}' başlatılmadı. '{1} &lt;args&gt;' komutunu çalıştırarak uygun komut satırı bağımsız değişken dizisiyle '{2}' komutunu başlatın.</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiInternalAccess">
-        <source>Accessing the internal type, method or field '{0}' from a previous evaluation in F# Interactive is deprecated and may cause subsequent access errors. To enable the legacy generation of a single dynamic assembly that can access internals, use the '--multiemit-' option.</source>
-        <target state="translated">F# Etkileşimli’de önceki bir değerlendirmeden '{0}' iç türüne, yöntemine veya alanına erişim kullanım dışıdır ve sonraki erişim hatalarına neden olabilir. İç öğelere erişen tek bir dinamik bütünleştirilmiş kodun eski neslini etkinleştirmek için '--multiemit-' seçeneğini kullanın.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiIntroPackageSourceUriInfo">
         <source>Include package source uri when searching for packages</source>
         <target state="translated">Paketler aranırken paket kaynağı URI'si ekleyin</target>
@@ -22,11 +17,6 @@
         <target state="translated">Ekranı temizle</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiMultiAssemblyEmitOptionOffByDefault">
-        <source>Emit multiple assemblies (off by default for .NET Framework)</source>
-        <target state="translated">Birden çok bütünleştirilmiş kod göster (.NET Framework için varsayılan olarak kapalı)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiOperationCouldNotBeCompleted">
         <source>Operation could not be completed due to earlier error</source>
         <target state="translated">Önceki hata nedeniyle işlem tamamlanamadı</target>
diff --git a/src/Compiler/Interactive/xlf/FSIstrings.txt.zh-Hans.xlf b/src/Compiler/Interactive/xlf/FSIstrings.txt.zh-Hans.xlf
index e9262eef59c..de485cc5361 100644
--- a/src/Compiler/Interactive/xlf/FSIstrings.txt.zh-Hans.xlf
+++ b/src/Compiler/Interactive/xlf/FSIstrings.txt.zh-Hans.xlf
@@ -7,11 +7,6 @@
         <target state="translated">FSI 中未调用具有 [&lt;EntryPoint&gt;] 的函数。未调用“{0}”。执行“{1} &lt;args&gt;”，以便使用命令行参数的相应字符串数组调用“{2}”。</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiInternalAccess">
-        <source>Accessing the internal type, method or field '{0}' from a previous evaluation in F# Interactive is deprecated and may cause subsequent access errors. To enable the legacy generation of a single dynamic assembly that can access internals, use the '--multiemit-' option.</source>
-        <target state="translated">已弃用从 F# 交互窗口的上一个评估中访问内部类型、方法或字段“{0}”，并可能导致后续访问错误。如果要启用可以访问内部的单个动态程序集的旧的生成，请使用 “--multiemit-” 选项。</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiIntroPackageSourceUriInfo">
         <source>Include package source uri when searching for packages</source>
         <target state="translated">搜索包时包含包源 uri</target>
@@ -22,11 +17,6 @@
         <target state="translated">清除屏幕</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiMultiAssemblyEmitOptionOffByDefault">
-        <source>Emit multiple assemblies (off by default for .NET Framework)</source>
-        <target state="translated">发出多个程序集(默认情况下为 .NET Framework 关闭)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiOperationCouldNotBeCompleted">
         <source>Operation could not be completed due to earlier error</source>
         <target state="translated">由于早期错误，无法完成操作</target>
diff --git a/src/Compiler/Interactive/xlf/FSIstrings.txt.zh-Hant.xlf b/src/Compiler/Interactive/xlf/FSIstrings.txt.zh-Hant.xlf
index 3223a668d89..9348019132b 100644
--- a/src/Compiler/Interactive/xlf/FSIstrings.txt.zh-Hant.xlf
+++ b/src/Compiler/Interactive/xlf/FSIstrings.txt.zh-Hant.xlf
@@ -7,11 +7,6 @@
         <target state="translated">FSI 中未叫用具有 [&lt;EntryPoint&gt;] 的函數。未叫用'{0}'。執行 '{1} &lt;args&gt;'，以使用適當的命令列引數字串陣列叫用 '{2}'。</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiInternalAccess">
-        <source>Accessing the internal type, method or field '{0}' from a previous evaluation in F# Interactive is deprecated and may cause subsequent access errors. To enable the legacy generation of a single dynamic assembly that can access internals, use the '--multiemit-' option.</source>
-        <target state="translated">從之前 F# 互動中的評估存取內部類型、方法或欄位 '{0}' 已過時，可能造成後續存取錯誤。若要啟用可存取內部之單一動態組件的舊版世代，請使用 '--multiemit-' 選項。</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiIntroPackageSourceUriInfo">
         <source>Include package source uri when searching for packages</source>
         <target state="translated">搜尋套件時包含套件來源 URI</target>
@@ -22,11 +17,6 @@
         <target state="translated">清空螢幕</target>
         <note />
       </trans-unit>
-      <trans-unit id="fsiMultiAssemblyEmitOptionOffByDefault">
-        <source>Emit multiple assemblies (off by default for .NET Framework)</source>
-        <target state="translated">發出多組件 (.NET Framework 預設為關閉)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="fsiOperationCouldNotBeCompleted">
         <source>Operation could not be completed due to earlier error</source>
         <target state="translated">因為先前發生錯誤，所以無法完成作業</target>
diff --git a/src/Compiler/Optimize/DetupleArgs.fs b/src/Compiler/Optimize/DetupleArgs.fs
index dc2ea60f6e7..4f749a689c1 100644
--- a/src/Compiler/Optimize/DetupleArgs.fs
+++ b/src/Compiler/Optimize/DetupleArgs.fs
@@ -388,9 +388,7 @@ let rebuildTS g m ts vs =
 /// - the definition formal projection info suggests a CallPattern
 type CallPattern = TupleStructure list 
       
-let callPatternOrder = (compare : CallPattern -> CallPattern -> int)
 let argsCP exprs = List.map exprTS exprs
-let noArgsCP = []
 let inline isTrivialCP xs = isNil xs
 
 let rec minimalCallPattern callPattern =
@@ -826,25 +824,6 @@ let passBinds penv binds = binds |> List.map (passBind penv)
 //   3. run pass over following code.
 //-------------------------------------------------------------------------
 
-let passBindRhs conv (TBind (v, repr, letSeqPtOpt)) = TBind(v, conv repr, letSeqPtOpt)
-
-let preInterceptExpr (penv: penv) conv expr =
-  match expr with
-  | Expr.LetRec (binds, e, m, _) ->
-     let binds = List.map (passBindRhs conv) binds
-     let binds = passBinds penv binds
-     Some (mkLetRecBinds m binds (conv e))
-  | Expr.Let (bind, e, m, _) ->  
-     let bind = passBindRhs conv bind
-     let bind = passBind penv bind
-     Some (mkLetBind m bind (conv e))
-  | TyappAndApp(f, fty, tys, args, m) ->
-     // match app, and fixup if needed 
-     let args = List.map conv args
-     let f = conv f
-     Some (fixupApp penv (f, fty, tys, args, m) )
-  | _ -> None
-  
 let postTransformExpr (penv: penv) expr =
     match expr with
     | Expr.LetRec (binds, e, m, _) ->
diff --git a/src/Compiler/Optimize/LowerComputedCollections.fs b/src/Compiler/Optimize/LowerComputedCollections.fs
index e3c120d0697..f2f3e4f6245 100644
--- a/src/Compiler/Optimize/LowerComputedCollections.fs
+++ b/src/Compiler/Optimize/LowerComputedCollections.fs
@@ -15,8 +15,6 @@ open FSharp.Compiler.TypedTree
 open FSharp.Compiler.TypedTreeOps
 open FSharp.Compiler.TypeHierarchy
 
-let LowerComputedCollectionsStackGuardDepth = StackGuard.GetDepthOption "LowerComputedCollections"
-
 /// Build the 'test and dispose' part of a 'use' statement
 let BuildDisposableCleanup tcVal (g: TcGlobals) infoReader m (v: Val) =
     let disposeMethod = 
diff --git a/src/Compiler/Optimize/LowerSequences.fs b/src/Compiler/Optimize/LowerSequences.fs
index 294635559c9..3a7d733ec59 100644
--- a/src/Compiler/Optimize/LowerSequences.fs
+++ b/src/Compiler/Optimize/LowerSequences.fs
@@ -17,8 +17,6 @@ open FSharp.Compiler.TypedTreeBasics
 open FSharp.Compiler.TypedTreeOps
 open FSharp.Compiler.TypeHierarchy
 
-let LowerSequenceExpressionsStackGuardDepth = StackGuard.GetDepthOption "LowerSequenceExpressions"
-
 //----------------------------------------------------------------------------
 // General helpers
 
diff --git a/src/Compiler/Optimize/Optimizer.fs b/src/Compiler/Optimize/Optimizer.fs
index 6b2d3c76a83..e2e64126db2 100644
--- a/src/Compiler/Optimize/Optimizer.fs
+++ b/src/Compiler/Optimize/Optimizer.fs
@@ -36,16 +36,6 @@ open System.Collections.ObjectModel
 
 let OptimizerStackGuardDepth = GetEnvInteger "FSHARP_Optimizer" 50
 
-#if DEBUG
-let verboseOptimizationInfo = 
-    try not (System.String.IsNullOrEmpty (System.Environment.GetEnvironmentVariable "FSHARP_verboseOptimizationInfo")) with _ -> false
-let verboseOptimizations = 
-    try not (System.String.IsNullOrEmpty (System.Environment.GetEnvironmentVariable "FSHARP_verboseOptimizations")) with _ -> false
-#else
-let [<Literal>] verboseOptimizationInfo = false
-let [<Literal>] verboseOptimizations = false
-#endif
-
 let i_ldlen = [ I_ldlen; (AI_conv DT_I4) ] 
 
 /// size of a function call 
@@ -758,8 +748,6 @@ let mkUInt32Val (g: TcGlobals) n = ConstValue(Const.UInt32 n, g.uint32_ty)
 
 let mkUInt64Val (g: TcGlobals) n = ConstValue(Const.UInt64 n, g.uint64_ty)
 
-let (|StripInt32Value|_|) = function StripConstValue(Const.Int32 n) -> Some n | _ -> None
-      
 let MakeValueInfoForValue g m vref vinfo = 
 #if DEBUG
     let rec check x = 
diff --git a/src/Compiler/Service/FSharpCheckerResults.fs b/src/Compiler/Service/FSharpCheckerResults.fs
index 25c94ca5c5c..c66bb3e5142 100644
--- a/src/Compiler/Service/FSharpCheckerResults.fs
+++ b/src/Compiler/Service/FSharpCheckerResults.fs
@@ -270,9 +270,7 @@ type FSharpSymbolUse(denv: DisplayEnv, symbol: FSharpSymbol, inst: TyparInstanti
 
                 let fileHasSignatureFile = fileSignatureLocation <> fileDeclarationLocation
 
-                let symbolIsNotInSignatureFile = m.SignatureLocation = Some m.DeclarationLocation
-
-                fileHasSignatureFile && symbolIsNotInSignatureFile
+                fileHasSignatureFile && not m.HasSignatureFile
                 || not m.IsModuleValueOrMember
                 || m.Accessibility.IsPrivate
             | :? FSharpEntity as m -> m.Accessibility.IsPrivate
@@ -834,7 +832,7 @@ type internal TypeCheckInfo
             if p >= 0 then Some p else None
 
     /// Build a CompetionItem
-    let CompletionItem (ty: ValueOption<TyconRef>) (assemblySymbol: ValueOption<AssemblySymbol>) (item: ItemWithInst) =
+    let CompletionItem (ty: TyconRef voption) (assemblySymbol: AssemblySymbol voption) (item: ItemWithInst) =
         let kind =
             match item.Item with
             | Item.FakeInterfaceCtor _
@@ -2345,9 +2343,19 @@ module internal ParseAndCheckFile =
 
         matchingBraces.ToArray()
 
-    let parseFile (sourceText: ISourceText, fileName, options: FSharpParsingOptions, userOpName: string, suggestNamesForErrors: bool) =
+    let parseFile
+        (
+            sourceText: ISourceText,
+            fileName,
+            options: FSharpParsingOptions,
+            userOpName: string,
+            suggestNamesForErrors: bool,
+            identCapture: bool
+        ) =
         Trace.TraceInformation("FCS: {0}.{1} ({2})", userOpName, "parseFile", fileName)
-        use act = Activity.start "ParseAndCheckFile.parseFile" [| "fileName", fileName |]
+
+        use act =
+            Activity.start "ParseAndCheckFile.parseFile" [| Activity.Tags.fileName, fileName |]
 
         let errHandler =
             DiagnosticsHandler(true, fileName, options.DiagnosticOptions, sourceText, suggestNamesForErrors)
@@ -2375,7 +2383,8 @@ module internal ParseAndCheckFile =
                         lexbuf,
                         None,
                         fileName,
-                        (isLastCompiland, isExe)
+                        (isLastCompiland, isExe),
+                        identCapture
                     )
                 with e ->
                     errHandler.DiagnosticsLogger.StopProcessingRecovery e range0 // don't re-raise any exceptions, we must return None.
@@ -2504,7 +2513,12 @@ module internal ParseAndCheckFile =
 
         cancellable {
             use _ =
-                Activity.start "ParseAndCheckFile.CheckOneFile" [| "fileName", mainInputFileName; "length", sourceText.Length.ToString() |]
+                Activity.start
+                    "ParseAndCheckFile.CheckOneFile"
+                    [|
+                        Activity.Tags.fileName, mainInputFileName
+                        Activity.Tags.length, sourceText.Length.ToString()
+                    |]
 
             let parsedMainInput = parseResults.ParseTree
 
@@ -3173,7 +3187,14 @@ type FsiInteractiveChecker(legacyReferenceResolver, tcConfig: TcConfig, tcGlobal
                 FSharpParsingOptions.FromTcConfig(tcConfig, [| fileName |], true)
 
             let parseErrors, parsedInput, anyErrors =
-                ParseAndCheckFile.parseFile (sourceText, fileName, parsingOptions, userOpName, suggestNamesForErrors)
+                ParseAndCheckFile.parseFile (
+                    sourceText,
+                    fileName,
+                    parsingOptions,
+                    userOpName,
+                    suggestNamesForErrors,
+                    tcConfig.captureIdentifiersWhenParsing
+                )
 
             let dependencyFiles = [||] // interactions have no dependencies
 
diff --git a/src/Compiler/Service/FSharpCheckerResults.fsi b/src/Compiler/Service/FSharpCheckerResults.fsi
index bbf14830f39..444807b0117 100644
--- a/src/Compiler/Service/FSharpCheckerResults.fsi
+++ b/src/Compiler/Service/FSharpCheckerResults.fsi
@@ -530,7 +530,8 @@ module internal ParseAndCheckFile =
         fileName: string *
         options: FSharpParsingOptions *
         userOpName: string *
-        suggestNamesForErrors: bool ->
+        suggestNamesForErrors: bool *
+        identCapture: bool ->
             FSharpDiagnostic[] * ParsedInput * bool
 
     val matchBraces:
diff --git a/src/Compiler/Service/FSharpSource.fs b/src/Compiler/Service/FSharpSource.fs
index 383a61be85a..f2483115b26 100644
--- a/src/Compiler/Service/FSharpSource.fs
+++ b/src/Compiler/Service/FSharpSource.fs
@@ -66,7 +66,9 @@ type private FSharpSourceCustom(filePath: string, getTimeStamp, getSourceText) =
     override _.TimeStamp = getTimeStamp ()
 
     override _.GetTextContainer() =
-        TextContainer.SourceText(getSourceText ())
+        getSourceText ()
+        |> Option.map TextContainer.SourceText
+        |> Option.defaultValue TextContainer.OnDisk
 
 type FSharpSource with
 
diff --git a/src/Compiler/Service/FSharpSource.fsi b/src/Compiler/Service/FSharpSource.fsi
index 5692bd7a6b0..36688631254 100644
--- a/src/Compiler/Service/FSharpSource.fsi
+++ b/src/Compiler/Service/FSharpSource.fsi
@@ -36,4 +36,5 @@ type internal FSharpSource =
 
     /// Creates a FSharpSource.
     static member Create:
-        filePath: string * getTimeStamp: (unit -> DateTime) * getSourceText: (unit -> ISourceText) -> FSharpSource
+        filePath: string * getTimeStamp: (unit -> DateTime) * getSourceText: (unit -> ISourceText option) ->
+            FSharpSource
diff --git a/src/Compiler/Service/IncrementalBuild.fs b/src/Compiler/Service/IncrementalBuild.fs
index 578eb5558f0..152d5119fb0 100644
--- a/src/Compiler/Service/IncrementalBuild.fs
+++ b/src/Compiler/Service/IncrementalBuild.fs
@@ -97,7 +97,7 @@ module IncrementalBuilderEventTesting =
 
 module Tc = CheckExpressions
 
-// This module is only here to contain the SyntaxTree type as to avoid amiguity with the module FSharp.Compiler.Syntax.
+// This module is only here to contain the SyntaxTree type as to avoid ambiguity with the module FSharp.Compiler.Syntax.
 [<AutoOpen>]
 module IncrementalBuildSyntaxTree =
 
@@ -127,7 +127,7 @@ module IncrementalBuildSyntaxTree =
                 use act =
                     Activity.start "IncrementalBuildSyntaxTree.parse"
                         [|
-                            "fileName", source.FilePath
+                            Activity.Tags.fileName, source.FilePath
                             "buildPhase", BuildPhase.Parse.ToString()
                             "canSkip", canSkip.ToString()
                         |]             
@@ -475,7 +475,7 @@ type BoundModel private (tcConfig: TcConfig,
                 let! res = defaultTypeCheck ()
                 return res
             | Some syntaxTree ->
-                use _ = Activity.start "BoundModel.TypeCheck" [|"fileName", syntaxTree.FileName|]
+                use _ = Activity.start "BoundModel.TypeCheck" [|Activity.Tags.fileName, syntaxTree.FileName|]
                 let sigNameOpt =
                     if partialCheck then
                         this.BackingSignature
@@ -538,7 +538,7 @@ type BoundModel private (tcConfig: TcConfig,
                         // Build symbol keys
                         let itemKeyStore, semanticClassification =
                             if enableBackgroundItemKeyStoreAndSemanticClassification then
-                                use _ = Activity.start "IncrementalBuild.CreateItemKeyStoreAndSemanticClassification" [|"fileName", fileName|]
+                                use _ = Activity.start "IncrementalBuild.CreateItemKeyStoreAndSemanticClassification" [|Activity.Tags.fileName, fileName|]
                                 let sResolutions = sink.GetResolutions()
                                 let builder = ItemKeyStoreBuilder()
                                 let preventDuplicates = HashSet({ new IEqualityComparer<struct(pos * pos)> with
@@ -733,8 +733,9 @@ type RawFSharpAssemblyDataBackedByLanguageService (tcConfig, tcGlobals, generate
 module IncrementalBuilderHelpers =
 
     /// Get the timestamp of the given file name.
-    let StampFileNameTask (cache: TimeStampCache) (_m: range, source: FSharpSource, _isLastCompiland) =
-        cache.GetFileTimeStamp source.FilePath
+    let StampFileNameTask (cache: TimeStampCache) (_m: range, source: FSharpSource, _isLastCompiland) notifiedTime =
+        notifiedTime
+        |> Option.defaultWith (fun () -> cache.GetFileTimeStamp source.FilePath)
 
     /// Timestamps of referenced assemblies are taken from the file's timestamp.
     let StampReferencedAssemblyTask (cache: TimeStampCache) (_ref, timeStamper) =
@@ -966,6 +967,7 @@ type IncrementalBuilderInitialState =
         allDependencies: string []
         defaultTimeStamp: DateTime
         mutable isImportsInvalidated: bool
+        useChangeNotifications: bool
     }
 
     static member Create(
@@ -984,7 +986,8 @@ type IncrementalBuilderInitialState =
                             importsInvalidatedByTypeProvider: Event<unit>,
 #endif
                             allDependencies,
-                            defaultTimeStamp: DateTime) =
+                            defaultTimeStamp: DateTime,
+                            useChangeNotifications: bool) =
 
         let initialState =
             {
@@ -1007,6 +1010,7 @@ type IncrementalBuilderInitialState =
                 allDependencies = allDependencies
                 defaultTimeStamp = defaultTimeStamp
                 isImportsInvalidated = false
+                useChangeNotifications = useChangeNotifications
             }
 #if !NO_TYPEPROVIDERS
         importsInvalidatedByTypeProvider.Publish.Add(fun () -> initialState.isImportsInvalidated <- true)
@@ -1017,8 +1021,10 @@ type IncrementalBuilderInitialState =
 type IncrementalBuilderState =
     {
         // stampedFileNames represent the real stamps of the files.
+        // notifiedStampedFileNames represent the stamps of when we got notified about file changes
         // logicalStampedFileNames represent the stamps of the files that are used to calculate the project's logical timestamp.
         stampedFileNames: ImmutableArray<DateTime>
+        notifiedStampedFileNames: ImmutableArray<DateTime>
         logicalStampedFileNames: ImmutableArray<DateTime>
         stampedReferencedAssemblies: ImmutableArray<DateTime>
         initialBoundModel: GraphNode<BoundModel>
@@ -1043,7 +1049,7 @@ module IncrementalBuilderStateHelpers =
 
     let rec createFinalizeBoundModelGraphNode (initialState: IncrementalBuilderInitialState) (boundModels: ImmutableArray<GraphNode<BoundModel>>.Builder) =
         GraphNode(node {
-            use _ = Activity.start "GetCheckResultsAndImplementationsForProject" [|"projectOutFile", initialState.outfile|]
+            use _ = Activity.start "GetCheckResultsAndImplementationsForProject" [|Activity.Tags.project, initialState.outfile|]
             // Compute last bound model then get all the evaluated models.
             let! _ = boundModels[boundModels.Count - 1].GetOrComputeValue()
             let boundModels =
@@ -1064,7 +1070,8 @@ module IncrementalBuilderStateHelpers =
 
     and computeStampedFileName (initialState: IncrementalBuilderInitialState) (state: IncrementalBuilderState) (cache: TimeStampCache) slot fileInfo =
         let currentStamp = state.stampedFileNames[slot]
-        let stamp = StampFileNameTask cache fileInfo
+        let notifiedStamp = if initialState.useChangeNotifications then Some state.notifiedStampedFileNames[slot] else None
+        let stamp = StampFileNameTask cache fileInfo notifiedStamp
 
         if currentStamp <> stamp then
             match state.boundModels[slot].TryPeekValue() with
@@ -1073,7 +1080,7 @@ module IncrementalBuilderStateHelpers =
                 let newBoundModel = boundModel.ClearTcInfoExtras()
                 { state with
                     boundModels = state.boundModels.RemoveAt(slot).Insert(slot, GraphNode(node.Return newBoundModel))
-                    stampedFileNames = state.stampedFileNames.SetItem(slot, StampFileNameTask cache fileInfo)
+                    stampedFileNames = state.stampedFileNames.SetItem(slot, StampFileNameTask cache fileInfo notifiedStamp)
                 }
             | _ ->
 
@@ -1083,7 +1090,8 @@ module IncrementalBuilderStateHelpers =
 
                 // Invalidate the file and all files below it.
                 for j = 0 to stampedFileNames.Count - slot - 1 do
-                    let stamp = StampFileNameTask cache initialState.fileNames[slot + j]
+                    let notifiedStamp = if initialState.useChangeNotifications then Some state.notifiedStampedFileNames.[slot + j] else None
+                    let stamp = StampFileNameTask cache initialState.fileNames[slot + j] notifiedStamp
                     stampedFileNames[slot + j] <- stamp
                     logicalStampedFileNames[slot + j] <- stamp
                     boundModels[slot + j] <- createBoundModelGraphNode initialState state.initialBoundModel boundModels (slot + j)
@@ -1156,6 +1164,7 @@ type IncrementalBuilderState with
         let state =
             {
                 stampedFileNames = ImmutableArray.init fileNames.Length (fun _ -> DateTime.MinValue)
+                notifiedStampedFileNames = ImmutableArray.init fileNames.Length (fun _ -> DateTime.MinValue)
                 logicalStampedFileNames = ImmutableArray.init fileNames.Length (fun _ -> DateTime.MinValue)
                 stampedReferencedAssemblies = ImmutableArray.init referencedAssemblies.Length (fun _ -> DateTime.MinValue)
                 initialBoundModel = initialBoundModel
@@ -1416,6 +1425,15 @@ type IncrementalBuilder(initialState: IncrementalBuilderInitialState, state: Inc
         let syntaxTree = GetSyntaxTree initialState.tcConfig initialState.fileParsed initialState.lexResourceManager fileInfo
         syntaxTree.Parse None
 
+    member builder.NotifyFileChanged(fileName, timeStamp) =
+        node {
+            let slotOfFile = builder.GetSlotOfFileName fileName
+            let newState = { currentState with notifiedStampedFileNames = currentState.notifiedStampedFileNames.SetItem(slotOfFile, timeStamp) }
+            let cache = TimeStampCache defaultTimeStamp
+            let! ct = NodeCode.CancellationToken
+            setCurrentState newState cache ct
+        }
+
     member _.SourceFiles  = fileNames |> Seq.map (fun (_, f, _) -> f.FilePath) |> List.ofSeq
 
     /// CreateIncrementalBuilder (for background type checking). Note that fsc.fs also
@@ -1440,7 +1458,10 @@ type IncrementalBuilder(initialState: IncrementalBuilderInitialState, state: Inc
             enablePartialTypeChecking: bool,
             enableParallelCheckingWithSignatureFiles: bool,
             dependencyProvider,
-            parallelReferenceResolution
+            parallelReferenceResolution,
+            captureIdentifiersWhenParsing,
+            getSource,
+            useChangeNotifications
         ) =
 
       let useSimpleResolutionSwitch = "--simpleresolution"
@@ -1523,7 +1544,8 @@ type IncrementalBuilder(initialState: IncrementalBuilderInitialState, state: Inc
 
                 tcConfigB.parallelCheckingWithSignatureFiles <- enableParallelCheckingWithSignatureFiles
                 tcConfigB.parallelReferenceResolution <- parallelReferenceResolution
-                
+                tcConfigB.captureIdentifiersWhenParsing <- captureIdentifiersWhenParsing
+
                 tcConfigB, sourceFilesNew
 
             // If this is a builder for a script, re-apply the settings inferred from the
@@ -1646,10 +1668,18 @@ type IncrementalBuilder(initialState: IncrementalBuilderInitialState, state: Inc
                     importsInvalidatedByTypeProvider
                 )
 
+            let getFSharpSource fileName =
+                getSource
+                |> Option.map(fun getSource ->
+                    let getTimeStamp() = DateTime.UtcNow
+                    let getSourceText() = getSource fileName
+                    FSharpSource.Create(fileName, getTimeStamp, getSourceText))
+                |> Option.defaultWith(fun () -> FSharpSource.CreateFromFile(fileName))
+
             let sourceFiles =
                 sourceFiles
                 |> List.map (fun (m, fileName, isLastCompiland) ->
-                    (m, FSharpSource.CreateFromFile(fileName), isLastCompiland)
+                    (m, getFSharpSource(fileName), isLastCompiland)
                 )
 
             let initialState =
@@ -1669,7 +1699,8 @@ type IncrementalBuilder(initialState: IncrementalBuilderInitialState, state: Inc
                     importsInvalidatedByTypeProvider,
 #endif
                     allDependencies,
-                    defaultTimeStamp)
+                    defaultTimeStamp,
+                    useChangeNotifications)
 
             let builder = IncrementalBuilder(initialState, IncrementalBuilderState.Create(initialState))
             return Some builder
diff --git a/src/Compiler/Service/IncrementalBuild.fsi b/src/Compiler/Service/IncrementalBuild.fsi
old mode 100755
new mode 100644
index 481ed50689e..c527ca8a70b
--- a/src/Compiler/Service/IncrementalBuild.fsi
+++ b/src/Compiler/Service/IncrementalBuild.fsi
@@ -245,6 +245,8 @@ type internal IncrementalBuilder =
     member GetParseResultsForFile:
         fileName: string -> ParsedInput * range * string * (PhasedDiagnostic * FSharpDiagnosticSeverity)[]
 
+    member NotifyFileChanged: fileName: string * timeStamp: DateTime -> NodeCode<unit>
+
     /// Create the incremental builder
     static member TryCreateIncrementalBuilderForProjectOptions:
         legacyReferenceResolver: LegacyReferenceResolver *
@@ -265,7 +267,10 @@ type internal IncrementalBuilder =
         enablePartialTypeChecking: bool *
         enableParallelCheckingWithSignatureFiles: bool *
         dependencyProvider: DependencyProvider option *
-        parallelReferenceResolution: ParallelReferenceResolution ->
+        parallelReferenceResolution: ParallelReferenceResolution *
+        captureIdentifiersWhenParsing: bool *
+        getSource: (string -> ISourceText option) option *
+        useChangeNotifications: bool ->
             NodeCode<IncrementalBuilder option * FSharpDiagnostic[]>
 
 /// Generalized Incremental Builder. This is exposed only for unit testing purposes.
diff --git a/src/Compiler/Service/ServiceInterfaceStubGenerator.fs b/src/Compiler/Service/ServiceInterfaceStubGenerator.fs
index 55ff01779f5..15f01224e78 100644
--- a/src/Compiler/Service/ServiceInterfaceStubGenerator.fs
+++ b/src/Compiler/Service/ServiceInterfaceStubGenerator.fs
@@ -522,21 +522,6 @@ module InterfaceStubGenerator =
         | Some ty -> Some ty
         | None -> None
 
-    let internal (|EventFunctionType|_|) (ty: FSharpType) =
-        match ty with
-        | MemberFunctionType ty ->
-            if ty.IsFunctionType && ty.GenericArguments.Count = 2 then
-                let retType = ty.GenericArguments[0]
-                let argType = ty.GenericArguments[1]
-
-                if argType.GenericArguments.Count = 2 then
-                    Some(argType.GenericArguments[0], retType)
-                else
-                    None
-            else
-                None
-        | _ -> None
-
     let internal removeWhitespace (str: string) = str.Replace(" ", "")
 
     /// Filter out duplicated interfaces in inheritance chain
diff --git a/src/Compiler/Service/ServiceLexing.fs b/src/Compiler/Service/ServiceLexing.fs
index c39546e975d..ac28ec245aa 100644
--- a/src/Compiler/Service/ServiceLexing.fs
+++ b/src/Compiler/Service/ServiceLexing.fs
@@ -27,7 +27,6 @@ module FSharpTokenTag =
     let String = tagOfToken (STRING("a", SynStringKind.Regular, LexCont.Default))
 
     let IDENT = tagOfToken (IDENT "a")
-    let HASH_IDENT = tagOfToken (HASH_IDENT "a")
     let STRING = String
 
     let INTERP_STRING_BEGIN_END =
diff --git a/src/Compiler/Service/ServiceParseTreeWalk.fs b/src/Compiler/Service/ServiceParseTreeWalk.fs
index 2a335d274e9..8415ec401fd 100644
--- a/src/Compiler/Service/ServiceParseTreeWalk.fs
+++ b/src/Compiler/Service/ServiceParseTreeWalk.fs
@@ -594,7 +594,7 @@ module SyntaxTraversal =
 
                 | SynExpr.TypeApp (synExpr, _, _synTypeList, _commas, _, _, _range) -> traverseSynExpr synExpr
 
-                | SynExpr.LetOrUse (_, isRecursive, synBindingList, synExpr, range, _) ->
+                | SynExpr.LetOrUse (isRecursive, _, synBindingList, synExpr, range, _) ->
                     match visitor.VisitLetOrUse(path, isRecursive, traverseSynBinding path, synBindingList, range) with
                     | None ->
                         [
diff --git a/src/Compiler/Service/ServiceStructure.fs b/src/Compiler/Service/ServiceStructure.fs
index e9468f63357..f1d404f7680 100644
--- a/src/Compiler/Service/ServiceStructure.fs
+++ b/src/Compiler/Service/ServiceStructure.fs
@@ -5,6 +5,7 @@ namespace FSharp.Compiler.EditorServices
 open Internal.Utilities.Library
 open FSharp.Compiler.Syntax
 open FSharp.Compiler.SyntaxTreeOps
+open FSharp.Compiler.SyntaxTrivia
 open FSharp.Compiler.Text
 open FSharp.Compiler.Text.Position
 open FSharp.Compiler.Text.Range
@@ -64,18 +65,6 @@ module Structure =
             |> List.map (fun (SynTyparDecl (_, typarg)) -> typarg.Range)
             |> List.reduce unionRanges
 
-    let rangeOfSynPatsElse other (synPats: SynSimplePat list) =
-        match synPats with
-        | [] -> other
-        | ls ->
-            ls
-            |> List.map (fun x ->
-                match x with
-                | SynSimplePat.Attrib (range = r)
-                | SynSimplePat.Id (range = r)
-                | SynSimplePat.Typed (range = r) -> r)
-            |> List.reduce unionRanges
-
     /// Collapse indicates the way a range/snapshot should be collapsed. `Same` is for a scope inside
     /// some kind of scope delimiter, e.g. `[| ... |]`, `[ ... ]`, `{ ... }`, etc.  `Below` is for expressions
     /// following a binding or the right hand side of a pattern, e.g. `let x = ...`
@@ -753,6 +742,64 @@ module Structure =
                     Some(mkRange "" (mkPos r.StartLine prefixLength) r.End)
                 | _ -> None)
 
+        let collectConditionalDirectives directives sourceLines =
+            let rec group directives stack (sourceLines: string array) =
+                match directives with
+                | [] -> ()
+                | ConditionalDirectiveTrivia.If _ as ifDirective :: directives -> group directives (ifDirective :: stack) sourceLines
+                | ConditionalDirectiveTrivia.Else elseRange as elseDirective :: directives ->
+                    match stack with
+                    | ConditionalDirectiveTrivia.If (_, ifRange) :: stack ->
+                        let startLineIndex = elseRange.StartLine - 2
+
+                        if startLineIndex >= 0 then
+                            // start of #if until the end of the line directly above #else
+                            let range =
+                                mkFileIndexRange
+                                    ifRange.FileIndex
+                                    ifRange.Start
+                                    (mkPos (elseRange.StartLine - 1) sourceLines[startLineIndex].Length)
+
+                            {
+                                Scope = Scope.HashDirective
+                                Collapse = Collapse.Same
+                                Range = range
+                                CollapseRange = range
+                            }
+                            |> acc.Add
+
+                        group directives (elseDirective :: stack) sourceLines
+                    | _ -> group directives stack sourceLines
+                | ConditionalDirectiveTrivia.EndIf endIfRange :: directives ->
+                    match stack with
+                    | ConditionalDirectiveTrivia.If (_, ifRange) :: stack ->
+                        let range = Range.startToEnd ifRange endIfRange
+
+                        {
+                            Scope = Scope.HashDirective
+                            Collapse = Collapse.Same
+                            Range = range
+                            CollapseRange = range
+                        }
+                        |> acc.Add
+
+                        group directives stack sourceLines
+                    | ConditionalDirectiveTrivia.Else elseRange :: stack ->
+                        let range = Range.startToEnd elseRange endIfRange
+
+                        {
+                            Scope = Scope.HashDirective
+                            Collapse = Collapse.Same
+                            Range = range
+                            CollapseRange = range
+                        }
+                        |> acc.Add
+
+                        group directives stack sourceLines
+                    | _ -> group directives stack sourceLines
+
+            group directives [] sourceLines
+
         let rec parseDeclaration (decl: SynModuleDecl) =
             match decl with
             | SynModuleDecl.Let (_, bindings, r) ->
@@ -1059,9 +1106,11 @@ module Structure =
         match parsedInput with
         | ParsedInput.ImplFile file ->
             file.Contents |> List.iter parseModuleOrNamespace
+            collectConditionalDirectives file.Trivia.ConditionalDirectives sourceLines
             getCommentRanges sourceLines
         | ParsedInput.SigFile file ->
             file.Contents |> List.iter parseModuleOrNamespaceSigs
+            collectConditionalDirectives file.Trivia.ConditionalDirectives sourceLines
             getCommentRanges sourceLines
 
         acc :> seq<_>
diff --git a/src/Compiler/Service/service.fs b/src/Compiler/Service/service.fs
index 07c1f518725..ad84d6e4b69 100644
--- a/src/Compiler/Service/service.fs
+++ b/src/Compiler/Service/service.fs
@@ -49,6 +49,11 @@ module EnvMisc =
 // BackgroundCompiler
 //
 
+[<RequireQualifiedAccess>]
+type DocumentSource =
+    | FileSystem
+    | Custom of (string -> ISourceText option)
+
 /// Callback that indicates whether a requested result has become obsolete.
 [<NoComparison; NoEquality>]
 type IsResultObsolete = IsResultObsolete of (unit -> bool)
@@ -188,7 +193,10 @@ type BackgroundCompiler
         enableBackgroundItemKeyStoreAndSemanticClassification,
         enablePartialTypeChecking,
         enableParallelCheckingWithSignatureFiles,
-        parallelReferenceResolution
+        parallelReferenceResolution,
+        captureIdentifiersWhenParsing,
+        getSource: (string -> ISourceText option) option,
+        useChangeNotifications
     ) as self =
 
     let beforeFileChecked = Event<string * FSharpProjectOptions>()
@@ -287,7 +295,7 @@ type BackgroundCompiler
     let CreateOneIncrementalBuilder (options: FSharpProjectOptions, userOpName) =
         node {
             use _ =
-                Activity.start "BackgroundCompiler.CreateOneIncrementalBuilder" [| "project", options.ProjectFileName |]
+                Activity.start "BackgroundCompiler.CreateOneIncrementalBuilder" [| Activity.Tags.project, options.ProjectFileName |]
 
             Trace.TraceInformation("FCS: {0}.{1} ({2})", userOpName, "CreateOneIncrementalBuilder", options.ProjectFileName)
             let projectReferences = getProjectReferences options userOpName
@@ -320,7 +328,10 @@ type BackgroundCompiler
                     enablePartialTypeChecking,
                     enableParallelCheckingWithSignatureFiles,
                     dependencyProvider,
-                    parallelReferenceResolution
+                    parallelReferenceResolution,
+                    captureIdentifiersWhenParsing,
+                    getSource,
+                    useChangeNotifications
                 )
 
             match builderOpt with
@@ -479,7 +490,13 @@ type BackgroundCompiler
     member _.ParseFile(fileName: string, sourceText: ISourceText, options: FSharpParsingOptions, cache: bool, userOpName: string) =
         async {
             use _ =
-                Activity.start "BackgroundCompiler.ParseFile" [| "fileName", fileName; "userOpName", userOpName; "cache", cache.ToString() |]
+                Activity.start
+                    "BackgroundCompiler.ParseFile"
+                    [|
+                        Activity.Tags.fileName, fileName
+                        Activity.Tags.userOpName, userOpName
+                        Activity.Tags.cache, cache.ToString()
+                    |]
 
             if cache then
                 let hash = sourceText.GetHashCode() |> int64
@@ -490,14 +507,14 @@ type BackgroundCompiler
                     Interlocked.Increment(&actualParseFileCount) |> ignore
 
                     let parseDiagnostics, parseTree, anyErrors =
-                        ParseAndCheckFile.parseFile (sourceText, fileName, options, userOpName, suggestNamesForErrors)
+                        ParseAndCheckFile.parseFile (sourceText, fileName, options, userOpName, suggestNamesForErrors, captureIdentifiersWhenParsing)
 
                     let res = FSharpParseFileResults(parseDiagnostics, parseTree, anyErrors, options.SourceFiles)
                     parseCacheLock.AcquireLock(fun ltok -> parseFileCache.Set(ltok, (fileName, hash, options), res))
                     return res
             else
                 let parseDiagnostics, parseTree, anyErrors =
-                    ParseAndCheckFile.parseFile (sourceText, fileName, options, userOpName, false)
+                    ParseAndCheckFile.parseFile (sourceText, fileName, options, userOpName, false, captureIdentifiersWhenParsing)
 
                 return FSharpParseFileResults(parseDiagnostics, parseTree, anyErrors, options.SourceFiles)
         }
@@ -506,7 +523,9 @@ type BackgroundCompiler
     member _.GetBackgroundParseResultsForFileInProject(fileName, options, userOpName) =
         node {
             use _ =
-                Activity.start "BackgroundCompiler.GetBackgroundParseResultsForFileInProject" [| "fileName", fileName; "userOpName", userOpName |]
+                Activity.start
+                    "BackgroundCompiler.GetBackgroundParseResultsForFileInProject"
+                    [| Activity.Tags.fileName, fileName; Activity.Tags.userOpName, userOpName |]
 
             let! builderOpt, creationDiags = getOrCreateBuilder (options, userOpName)
 
@@ -535,7 +554,9 @@ type BackgroundCompiler
 
     member _.GetCachedCheckFileResult(builder: IncrementalBuilder, fileName, sourceText: ISourceText, options) =
         node {
-            use _ = Activity.start "BackgroundCompiler.GetCachedCheckFileResult" [| "fileName", fileName |]
+            use _ =
+                Activity.start "BackgroundCompiler.GetCachedCheckFileResult" [| Activity.Tags.fileName, fileName |]
+
             let hash = sourceText.GetHashCode() |> int64
             let key = (fileName, hash, options)
             let cachedResultsOpt = parseCacheLock.AcquireLock(fun ltok -> checkFileInProjectCache.TryGet(ltok, key))
@@ -617,6 +638,9 @@ type BackgroundCompiler
         ) =
 
         node {
+            if useChangeNotifications then
+                do! builder.NotifyFileChanged(fileName, DateTime.UtcNow)
+
             match! bc.GetCachedCheckFileResult(builder, fileName, sourceText, options) with
             | Some (_, results) -> return FSharpCheckFileAnswer.Succeeded results
             | _ ->
@@ -642,9 +666,9 @@ type BackgroundCompiler
                 Activity.start
                     "BackgroundCompiler.CheckFileInProjectAllowingStaleCachedResults"
                     [|
-                        "project", options.ProjectFileName
-                        "fileName", fileName
-                        "userOpName", userOpName
+                        Activity.Tags.project, options.ProjectFileName
+                        Activity.Tags.fileName, fileName
+                        Activity.Tags.userOpName, userOpName
                     |]
 
             let! cachedResults =
@@ -684,9 +708,9 @@ type BackgroundCompiler
                 Activity.start
                     "BackgroundCompiler.CheckFileInProject"
                     [|
-                        "project", options.ProjectFileName
-                        "fileName", fileName
-                        "userOpName", userOpName
+                        Activity.Tags.project, options.ProjectFileName
+                        Activity.Tags.fileName, fileName
+                        Activity.Tags.userOpName, userOpName
                     |]
 
             let! builderOpt, creationDiags = getOrCreateBuilder (options, userOpName)
@@ -712,9 +736,9 @@ type BackgroundCompiler
                 Activity.start
                     "BackgroundCompiler.ParseAndCheckFileInProject"
                     [|
-                        "project", options.ProjectFileName
-                        "fileName", fileName
-                        "userOpName", userOpName
+                        Activity.Tags.project, options.ProjectFileName
+                        Activity.Tags.fileName, fileName
+                        Activity.Tags.userOpName, userOpName
                     |]
 
             let! builderOpt, creationDiags = getOrCreateBuilder (options, userOpName)
@@ -740,7 +764,14 @@ type BackgroundCompiler
                     GraphNode.SetPreferredUILang tcPrior.TcConfig.preferredUiLang
 
                     let parseDiagnostics, parseTree, anyErrors =
-                        ParseAndCheckFile.parseFile (sourceText, fileName, parsingOptions, userOpName, suggestNamesForErrors)
+                        ParseAndCheckFile.parseFile (
+                            sourceText,
+                            fileName,
+                            parsingOptions,
+                            userOpName,
+                            suggestNamesForErrors,
+                            captureIdentifiersWhenParsing
+                        )
 
                     let parseResults =
                         FSharpParseFileResults(parseDiagnostics, parseTree, anyErrors, builder.AllDependenciesDeprecated)
@@ -751,6 +782,24 @@ type BackgroundCompiler
                     return (parseResults, checkResults)
         }
 
+    member _.NotifyFileChanged(fileName, options, userOpName) =
+        node {
+            use _ =
+                Activity.start
+                    "BackgroundCompiler.NotifyFileChanged"
+                    [|
+                        Activity.Tags.project, options.ProjectFileName
+                        Activity.Tags.fileName, fileName
+                        Activity.Tags.userOpName, userOpName
+                    |]
+
+            let! builderOpt, _ = getOrCreateBuilder (options, userOpName)
+
+            match builderOpt with
+            | None -> return ()
+            | Some builder -> do! builder.NotifyFileChanged(fileName, DateTime.UtcNow)
+        }
+
     /// Fetch the check information from the background compiler (which checks w.r.t. the FileSystem API)
     member _.GetBackgroundCheckResultsForFileInProject(fileName, options, userOpName) =
         node {
@@ -758,9 +807,9 @@ type BackgroundCompiler
                 Activity.start
                     "BackgroundCompiler.ParseAndCheckFileInProject"
                     [|
-                        "project", options.ProjectFileName
-                        "fileName", fileName
-                        "userOpName", userOpName
+                        Activity.Tags.project, options.ProjectFileName
+                        Activity.Tags.fileName, fileName
+                        Activity.Tags.userOpName, userOpName
                     |]
 
             let! builderOpt, creationDiags = getOrCreateBuilder (options, userOpName)
@@ -850,9 +899,9 @@ type BackgroundCompiler
                 Activity.start
                     "BackgroundCompiler.FindReferencesInFile"
                     [|
-                        "project", options.ProjectFileName
-                        "fileName", fileName
-                        "userOpName", userOpName
+                        Activity.Tags.project, options.ProjectFileName
+                        Activity.Tags.fileName, fileName
+                        Activity.Tags.userOpName, userOpName
                         "symbol", symbol.FullName
                     |]
 
@@ -878,9 +927,9 @@ type BackgroundCompiler
                 Activity.start
                     "BackgroundCompiler.GetSemanticClassificationForFile"
                     [|
-                        "project", options.ProjectFileName
-                        "fileName", fileName
-                        "userOpName", userOpName
+                        Activity.Tags.project, options.ProjectFileName
+                        Activity.Tags.fileName, fileName
+                        Activity.Tags.userOpName, userOpName
                     |]
 
             let! builderOpt, _ = getOrCreateBuilder (options, userOpName)
@@ -902,9 +951,9 @@ type BackgroundCompiler
             Activity.start
                 "BackgroundCompiler.GetSemanticClassificationForFile"
                 [|
-                    "project", options.ProjectFileName
-                    "fileName", fileName
-                    "userOpName", _userOpName
+                    Activity.Tags.project, options.ProjectFileName
+                    Activity.Tags.fileName, fileName
+                    Activity.Tags.userOpName, _userOpName
                 |]
 
         match sourceText with
@@ -980,7 +1029,12 @@ type BackgroundCompiler
     member _.GetAssemblyData(options, userOpName) =
         node {
             use _ =
-                Activity.start "BackgroundCompiler.GetAssemblyData" [| "project", options.ProjectFileName; "userOpName", userOpName |]
+                Activity.start
+                    "BackgroundCompiler.GetAssemblyData"
+                    [|
+                        Activity.Tags.project, options.ProjectFileName
+                        Activity.Tags.userOpName, userOpName
+                    |]
 
             let! builderOpt, _ = getOrCreateBuilder (options, userOpName)
 
@@ -1003,7 +1057,12 @@ type BackgroundCompiler
     /// Parse and typecheck the whole project.
     member bc.ParseAndCheckProject(options, userOpName) =
         use _ =
-            Activity.start "BackgroundCompiler.ParseAndCheckProject" [| "project", options.ProjectFileName; "userOpName", userOpName |]
+            Activity.start
+                "BackgroundCompiler.ParseAndCheckProject"
+                [|
+                    Activity.Tags.project, options.ProjectFileName
+                    Activity.Tags.userOpName, userOpName
+                |]
 
         bc.ParseAndCheckProjectImpl(options, userOpName)
 
@@ -1022,7 +1081,9 @@ type BackgroundCompiler
             _userOpName
         ) =
         use _ =
-            Activity.start "BackgroundCompiler.GetProjectOptionsFromScript" [| "fileName", fileName; "userOpName", _userOpName |]
+            Activity.start
+                "BackgroundCompiler.GetProjectOptionsFromScript"
+                [| Activity.Tags.fileName, fileName; Activity.Tags.userOpName, _userOpName |]
 
         cancellable {
             use diagnostics = new DiagnosticsScope()
@@ -1109,7 +1170,12 @@ type BackgroundCompiler
 
     member bc.InvalidateConfiguration(options: FSharpProjectOptions, userOpName) =
         use _ =
-            Activity.start "BackgroundCompiler.InvalidateConfiguration" [| "project", options.ProjectFileName; "userOpName", userOpName |]
+            Activity.start
+                "BackgroundCompiler.InvalidateConfiguration"
+                [|
+                    Activity.Tags.project, options.ProjectFileName
+                    Activity.Tags.userOpName, userOpName
+                |]
 
         if incrementalBuildersCache.ContainsSimilarKey(AnyCallerThread, options) then
             parseCacheLock.AcquireLock(fun ltok ->
@@ -1120,7 +1186,7 @@ type BackgroundCompiler
             ()
 
     member bc.ClearCache(options: seq<FSharpProjectOptions>, _userOpName) =
-        use _ = Activity.start "BackgroundCompiler.ClearCache" [| "userOpName", _userOpName |]
+        use _ = Activity.start "BackgroundCompiler.ClearCache" [| Activity.Tags.userOpName, _userOpName |]
 
         lock gate (fun () ->
             options
@@ -1128,7 +1194,12 @@ type BackgroundCompiler
 
     member _.NotifyProjectCleaned(options: FSharpProjectOptions, userOpName) =
         use _ =
-            Activity.start "BackgroundCompiler.NotifyProjectCleaned" [| "project", options.ProjectFileName; "userOpName", userOpName |]
+            Activity.start
+                "BackgroundCompiler.NotifyProjectCleaned"
+                [|
+                    Activity.Tags.project, options.ProjectFileName
+                    Activity.Tags.userOpName, userOpName
+                |]
 
         async {
             let! ct = Async.CancellationToken
@@ -1192,7 +1263,10 @@ type FSharpChecker
         enableBackgroundItemKeyStoreAndSemanticClassification,
         enablePartialTypeChecking,
         enableParallelCheckingWithSignatureFiles,
-        parallelReferenceResolution
+        parallelReferenceResolution,
+        captureIdentifiersWhenParsing,
+        getSource,
+        useChangeNotifications
     ) =
 
     let backgroundCompiler =
@@ -1207,7 +1281,10 @@ type FSharpChecker
             enableBackgroundItemKeyStoreAndSemanticClassification,
             enablePartialTypeChecking,
             enableParallelCheckingWithSignatureFiles,
-            parallelReferenceResolution
+            parallelReferenceResolution,
+            captureIdentifiersWhenParsing,
+            getSource,
+            useChangeNotifications
         )
 
     static let globalInstance = lazy FSharpChecker.Create()
@@ -1250,7 +1327,9 @@ type FSharpChecker
             ?enableBackgroundItemKeyStoreAndSemanticClassification,
             ?enablePartialTypeChecking,
             ?enableParallelCheckingWithSignatureFiles,
-            ?parallelReferenceResolution
+            ?parallelReferenceResolution: bool,
+            ?captureIdentifiersWhenParsing: bool,
+            ?documentSource: DocumentSource
         ) =
 
         use _ = Activity.startNoTags "FSharpChecker.Create"
@@ -1272,6 +1351,12 @@ type FSharpChecker
 
         let enablePartialTypeChecking = defaultArg enablePartialTypeChecking false
         let enableParallelCheckingWithSignatureFiles = defaultArg enableParallelCheckingWithSignatureFiles false
+        let captureIdentifiersWhenParsing = defaultArg captureIdentifiersWhenParsing false
+
+        let useChangeNotifications =
+            match documentSource with
+            | Some (DocumentSource.Custom _) -> true
+            | _ -> false
 
         if keepAssemblyContents && enablePartialTypeChecking then
             invalidArg "enablePartialTypeChecking" "'keepAssemblyContents' and 'enablePartialTypeChecking' cannot be both enabled."
@@ -1289,14 +1374,22 @@ type FSharpChecker
             enableBackgroundItemKeyStoreAndSemanticClassification,
             enablePartialTypeChecking,
             enableParallelCheckingWithSignatureFiles,
-            parallelReferenceResolution
+            parallelReferenceResolution,
+            captureIdentifiersWhenParsing,
+            (match documentSource with
+             | Some (DocumentSource.Custom f) -> Some f
+             | _ -> None),
+            useChangeNotifications
         )
 
     member _.ReferenceResolver = legacyReferenceResolver
 
     member _.MatchBraces(fileName, sourceText: ISourceText, options: FSharpParsingOptions, ?userOpName: string) =
         let userOpName = defaultArg userOpName "Unknown"
-        use _ = Activity.start "FSharpChecker.MatchBraces" [| "fileName", fileName; "userOpName", userOpName |]
+
+        use _ =
+            Activity.start "FSharpChecker.MatchBraces" [| Activity.Tags.fileName, fileName; Activity.Tags.userOpName, userOpName |]
+
         let hash = sourceText.GetHashCode() |> int64
 
         async {
@@ -1348,7 +1441,7 @@ type FSharpChecker
 
     member _.Compile(argv: string[], ?userOpName: string) =
         let _userOpName = defaultArg userOpName "Unknown"
-        use _ = Activity.start "FSharpChecker.Compile" [| "userOpName", _userOpName |]
+        use _ = Activity.start "FSharpChecker.Compile" [| Activity.Tags.userOpName, _userOpName |]
 
         async {
             let ctok = CompilationThreadToken()
@@ -1391,6 +1484,12 @@ type FSharpChecker
         let userOpName = defaultArg userOpName "Unknown"
         backgroundCompiler.NotifyProjectCleaned(options, userOpName)
 
+    member _.NotifyFileChanged(fileName: string, options: FSharpProjectOptions, ?userOpName: string) =
+        let userOpName = defaultArg userOpName "Unknown"
+
+        backgroundCompiler.NotifyFileChanged(fileName, options, userOpName)
+        |> Async.AwaitNodeCode
+
     /// Typecheck a source code file, returning a handle to the results of the
     /// parse including the reconstructed types in the file.
     member _.CheckFileInProjectAllowingStaleCachedResults
@@ -1464,7 +1563,7 @@ type FSharpChecker
         let userOpName = defaultArg userOpName "Unknown"
 
         node {
-            if fastCheck <> Some true then
+            if fastCheck <> Some true || not captureIdentifiersWhenParsing then
                 return! backgroundCompiler.FindReferencesInFile(fileName, options, symbol, canInvalidateProject, userOpName)
             else
                 let! parseResults = backgroundCompiler.GetBackgroundParseResultsForFileInProject(fileName, options, userOpName)
diff --git a/src/Compiler/Service/service.fsi b/src/Compiler/Service/service.fsi
index 697e6ae2cb8..40b6b978690 100644
--- a/src/Compiler/Service/service.fsi
+++ b/src/Compiler/Service/service.fsi
@@ -16,6 +16,12 @@ open FSharp.Compiler.Syntax
 open FSharp.Compiler.Text
 open FSharp.Compiler.Tokenization
 
+[<Experimental "This type is experimental and likely to be removed in the future.">]
+[<RequireQualifiedAccess>]
+type DocumentSource =
+    | FileSystem
+    | Custom of (string -> ISourceText option)
+
 /// Used to parse and check F# source code.
 [<Sealed; AutoSerializable(false)>]
 type public FSharpChecker =
@@ -34,6 +40,8 @@ type public FSharpChecker =
     /// <param name="enablePartialTypeChecking">Indicates whether to perform partial type checking. Cannot be set to true if keepAssmeblyContents is true. If set to true, can cause duplicate type-checks when richer information on a file is needed, but can skip background type-checking entirely on implementation files with signature files.</param>
     /// <param name="enableParallelCheckingWithSignatureFiles">Type check implementation files that are backed by a signature file in parallel.</param>
     /// <param name="parallelReferenceResolution">Indicates whether to resolve references in parallel.</param>
+    /// <param name="captureIdentifiersWhenParsing">When set to true we create a set of all identifiers for each parsed file which can be used to speed up finding references.</param>
+    /// <param name="documentSource">Default: FileSystem. You can use Custom source to provide a function that will return the source for a given file path instead of reading it from the file system. Note that with this option the FSharpChecker will also not monitor the file system for file changes. It will expect to be notified of changes via the NotifyFileChanged method.</param>
     static member Create:
         ?projectCacheSize: int *
         ?keepAssemblyContents: bool *
@@ -45,7 +53,9 @@ type public FSharpChecker =
         ?enableBackgroundItemKeyStoreAndSemanticClassification: bool *
         ?enablePartialTypeChecking: bool *
         ?enableParallelCheckingWithSignatureFiles: bool *
-        ?parallelReferenceResolution: bool ->
+        ?parallelReferenceResolution: bool *
+        ?captureIdentifiersWhenParsing: bool *
+        [<Experimental "This parameter is experimental and likely to be removed in the future.">] ?documentSource: DocumentSource ->
             FSharpChecker
 
     /// <summary>
@@ -300,14 +310,14 @@ type public FSharpChecker =
     /// <param name="options">The options for the project or script, used to determine active --define conditionals and other options relevant to parsing.</param>
     /// <param name="symbol">The symbol to find all uses in the file.</param>
     /// <param name="canInvalidateProject">Default: true. If true, this call can invalidate the current state of project if the options have changed. If false, the current state of the project will be used.</param>
-    /// <param name="fastCheck">Default: false. Experimental feature that makes the operation faster.</param>
+    /// <param name="fastCheck">Default: false. Experimental feature that makes the operation faster. Requires FSharpChecker to be created with captureIdentifiersWhenParsing = true.</param>
     /// <param name="userOpName">An optional string used for tracing compiler operations associated with this request.</param>
     member FindBackgroundReferencesInFile:
         fileName: string *
         options: FSharpProjectOptions *
         symbol: FSharpSymbol *
         ?canInvalidateProject: bool *
-        ?fastCheck: bool *
+        [<Experimental("This FCS API is experimental and subject to change.")>] ?fastCheck: bool *
         ?userOpName: string ->
             Async<range seq>
 
@@ -374,6 +384,11 @@ type public FSharpChecker =
     /// Flush all caches and garbage collect
     member ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients: unit -> unit
 
+    /// Notify the checker that given file has changed. This needs to be used when checker is created with documentSource = Custom.
+    /// Although it is not mandatory when the changed file is the next thing requested to be checked.
+    [<Experimental "This FCS API is experimental and likely to be removed in the future.">]
+    member NotifyFileChanged: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<unit>
+
     /// <summary>
     /// This function is called when a project has been cleaned/rebuilt, and thus any live type providers should be refreshed.
     /// </summary>
diff --git a/src/Compiler/Symbols/SymbolHelpers.fs b/src/Compiler/Symbols/SymbolHelpers.fs
index a3232c3db39..5f028e020b6 100644
--- a/src/Compiler/Symbols/SymbolHelpers.fs
+++ b/src/Compiler/Symbols/SymbolHelpers.fs
@@ -229,14 +229,6 @@ module internal SymbolHelpers =
                 | Some dir -> Path.Combine(dir, file)
          else file
 
-    /// Cut long filenames to make them visually appealing 
-    let cutFileName s = if String.length s > 40 then String.sub s 0 10 + "..."+String.sub s (String.length s - 27) 27 else s
-
-    let libFileOfEntityRef x =
-        match x with
-        | ERefLocal _ -> None
-        | ERefNonLocal nlref -> nlref.Ccu.FileName      
-
     let ParamNameAndTypesOfUnaryCustomOperation g minfo = 
         match minfo with 
         | FSMeth(_, _, vref, _) -> 
@@ -517,14 +509,6 @@ module internal SymbolHelpers =
               | Item.DelegateCtor _
               | Item.ModuleOrNamespaces [] -> 0
               ) }
-
-    let ItemWithTypeDisplayPartialEquality g = 
-        let itemComparer = ItemDisplayPartialEquality g
-        
-        { new IPartialEqualityComparer<Item * _> with
-            member x.InEqualityRelation ((item, _)) = itemComparer.InEqualityRelation item
-            member x.Equals((item1, _), (item2, _)) = itemComparer.Equals(item1, item2)
-            member x.GetHashCode ((item, _)) = itemComparer.GetHashCode item }
     
     /// Remove all duplicate items
     let RemoveDuplicateItems g (items: ItemWithInst list) =     
diff --git a/src/Compiler/Symbols/SymbolPatterns.fs b/src/Compiler/Symbols/SymbolPatterns.fs
index e44375cb97c..44b77965a28 100644
--- a/src/Compiler/Symbols/SymbolPatterns.fs
+++ b/src/Compiler/Symbols/SymbolPatterns.fs
@@ -29,8 +29,6 @@ module FSharpSymbolPatterns =
                     res)))
             |> Option.isSome
 
-    let UnnamedUnionFieldRegex = Regex("^Item(\d+)?$", RegexOptions.Compiled)
-    
     let (|AbbreviatedType|_|) (entity: FSharpEntity) =
         if entity.IsFSharpAbbreviation then Some entity.AbbreviatedType
         else None
diff --git a/src/Compiler/Symbols/Symbols.fs b/src/Compiler/Symbols/Symbols.fs
index 499654b029a..56d19effb2a 100644
--- a/src/Compiler/Symbols/Symbols.fs
+++ b/src/Compiler/Symbols/Symbols.fs
@@ -1777,7 +1777,7 @@ type FSharpMemberOrFunctionOrValue(cenv, d:FSharpMemberOrValData, item) =
         if isUnresolved() then false else 
         match fsharpInfo() with 
         | None -> false
-        | Some v -> 
+        | Some v ->
         v.IsCompilerGenerated
 
     member _.InlineAnnotation = 
@@ -1826,6 +1826,14 @@ type FSharpMemberOrFunctionOrValue(cenv, d:FSharpMemberOrValData, item) =
         | P _ -> true
         | _ -> false
 
+    member x.HasSignatureFile =
+        match fsharpInfo() with
+        | None -> false
+        | Some vref ->
+            match vref.TryDeref with
+            | ValueNone -> false
+            | ValueSome v -> v.HasSignatureFile
+    
     member _.IsEvent = 
         match d with 
         | E _ -> true
diff --git a/src/Compiler/Symbols/Symbols.fsi b/src/Compiler/Symbols/Symbols.fsi
index 8a38e2cb03e..e9ce9d8b11e 100644
--- a/src/Compiler/Symbols/Symbols.fsi
+++ b/src/Compiler/Symbols/Symbols.fsi
@@ -816,6 +816,9 @@ type FSharpMemberOrFunctionOrValue =
     /// Indicates if this is a method member
     member IsMethod: bool
 
+    /// Indicates if the value has a signature file counterpart
+    member HasSignatureFile: bool
+
     /// Indicates if this is a property and there exists an associated getter method
     member HasGetterMethod: bool
 
diff --git a/src/Compiler/SyntaxTree/LexFilter.fs b/src/Compiler/SyntaxTree/LexFilter.fs
index 14a43332424..09f0bafbea0 100644
--- a/src/Compiler/SyntaxTree/LexFilter.fs
+++ b/src/Compiler/SyntaxTree/LexFilter.fs
@@ -149,11 +149,6 @@ let isInfix token =
     | QMARK_QMARK -> true
     | _ -> false
 
-let isNonAssocInfixToken token = 
-    match token with 
-    | EQUALS -> true
-    | _ -> false
-
 let infixTokenLength token = 
     match token with 
     | COMMA -> 1
@@ -393,16 +388,6 @@ let rec isWithAugmentBlockContinuator token =
     | ODUMMY token -> isWithAugmentBlockContinuator token
     | _ -> false
 
-let isLongIdentifier token =
-    match token with
-    | IDENT _ | DOT -> true
-    | _ -> false
-
-let isLongIdentifierOrGlobal token =
-    match token with
-    | GLOBAL | IDENT _ | DOT -> true
-    | _ -> false
-
 let isAtomicExprEndToken token = 
     match token with
     | IDENT _ 
diff --git a/src/Compiler/SyntaxTree/LexHelpers.fs b/src/Compiler/SyntaxTree/LexHelpers.fs
index ee6b39a5a93..f5c83752477 100644
--- a/src/Compiler/SyntaxTree/LexHelpers.fs
+++ b/src/Compiler/SyntaxTree/LexHelpers.fs
@@ -429,8 +429,6 @@ module Keywords =
 
         tab
 
-    let KeywordToken s = keywordTable[s]
-
     let IdentifierToken args (lexbuf: Lexbuf) (s: string) =
         if IsCompilerGeneratedName s then
             warning (Error(FSComp.SR.lexhlpIdentifiersContainingAtSymbolReserved (), lexbuf.LexemeRange))
diff --git a/src/Compiler/SyntaxTree/ParseHelpers.fs b/src/Compiler/SyntaxTree/ParseHelpers.fs
index fee75795e33..e181801324d 100644
--- a/src/Compiler/SyntaxTree/ParseHelpers.fs
+++ b/src/Compiler/SyntaxTree/ParseHelpers.fs
@@ -420,9 +420,9 @@ let (|GetIdent|SetIdent|OtherIdent|) (ident: Ident option) =
 
 let mkSynMemberDefnGetSet
     (parseState: IParseState)
-    (opt_inline: bool)
+    (opt_inline: range option)
     (mWith: range)
-    (classDefnMemberGetSetElements: (bool * SynAttributeList list * (SynPat * range) * (range option * SynReturnInfo) option * range option * SynExpr * range) list)
+    (classDefnMemberGetSetElements: (range option * SynAttributeList list * (SynPat * range) * (range option * SynReturnInfo) option * range option * SynExpr * range) list)
     (mAnd: range option)
     (mWhole: range)
     (propertyNameBindingPat: SynPat)
@@ -441,7 +441,7 @@ let mkSynMemberDefnGetSet
 
     let tryMkSynMemberDefnMember
         (
-            optInline,
+            mOptInline: range option,
             optAttrs: SynAttributeList list,
             (bindingPat, mBindLhs),
             optReturnType,
@@ -449,7 +449,7 @@ let mkSynMemberDefnGetSet
             expr,
             mExpr
         ) : (SynMemberDefn * Ident option) option =
-        let optInline = opt_inline || optInline
+        let optInline = Option.isSome opt_inline || Option.isSome mOptInline
         // optional attributes are only applied to getters and setters
         // the "top level" attrs will be applied to both
         let optAttrs =
@@ -469,6 +469,7 @@ let mkSynMemberDefnGetSet
         let trivia: SynBindingTrivia =
             {
                 LeadingKeyword = leadingKeyword
+                InlineKeyword = mOptInline
                 EqualsRange = mEquals
             }
 
@@ -729,6 +730,7 @@ let mkSynMemberDefnGetSet
                 if getOrSet.idText = "get" then
                     let trivia =
                         {
+                            InlineKeyword = opt_inline
                             WithKeyword = mWith
                             GetKeyword = Some getOrSet.idRange
                             AndKeyword = None
@@ -739,6 +741,7 @@ let mkSynMemberDefnGetSet
                 else
                     let trivia =
                         {
+                            InlineKeyword = opt_inline
                             WithKeyword = mWith
                             GetKeyword = None
                             AndKeyword = None
@@ -759,6 +762,7 @@ let mkSynMemberDefnGetSet
 
             let trivia =
                 {
+                    InlineKeyword = opt_inline
                     WithKeyword = mWith
                     GetKeyword = Some mGet
                     AndKeyword = mAnd
@@ -772,6 +776,7 @@ let mkSynMemberDefnGetSet
                 match getOrSet with
                 | GetIdent mGet ->
                     {
+                        InlineKeyword = opt_inline
                         WithKeyword = mWith
                         GetKeyword = Some mGet
                         AndKeyword = mAnd
@@ -779,6 +784,7 @@ let mkSynMemberDefnGetSet
                     }
                 | SetIdent mSet ->
                     {
+                        InlineKeyword = opt_inline
                         WithKeyword = mWith
                         GetKeyword = None
                         AndKeyword = mAnd
@@ -786,6 +792,7 @@ let mkSynMemberDefnGetSet
                     }
                 | OtherIdent ->
                     {
+                        InlineKeyword = opt_inline
                         WithKeyword = mWith
                         AndKeyword = mAnd
                         GetKeyword = None
@@ -899,6 +906,7 @@ let mkSynDoBinding (vis: SynAccess option, mDo, expr, m) =
         DebugPointAtBinding.NoneAtDo,
         {
             LeadingKeyword = SynLeadingKeyword.Do mDo
+            InlineKeyword = None
             EqualsRange = None
         }
     )
diff --git a/src/Compiler/SyntaxTree/ParseHelpers.fsi b/src/Compiler/SyntaxTree/ParseHelpers.fsi
index 353d8c973c6..46ae73f1ab0 100644
--- a/src/Compiler/SyntaxTree/ParseHelpers.fsi
+++ b/src/Compiler/SyntaxTree/ParseHelpers.fsi
@@ -164,9 +164,9 @@ val raiseParseErrorAt: range -> (int * string) -> 'a
 
 val mkSynMemberDefnGetSet:
     parseState: IParseState ->
-    opt_inline: bool ->
+    opt_inline: range option ->
     mWith: range ->
-    classDefnMemberGetSetElements: (bool * SynAttributeList list * (SynPat * range) * (range option * SynReturnInfo) option * range option * SynExpr * range) list ->
+    classDefnMemberGetSetElements: (range option * SynAttributeList list * (SynPat * range) * (range option * SynReturnInfo) option * range option * SynExpr * range) list ->
     mAnd: range option ->
     mWhole: range ->
     propertyNameBindingPat: SynPat ->
diff --git a/src/Compiler/SyntaxTree/SyntaxTree.fs b/src/Compiler/SyntaxTree/SyntaxTree.fs
index 30a864946a5..aa5535914d5 100644
--- a/src/Compiler/SyntaxTree/SyntaxTree.fs
+++ b/src/Compiler/SyntaxTree/SyntaxTree.fs
@@ -1197,8 +1197,7 @@ type SynEnumCase =
     | SynEnumCase of
         attributes: SynAttributes *
         ident: SynIdent *
-        value: SynConst *
-        valueRange: range *
+        valueExpr: SynExpr *
         xmlDoc: PreXmlDoc *
         range: range *
         trivia: SynEnumCaseTrivia
diff --git a/src/Compiler/SyntaxTree/SyntaxTree.fsi b/src/Compiler/SyntaxTree/SyntaxTree.fsi
index f878e5fa21f..5190b8fd736 100644
--- a/src/Compiler/SyntaxTree/SyntaxTree.fsi
+++ b/src/Compiler/SyntaxTree/SyntaxTree.fsi
@@ -1349,8 +1349,7 @@ type SynEnumCase =
     | SynEnumCase of
         attributes: SynAttributes *
         ident: SynIdent *
-        value: SynConst *
-        valueRange: range *
+        valueExpr: SynExpr *
         xmlDoc: PreXmlDoc *
         range: range *
         trivia: SynEnumCaseTrivia
@@ -1955,5 +1954,5 @@ type ParsedInput =
     /// Gets the #nowarn and other scoped pragmas
     member ScopedPragmas: ScopedPragma list
 
-    /// Gets a set of all identifiers used in this parsed input
+    /// Gets a set of all identifiers used in this parsed input. Only populated if captureIdentifiersWhenParsing option was used.
     member Identifiers: Set<string>
diff --git a/src/Compiler/SyntaxTree/SyntaxTrivia.fs b/src/Compiler/SyntaxTree/SyntaxTrivia.fs
index 160569564a3..dea3bfbc31a 100644
--- a/src/Compiler/SyntaxTree/SyntaxTrivia.fs
+++ b/src/Compiler/SyntaxTree/SyntaxTrivia.fs
@@ -224,12 +224,14 @@ type SynLeadingKeyword =
 type SynBindingTrivia =
     {
         LeadingKeyword: SynLeadingKeyword
+        InlineKeyword: range option
         EqualsRange: range option
     }
 
     static member Zero: SynBindingTrivia =
         {
             LeadingKeyword = SynLeadingKeyword.Synthetic
+            InlineKeyword = None
             EqualsRange = None
         }
 
@@ -288,6 +290,7 @@ type SynModuleOrNamespaceSigTrivia =
 type SynValSigTrivia =
     {
         LeadingKeyword: SynLeadingKeyword
+        InlineKeyword: range option
         WithKeyword: range option
         EqualsRange: range option
     }
@@ -295,6 +298,7 @@ type SynValSigTrivia =
     static member Zero: SynValSigTrivia =
         {
             LeadingKeyword = SynLeadingKeyword.Synthetic
+            InlineKeyword = None
             WithKeyword = None
             EqualsRange = None
         }
@@ -305,6 +309,7 @@ type SynTypeFunTrivia = { ArrowRange: range }
 [<NoEquality; NoComparison>]
 type SynMemberGetSetTrivia =
     {
+        InlineKeyword: range option
         WithKeyword: range
         GetKeyword: range option
         AndKeyword: range option
diff --git a/src/Compiler/SyntaxTree/SyntaxTrivia.fsi b/src/Compiler/SyntaxTree/SyntaxTrivia.fsi
index 555af5520ed..c76e3e99534 100644
--- a/src/Compiler/SyntaxTree/SyntaxTrivia.fsi
+++ b/src/Compiler/SyntaxTree/SyntaxTrivia.fsi
@@ -287,6 +287,9 @@ type SynBindingTrivia =
         /// Used leading keyword of SynBinding
         LeadingKeyword: SynLeadingKeyword
 
+        /// The syntax range of the `inline` keyword
+        InlineKeyword: range option
+
         /// The syntax range of the `=` token.
         EqualsRange: range option
     }
@@ -362,6 +365,9 @@ type SynValSigTrivia =
         /// but in case of `SynMemberDefn.AutoProperty` or `SynMemberDefn.AbstractSlot` it could be something else.
         LeadingKeyword: SynLeadingKeyword
 
+        /// The syntax range of the `inline` keyword
+        InlineKeyword: range option
+
         /// The syntax range of the `with` keyword
         WithKeyword: range option
 
@@ -383,6 +389,9 @@ type SynTypeFunTrivia =
 [<NoEquality; NoComparison>]
 type SynMemberGetSetTrivia =
     {
+        /// The syntax range of the `inline` keyword
+        InlineKeyword: range option
+
         /// The syntax range of the `with` keyword
         WithKeyword: range
 
diff --git a/src/Compiler/TypedTree/CompilerGlobalState.fs b/src/Compiler/TypedTree/CompilerGlobalState.fs
index b7eea4fb718..7047fc3cf35 100644
--- a/src/Compiler/TypedTree/CompilerGlobalState.fs
+++ b/src/Compiler/TypedTree/CompilerGlobalState.fs
@@ -4,7 +4,10 @@
 
 module FSharp.Compiler.CompilerGlobalState
 
+open System
 open System.Collections.Generic
+open System.Collections.Concurrent
+open System.Threading
 open FSharp.Compiler.Syntax.PrettyNaming
 open FSharp.Compiler.Text
 
@@ -15,26 +18,15 @@ open FSharp.Compiler.Text
 /// It is made concurrency-safe since a global instance of the type is allocated in tast.fs, and it is good
 /// policy to make all globally-allocated objects concurrency safe in case future versions of the compiler
 /// are used to host multiple concurrent instances of compilation.
-type NiceNameGenerator() =
-
-    let lockObj = obj()
-    let basicNameCounts = Dictionary<string, int>(100)
-
+type NiceNameGenerator() =    
+    let basicNameCounts = ConcurrentDictionary<string,Ref<int>>(max Environment.ProcessorCount 1, 127)
+   
     member _.FreshCompilerGeneratedName (name, m: range) =
-      lock lockObj (fun () ->
         let basicName = GetBasicNameOfPossibleCompilerGeneratedName name
-        let n =
-            match basicNameCounts.TryGetValue basicName with
-            | true, count -> count
-            | _ -> 0
-        let nm = CompilerGeneratedNameSuffix basicName (string m.StartLine + (match n with 0 -> "" | n -> "-" + string n))
-        basicNameCounts[basicName] <- n + 1
-        nm)
-
-    member _.Reset () =
-      lock lockObj (fun () ->
-        basicNameCounts.Clear()
-      )
+        let countCell = basicNameCounts.GetOrAdd(basicName,fun k -> ref 0)
+        let count = Interlocked.Increment(countCell)
+        
+        CompilerGeneratedNameSuffix basicName (string m.StartLine + (match (count-1) with 0 -> "" | n -> "-" + string n))
 
 /// Generates compiler-generated names marked up with a source code location, but if given the same unique value then
 /// return precisely the same name. Each name generated also includes the StartLine number of the range passed in
@@ -42,35 +34,15 @@ type NiceNameGenerator() =
 ///
 /// This type may be accessed concurrently, though in practice it is only used from the compilation thread.
 /// It is made concurrency-safe since a global instance of the type is allocated in tast.fs.
-type StableNiceNameGenerator() =
+type StableNiceNameGenerator() = 
 
-    let lockObj = obj()
-
-    let names = Dictionary<string * int64, string>(100)
-    let basicNameCounts = Dictionary<string, int>(100)
+    let niceNames = ConcurrentDictionary<string * int64, string>(max Environment.ProcessorCount 1, 127)
+    let innerGenerator = new NiceNameGenerator()
 
     member x.GetUniqueCompilerGeneratedName (name, m: range, uniq) =
-        lock lockObj (fun () ->
-            let basicName = GetBasicNameOfPossibleCompilerGeneratedName name
-            let key = basicName, uniq
-            match names.TryGetValue key with
-            | true, nm -> nm
-            | _ ->
-                let n =
-                    match basicNameCounts.TryGetValue basicName with
-                    | true, c -> c
-                    | _ -> 0
-                let nm = CompilerGeneratedNameSuffix basicName (string m.StartLine + (match n with 0 -> "" | n -> "-" + string n))
-                names[key] <- nm
-                basicNameCounts[basicName] <- n + 1
-                nm
-        )
-
-    member x.Reset () =
-      lock lockObj (fun () ->
-        basicNameCounts.Clear()
-        names.Clear()
-      )
+        let basicName = GetBasicNameOfPossibleCompilerGeneratedName name
+        let key = basicName, uniq
+        niceNames.GetOrAdd(key, fun _ -> innerGenerator.FreshCompilerGeneratedName(name, m))
 
 type internal CompilerGlobalState () =
     /// A global generator of compiler generated names
@@ -92,12 +64,10 @@ type internal CompilerGlobalState () =
 type Unique = int64
 
 //++GLOBAL MUTABLE STATE (concurrency-safe)
-let newUnique =
-    let i = ref 0L
-    fun () -> System.Threading.Interlocked.Increment i
+let mutable private uniqueCount = 0L
+let newUnique() = System.Threading.Interlocked.Increment &uniqueCount
 
 /// Unique name generator for stamps attached to to val_specs, tycon_specs etc.
 //++GLOBAL MUTABLE STATE (concurrency-safe)
-let newStamp =
-    let i = ref 0L
-    fun () -> System.Threading.Interlocked.Increment i
+let mutable private stampCount = 0L
+let newStamp() = System.Threading.Interlocked.Increment &stampCount
diff --git a/src/Compiler/TypedTree/CompilerGlobalState.fsi b/src/Compiler/TypedTree/CompilerGlobalState.fsi
index 105ab236f9e..6f0dba79ddf 100644
--- a/src/Compiler/TypedTree/CompilerGlobalState.fsi
+++ b/src/Compiler/TypedTree/CompilerGlobalState.fsi
@@ -17,7 +17,6 @@ type NiceNameGenerator =
 
     new: unit -> NiceNameGenerator
     member FreshCompilerGeneratedName: name: string * m: range -> string
-    member Reset: unit -> unit
 
 /// Generates compiler-generated names marked up with a source code location, but if given the same unique value then
 /// return precisely the same name. Each name generated also includes the StartLine number of the range passed in
@@ -29,7 +28,6 @@ type StableNiceNameGenerator =
 
     new: unit -> StableNiceNameGenerator
     member GetUniqueCompilerGeneratedName: name: string * m: range * uniq: int64 -> string
-    member Reset: unit -> unit
 
 type internal CompilerGlobalState =
 
diff --git a/src/Compiler/TypedTree/TcGlobals.fs b/src/Compiler/TypedTree/TcGlobals.fs
index bcb939e76ab..dd2f6e70f9e 100755
--- a/src/Compiler/TypedTree/TcGlobals.fs
+++ b/src/Compiler/TypedTree/TcGlobals.fs
@@ -1485,6 +1485,8 @@ type TcGlobals(
   member val unchecked_unary_not_vref = ValRefForIntrinsic v_unchecked_unary_not_info
   member val unchecked_subtraction_vref = ValRefForIntrinsic v_unchecked_subtraction_info
   member val unchecked_multiply_vref    = ValRefForIntrinsic v_unchecked_multiply_info
+  member val unchecked_division_vref    = ValRefForIntrinsic v_unchecked_division_info
+  member val unchecked_modulus_vref     = ValRefForIntrinsic v_unchecked_modulus_info
   member val unchecked_defaultof_vref    = ValRefForIntrinsic v_unchecked_defaultof_info
   member val refcell_deref_vref = ValRefForIntrinsic v_refcell_deref_info
   member val refcell_assign_vref = ValRefForIntrinsic v_refcell_assign_info
diff --git a/src/Compiler/TypedTree/TypedTree.fs b/src/Compiler/TypedTree/TypedTree.fs
index dfdc9640a0c..0adaac1f63e 100644
--- a/src/Compiler/TypedTree/TypedTree.fs
+++ b/src/Compiler/TypedTree/TypedTree.fs
@@ -1276,6 +1276,8 @@ type Entity =
 
     /// Indicates if we have pre-determined that a type definition has a self-referential constructor using 'as x'
     member x.HasSelfReferentialConstructor = x.entity_flags.HasSelfReferentialConstructor
+    
+    member x.HasSignatureFile = x.SigRange <> x.DefinitionRange
 
     /// Set the custom attributes on an F# type definition.
     member x.SetAttribs attribs = x.entity_attribs <- attribs
@@ -2803,6 +2805,9 @@ type Val =
     //  Indicates if this value was declared to be a type function, e.g. "let f<'a> = typeof<'a>"
     member x.IsTypeFunction = x.val_flags.IsTypeFunction
 
+    member x.HasSignatureFile =
+        x.SigRange <> x.DefinitionRange
+    
     /// Get the inline declaration on the value
     member x.InlineInfo = x.val_flags.InlineInfo
 
diff --git a/src/Compiler/TypedTree/TypedTree.fsi b/src/Compiler/TypedTree/TypedTree.fsi
index b63942d2c8c..621a9da12bd 100644
--- a/src/Compiler/TypedTree/TypedTree.fsi
+++ b/src/Compiler/TypedTree/TypedTree.fsi
@@ -571,6 +571,9 @@ type Entity =
     /// Indicates if we have pre-determined that a type definition has a self-referential constructor using 'as x'
     member HasSelfReferentialConstructor: bool
 
+    /// Indicates if the value has a signature file counterpart
+    member HasSignatureFile: bool
+
     /// Get the Abstract IL scope, nesting type metadata for this
     /// type definition, assuming it is backed by Abstract IL metadata.
     member ILTyconInfo: TILObjectReprData
@@ -2085,6 +2088,9 @@ type Val =
 
     member IsTypeFunction: bool
 
+    /// Indicates if the value has a signature file counterpart
+    member HasSignatureFile: bool
+
     /// The value of a value or member marked with [<LiteralAttribute>]
     member LiteralValue: Const option
 
diff --git a/src/Compiler/TypedTree/TypedTreeOps.fs b/src/Compiler/TypedTree/TypedTreeOps.fs
index 6fa70a5903e..b87db718b3a 100644
--- a/src/Compiler/TypedTree/TypedTreeOps.fs
+++ b/src/Compiler/TypedTree/TypedTreeOps.fs
@@ -141,22 +141,6 @@ let rec instTyparRef tpinst ty tp =
         if typarEq tp tpR then tyR 
         else instTyparRef t ty tp
 
-let instMeasureTyparRef tpinst unt (tp: Typar) =
-   match tp.Kind with 
-   | TyparKind.Measure ->
-        let rec loop tpinst = 
-            match tpinst with 
-            | [] -> unt
-            | (tpR, tyR) :: t -> 
-                if typarEq tp tpR then 
-                    match tyR with 
-                    | TType_measure unt -> unt
-                    | _ -> failwith "instMeasureTyparRef incorrect kind"
-                else
-                    loop t
-        loop tpinst
-   | _ -> failwith "instMeasureTyparRef: kind=Type"
-
 let remapTyconRef (tcmap: TyconRefMap<_>) tcref =
     match tcmap.TryFind tcref with 
     | Some tcref -> tcref
@@ -270,12 +254,6 @@ and remapTyparConstraintsAux tyenv cs =
          | TyparConstraint.IsReferenceType _ 
          | TyparConstraint.RequiresDefaultConstructor _ -> Some x)
 
-and remapTraitWitnessInfo tyenv (TraitWitnessInfo(tys, nm, flags, argTys, retTy)) =
-    let tysR = remapTypesAux tyenv tys
-    let argTysR = remapTypesAux tyenv argTys
-    let rtyR = Option.map (remapTypeAux tyenv) retTy
-    TraitWitnessInfo(tysR, nm, flags, argTysR, rtyR)
-
 and remapTraitInfo tyenv (TTrait(tys, nm, flags, argTys, retTy, slnCell)) =
     let slnCell = 
         match slnCell.Value with 
@@ -1253,8 +1231,6 @@ let isRefTupleExpr e = match e with Expr.Op (TOp.Tuple tupInfo, _, _, _) -> not
 
 let tryDestRefTupleExpr e = match e with Expr.Op (TOp.Tuple tupInfo, _, es, _) when not (evalTupInfoIsStruct tupInfo) -> es | _ -> [e]
 
-let rangeOfExpr (x: Expr) = x.Range
-
 //---------------------------------------------------------------------------
 // Build nodes in decision graphs
 //---------------------------------------------------------------------------
@@ -1356,10 +1332,6 @@ let mkCompGenBinds (vs: Val list) (es: Expr list) = List.map2 mkCompGenBind vs e
 
 let mkCompGenLet m v x body = mkLetBind m (mkCompGenBind v x) body
 
-let mkCompGenLets m vs xs body = mkLetsBind m (mkCompGenBinds vs xs) body
-
-let mkCompGenLetsFromBindings m vs xs body = mkLetsFromBindings m (mkCompGenBinds vs xs) body
-
 let mkInvisibleBind v e = TBind(v, e, DebugPointAtBinding.NoneAtInvisible)
 
 let mkInvisibleBinds (vs: Val list) (es: Expr list) = List.map2 mkInvisibleBind vs es
@@ -1604,13 +1576,13 @@ type TyconRefMultiMap<'T>(contents: TyconRefMap<'T list>) =
 //--------------------------------------------------------------------------
 
 /// Try to create a EntityRef suitable for accessing the given Entity from another assembly 
-let tryRescopeEntity viewedCcu (entity: Entity) : ValueOption<EntityRef> = 
+let tryRescopeEntity viewedCcu (entity: Entity) : EntityRef voption =
     match entity.PublicPath with 
     | Some pubpath -> ValueSome (ERefNonLocal (rescopePubPath viewedCcu pubpath))
     | None -> ValueNone
 
 /// Try to create a ValRef suitable for accessing the given Val from another assembly 
-let tryRescopeVal viewedCcu (entityRemap: Remap) (vspec: Val) : ValueOption<ValRef> =
+let tryRescopeVal viewedCcu (entityRemap: Remap) (vspec: Val) : ValRef voption =
     match vspec.PublicPath with 
     | Some (ValPubPath(p, fullLinkageKey)) -> 
         // The type information in the val linkage doesn't need to keep any information to trait solutions.
@@ -2270,11 +2242,6 @@ and accFreeInTrait opts (TTrait(tys, _, _, argTys, retTy, sln)) acc =
          (accFreeInTypes opts argTys 
            (Option.foldBack (accFreeInType opts) retTy acc)))
 
-and accFreeInWitnessArg opts (TraitWitnessInfo(tys, _nm, _mf, argTys, retTy)) acc = 
-       accFreeInTypes opts tys 
-         (accFreeInTypes opts argTys 
-           (Option.foldBack (accFreeInType opts) retTy acc))
-
 and accFreeInTraitSln opts sln acc = 
     match sln with 
     | ILMethSln(ty, _, _, minst, staticTyOpt) ->
@@ -2785,7 +2752,6 @@ let generalizedTyconRef (g: TcGlobals) tcref =
     let tinst = generalTyconRefInst tcref
     TType_app(tcref, tinst, g.knownWithoutNull)
 
-let isTTyparSupportsStaticMethod = function TyparConstraint.MayResolveMember _ -> true | _ -> false
 let isTTyparCoercesToType = function TyparConstraint.CoercesTo _ -> true | _ -> false
 
 //--------------------------------------------------------------------------
@@ -2919,8 +2885,6 @@ module PrettyTypes =
     let safeDestAnyParTy orig g ty = match tryAnyParTy g ty with ValueNone -> orig | ValueSome x -> x
 
     let foldUnurriedArgInfos f z (x: UncurriedArgInfos) = List.fold (fold1Of2 f) z x
-    let mapUnurriedArgInfos f (x: UncurriedArgInfos) = List.map (map1Of2 f) x
-
     let foldTypar f z (x: Typar) = foldOn mkTyparTy f z x
     let mapTypar g f (x: Typar) : Typar = (mkTyparTy >> f >> safeDestAnyParTy x g) x
 
@@ -3394,7 +3358,6 @@ let TryDecodeILAttribute tref (attrs: ILAttributes) =
 // F# view of attributes (these get converted to AbsIL attributes in ilxgen) 
 let IsMatchingFSharpAttribute g (AttribInfo(_, tcref)) (Attrib(tcref2, _, _, _, _, _, _)) = tyconRefEq g tcref tcref2
 let HasFSharpAttribute g tref attrs = List.exists (IsMatchingFSharpAttribute g tref) attrs
-let findAttrib g tref attrs = List.find (IsMatchingFSharpAttribute g tref) attrs
 let TryFindFSharpAttribute g tref attrs = List.tryFind (IsMatchingFSharpAttribute g tref) attrs
 let TryFindFSharpAttributeOpt g tref attrs = match tref with None -> None | Some tref -> List.tryFind (IsMatchingFSharpAttribute g tref) attrs
 
@@ -3742,6 +3705,28 @@ let (|SpecificUnopExpr|_|) g vrefReqd expr =
     | UnopExpr g (vref, arg1) when valRefEq g vref vrefReqd -> Some arg1
     | _ -> None
 
+let (|SignedConstExpr|_|) expr =
+    match expr with
+    | Expr.Const (Const.Int32 _, _, _)
+    | Expr.Const (Const.SByte _, _, _)
+    | Expr.Const (Const.Int16 _, _, _)
+    | Expr.Const (Const.Int64 _, _, _)
+    | Expr.Const (Const.Single _, _, _)
+    | Expr.Const (Const.Double _, _, _) -> Some ()
+    | _ -> None
+
+let (|IntegerConstExpr|_|) expr =
+    match expr with
+    | Expr.Const (Const.Int32 _, _, _)
+    | Expr.Const (Const.SByte _, _, _)
+    | Expr.Const (Const.Int16 _, _, _)
+    | Expr.Const (Const.Int64 _, _, _)
+    | Expr.Const (Const.Byte _, _, _)
+    | Expr.Const (Const.UInt16 _, _, _)
+    | Expr.Const (Const.UInt32 _, _, _)
+    | Expr.Const (Const.UInt64 _, _, _) -> Some ()
+    | _ -> None
+
 let (|SpecificBinopExpr|_|) g vrefReqd expr = 
     match expr with 
     | BinopExpr g (vref, arg1, arg2) when valRefEq g vref vrefReqd -> Some (arg1, arg2)
@@ -3829,20 +3814,10 @@ module DebugPrint =
     let mutable layoutStamps = false
     let mutable layoutValReprInfo = false
 
-    let squareAngleL l = LeftL.leftBracketAngle ^^ l ^^ RightL.rightBracketAngle
-
-    let angleL l = sepL leftAngle ^^ l ^^ rightL rightAngle
-
-    let braceL l = leftL leftBrace ^^ l ^^ rightL rightBrace
-
     let braceBarL l = leftL leftBraceBar ^^ l ^^ rightL rightBraceBar
 
-    let boolL b = if b then WordL.keywordTrue else WordL.keywordFalse
-
     let intL (n: int) = wordL (tagNumericLiteral (string n))
 
-    let int64L (n: int64) = wordL (tagNumericLiteral (string n))
-
     let qlistL f xmap = QueueList.foldBack (fun x z -> z @@ f x) xmap emptyL
 
     let bracketIfL b lyt = if b then bracketL lyt else lyt
@@ -3859,6 +3834,7 @@ module DebugPrint =
 
     let angleBracketListL l = angleBracketL (sepListL (sepL (tagText ",")) l)
 
+#if DEBUG
     let layoutMemberFlags (memFlags: SynMemberFlags) = 
         let stat = 
             if memFlags.IsInstance || (memFlags.MemberKind = SynMemberKind.Constructor) then emptyL 
@@ -3868,6 +3844,7 @@ module DebugPrint =
             elif memFlags.IsOverrideOrExplicitImpl then stat ++ wordL (tagText "override")
             else stat
         stat
+#endif
 
     let stampL (n: Stamp) w = 
         if layoutStamps then w ^^ wordL (tagText ("#" + string n)) else w
@@ -3976,8 +3953,6 @@ module DebugPrint =
 
     and auxTypar2L env typar = auxTyparWrapL env false typar
 
-    and auxTyparAtomL env typar = auxTyparWrapL env true typar
-
     and auxTyparConstraintTypL env ty = auxTypeL env ty
 
     and auxTraitL env (ttrait: TraitConstraintInfo) =
@@ -4034,8 +4009,6 @@ module DebugPrint =
 
     and typarL tp = auxTypar2L SimplifyTypes.typeSimplificationInfo0 tp 
 
-    and typarAtomL tp = auxTyparAtomL SimplifyTypes.typeSimplificationInfo0 tp
-
     and typeAtomL tau =
         let tau, cxs = tau, []
         let env = SimplifyTypes.CollectInfo false [tau] cxs
@@ -4098,6 +4071,7 @@ module DebugPrint =
           ^^ (if v.IsMutable then wordL(tagText "mutable ") else emptyL)
           ^^ (if layoutTypes then wordL (tagText ":") ^^ typeL v.Type else emptyL)
 
+#if DEBUG
     let tslotparamL (TSlotParam(nmOpt, ty, inFlag, outFlag, _, _)) =
         (optionL (tagText >> wordL) nmOpt) ^^ 
          wordL(tagText ":") ^^ 
@@ -4105,6 +4079,7 @@ module DebugPrint =
          (if inFlag then wordL(tagText "[in]") else emptyL) ^^ 
          (if outFlag then wordL(tagText "[out]") else emptyL) ^^ 
          (if inFlag then wordL(tagText "[opt]") else emptyL)
+#endif
 
     let slotSigL (slotsig: SlotSig) =
 #if DEBUG
@@ -4122,12 +4097,7 @@ module DebugPrint =
         wordL(tagText "slotsig")
 #endif
 
-    let rec memberL (g:TcGlobals) (v: Val) (membInfo: ValMemberInfo) = 
-        aboveListL 
-            [ wordL(tagText "compiled_name! = ") ^^ wordL (tagText (v.CompiledName g.CompilerGlobalState))
-              wordL(tagText "membInfo-slotsig! = ") ^^ listL slotSigL membInfo.ImplementedSlotSigs ]
-
-    and valAtBindL v =
+    let valAtBindL v =
         let vL = valL v
         let vL = (if v.IsMutable then wordL(tagText "mutable") ++ vL else vL)
         let vL =
@@ -4145,8 +4115,6 @@ module DebugPrint =
 
     let recdFieldRefL (rfref: RecdFieldRef) = wordL (tagText rfref.FieldName)
 
-    let identL (id: Ident) = wordL (tagText id.idText)
-
     // Note: We need nice printing of constants in order to print literals and attributes 
     let constL c =
         let str = 
@@ -4590,9 +4558,6 @@ module DebugPrint =
     and implFileL (CheckedImplFile (signature=implFileTy; contents=implFileContents)) =
         aboveListL [(wordL(tagText "top implementation ")) @@-- mexprL implFileTy implFileContents]
 
-    and ccuL (ccu: CcuThunk) =
-        entityL ccu.Contents
-
     let showType x = showL (typeL x)
 
     let showExpr x = showL (exprL x)
@@ -5633,9 +5598,6 @@ let bindLocalVal (v: Val) (v': Val) tmenv =
 let bindLocalVals vs vs' tmenv = 
     { tmenv with valRemap= (vs, vs', tmenv.valRemap) |||> List.foldBack2 (fun v v' acc -> acc.Add v (mkLocalValRef v') ) }
 
-let bindTycon (tc: Tycon) (tc': Tycon) tyenv = 
-    { tyenv with tyconRefRemap=tyenv.tyconRefRemap.Add (mkLocalTyconRef tc) (mkLocalTyconRef tc') }
-
 let bindTycons tcs tcs' tyenv =  
     { tyenv with tyconRefRemap= (tcs, tcs', tyenv.tyconRefRemap) |||> List.foldBack2 (fun tc tc' acc -> acc.Add (mkLocalTyconRef tc) (mkLocalTyconRef tc')) }
 
@@ -8007,8 +7969,6 @@ let TryDecodeTypeProviderAssemblyAttr (cattr: ILAttribute) : string MaybeNull op
 
 let tname_SignatureDataVersionAttr = FSharpLib.Core + ".FSharpInterfaceDataVersionAttribute"
 
-let tnames_SignatureDataVersionAttr = splitILTypeName tname_SignatureDataVersionAttr
-
 let tref_SignatureDataVersionAttr fsharpCoreAssemblyScopeRef = mkILTyRef(fsharpCoreAssemblyScopeRef, tname_SignatureDataVersionAttr)
 
 let mkSignatureDataVersionAttr (g: TcGlobals) (version: ILVersionInfo)  = 
@@ -8259,13 +8219,6 @@ let AdjustValForExpectedValReprInfo g m (vref: ValRef) flags valReprInfo =
     // Build a type-lambda expression for the toplevel value if needed... 
     mkTypeLambda m tpsR (tauexpr, tauty), tpsR +-> tauty
 
-let IsSubsumptionExpr g expr =
-    match expr with 
-    | Expr.Op (TOp.Coerce, [inputTy;actualTy], [_], _) ->
-        isFunTy g actualTy && isFunTy g inputTy   
-    | _ -> 
-        false
-
 let stripTupledFunTy g ty = 
     let argTys, retTy = stripFunTy g ty
     let curriedArgTys = argTys |> List.map (tryDestRefTupleTy g)
@@ -8832,7 +8785,6 @@ let XmlDocSigOfEntity (eref: EntityRef) =
 
 let enum_CompilationRepresentationAttribute_Static = 0b0000000000000001
 let enum_CompilationRepresentationAttribute_Instance = 0b0000000000000010
-let enum_CompilationRepresentationAttribute_StaticInstanceMask = 0b0000000000000011
 let enum_CompilationRepresentationAttribute_ModuleSuffix = 0b0000000000000100
 let enum_CompilationRepresentationAttribute_PermitNull = 0b0000000000001000
 
@@ -9551,11 +9503,11 @@ type Entity with
                 List.lengthsEqAndForall2 (typeEquiv g) (List.map fst argInfos) argTys &&  
                 membInfo.MemberFlags.IsOverrideOrExplicitImpl
             | _ -> false) 
-    
-    member tycon.HasMember g nm argTys = 
+
+    member tycon.TryGetMember g nm argTys = 
         tycon.TypeContents.tcaug_adhoc 
         |> NameMultiMap.find nm
-        |> List.exists (fun vref -> 
+        |> List.tryFind (fun vref -> 
             match vref.MemberInfo with 
             | None -> false 
             | _ ->
@@ -9564,7 +9516,8 @@ type Entity with
             match argInfos with
             | [argInfos] -> List.lengthsEqAndForall2 (typeEquiv g) (List.map fst argInfos) argTys
             | _ -> false) 
-
+    
+    member tycon.HasMember g nm argTys = (tycon.TryGetMember g nm argTys).IsSome
 
 type EntityRef with 
     member tcref.HasInterface g ty = tcref.Deref.HasInterface g ty
@@ -9647,12 +9600,46 @@ let IsSimpleSyntacticConstantExpr g inputExpr =
         checkExpr vrefs e
 
     checkExpr Set.empty inputExpr    
-    
-let EvalArithBinOp (opInt8, opInt16, opInt32, opInt64, opUInt8, opUInt16, opUInt32, opUInt64) (arg1: Expr) (arg2: Expr) = 
-    // At compile-time we check arithmetic 
+
+let EvalArithShiftOp (opInt8, opInt16, opInt32, opInt64, opUInt8, opUInt16, opUInt32, opUInt64) (arg1: Expr) (arg2: Expr) =
+    // At compile-time we check arithmetic
+    let m = unionRanges arg1.Range arg2.Range
+    try
+        match arg1, arg2 with
+        | Expr.Const (Const.Int32 x1, _, ty), Expr.Const (Const.Int32 shift, _, _) -> Expr.Const (Const.Int32 (opInt32 x1 shift), m, ty)
+        | Expr.Const (Const.SByte x1, _, ty), Expr.Const (Const.Int32 shift, _, _) -> Expr.Const (Const.SByte (opInt8 x1 shift), m, ty)
+        | Expr.Const (Const.Int16 x1, _, ty), Expr.Const (Const.Int32 shift, _, _) -> Expr.Const (Const.Int16 (opInt16 x1 shift), m, ty)
+        | Expr.Const (Const.Int64 x1, _, ty), Expr.Const (Const.Int32 shift, _, _) -> Expr.Const (Const.Int64 (opInt64 x1 shift), m, ty)
+        | Expr.Const (Const.Byte x1, _, ty), Expr.Const (Const.Int32 shift, _, _) -> Expr.Const (Const.Byte (opUInt8 x1 shift), m, ty)
+        | Expr.Const (Const.UInt16 x1, _, ty), Expr.Const (Const.Int32 shift, _, _) -> Expr.Const (Const.UInt16 (opUInt16 x1 shift), m, ty)
+        | Expr.Const (Const.UInt32 x1, _, ty), Expr.Const (Const.Int32 shift, _, _) -> Expr.Const (Const.UInt32 (opUInt32 x1 shift), m, ty)
+        | Expr.Const (Const.UInt64 x1, _, ty), Expr.Const (Const.Int32 shift, _, _) -> Expr.Const (Const.UInt64 (opUInt64 x1 shift), m, ty)
+        | _ -> error (Error ( FSComp.SR.tastNotAConstantExpression(), m))
+    with :? System.OverflowException -> error (Error ( FSComp.SR.tastConstantExpressionOverflow(), m))
+
+let EvalArithUnOp (opInt8, opInt16, opInt32, opInt64, opUInt8, opUInt16, opUInt32, opUInt64, opSingle, opDouble) (arg1: Expr) =
+    // At compile-time we check arithmetic
+    let m = arg1.Range
+    try
+        match arg1 with
+        | Expr.Const (Const.Int32 x1, _, ty) -> Expr.Const (Const.Int32 (opInt32 x1), m, ty)
+        | Expr.Const (Const.SByte x1, _, ty) -> Expr.Const (Const.SByte (opInt8 x1), m, ty)
+        | Expr.Const (Const.Int16 x1, _, ty) -> Expr.Const (Const.Int16 (opInt16 x1), m, ty)
+        | Expr.Const (Const.Int64 x1, _, ty) -> Expr.Const (Const.Int64 (opInt64 x1), m, ty)
+        | Expr.Const (Const.Byte x1, _, ty) -> Expr.Const (Const.Byte (opUInt8 x1), m, ty)
+        | Expr.Const (Const.UInt16 x1, _, ty) -> Expr.Const (Const.UInt16 (opUInt16 x1), m, ty)
+        | Expr.Const (Const.UInt32 x1, _, ty) -> Expr.Const (Const.UInt32 (opUInt32 x1), m, ty)
+        | Expr.Const (Const.UInt64 x1, _, ty) -> Expr.Const (Const.UInt64 (opUInt64 x1), m, ty)
+        | Expr.Const (Const.Single x1, _, ty) -> Expr.Const (Const.Single (opSingle x1), m, ty)
+        | Expr.Const (Const.Double x1, _, ty) -> Expr.Const (Const.Double (opDouble x1), m, ty)
+        | _ -> error (Error ( FSComp.SR.tastNotAConstantExpression(), m))
+    with :? System.OverflowException -> error (Error ( FSComp.SR.tastConstantExpressionOverflow(), m))
+
+let EvalArithBinOp (opInt8, opInt16, opInt32, opInt64, opUInt8, opUInt16, opUInt32, opUInt64, opSingle, opDouble) (arg1: Expr) (arg2: Expr) =
+    // At compile-time we check arithmetic
     let m = unionRanges arg1.Range arg2.Range
-    try 
-        match arg1, arg2 with 
+    try
+        match arg1, arg2 with
         | Expr.Const (Const.Int32 x1, _, ty), Expr.Const (Const.Int32 x2, _, _) -> Expr.Const (Const.Int32 (opInt32 x1 x2), m, ty)
         | Expr.Const (Const.SByte x1, _, ty), Expr.Const (Const.SByte x2, _, _) -> Expr.Const (Const.SByte (opInt8 x1 x2), m, ty)
         | Expr.Const (Const.Int16 x1, _, ty), Expr.Const (Const.Int16 x2, _, _) -> Expr.Const (Const.Int16 (opInt16 x1 x2), m, ty)
@@ -9661,11 +9648,18 @@ let EvalArithBinOp (opInt8, opInt16, opInt32, opInt64, opUInt8, opUInt16, opUInt
         | Expr.Const (Const.UInt16 x1, _, ty), Expr.Const (Const.UInt16 x2, _, _) -> Expr.Const (Const.UInt16 (opUInt16 x1 x2), m, ty)
         | Expr.Const (Const.UInt32 x1, _, ty), Expr.Const (Const.UInt32 x2, _, _) -> Expr.Const (Const.UInt32 (opUInt32 x1 x2), m, ty)
         | Expr.Const (Const.UInt64 x1, _, ty), Expr.Const (Const.UInt64 x2, _, _) -> Expr.Const (Const.UInt64 (opUInt64 x1 x2), m, ty)
+        | Expr.Const (Const.Single x1, _, ty), Expr.Const (Const.Single x2, _, _) -> Expr.Const (Const.Single (opSingle x1 x2), m, ty)
+        | Expr.Const (Const.Double x1, _, ty), Expr.Const (Const.Double x2, _, _) -> Expr.Const (Const.Double (opDouble x1 x2), m, ty)
         | _ -> error (Error ( FSComp.SR.tastNotAConstantExpression(), m))
     with :? System.OverflowException -> error (Error ( FSComp.SR.tastConstantExpressionOverflow(), m))
 
 // See also PostTypeCheckSemanticChecks.CheckAttribArgExpr, which must match this precisely
-let rec EvalAttribArgExpr g x = 
+let rec EvalAttribArgExpr (g: TcGlobals) x = 
+    let ignore (_x: 'a) = Unchecked.defaultof<'a>
+    let ignore2 (_x: 'a) (_y: 'a) = Unchecked.defaultof<'a>
+
+    let arithmeticInLiteralsEnabled = g.langVersion.SupportsFeature LanguageFeature.ArithmeticInLiterals
+
     match x with 
 
     // Detect standard constants 
@@ -9699,30 +9693,93 @@ let rec EvalAttribArgExpr g x =
         EvalAttribArgExpr g arg1
     // Detect bitwise or of attribute flags
     | AttribBitwiseOrExpr g (arg1, arg2) -> 
-        EvalArithBinOp ((|||), (|||), (|||), (|||), (|||), (|||), (|||), (|||)) (EvalAttribArgExpr g arg1) (EvalAttribArgExpr g arg2) 
-    | SpecificBinopExpr g g.unchecked_addition_vref (arg1, arg2) -> 
-       // At compile-time we check arithmetic 
-       let v1, v2 = EvalAttribArgExpr g arg1, EvalAttribArgExpr g arg2 
-       match v1, v2 with 
-       | Expr.Const (Const.String x1, m, ty), Expr.Const (Const.String x2, _, _) -> Expr.Const (Const.String (x1 + x2), m, ty)
-       | _ -> 
-#if ALLOW_ARITHMETIC_OPS_IN_LITERAL_EXPRESSIONS_AND_ATTRIBUTE_ARGS
-           EvalArithBinOp (Checked.(+), Checked.(+), Checked.(+), Checked.(+), Checked.(+), Checked.(+), Checked.(+), Checked.(+)) g v1 v2
-#else
-           errorR (Error ( FSComp.SR.tastNotAConstantExpression(), x.Range))
-           x
-#endif
-#if ALLOW_ARITHMETIC_OPS_IN_LITERAL_EXPRESSIONS_AND_ATTRIBUTE_ARGS
-    | SpecificBinopExpr g g.unchecked_subtraction_vref (arg1, arg2) -> 
-       EvalArithBinOp (Checked.(-), Checked.(-), Checked.(-), Checked.(-), Checked.(-), Checked.(-), Checked.(-), Checked.(-)) g (EvalAttribArgExpr g arg1) (EvalAttribArgExpr g arg2)
-    | SpecificBinopExpr g g.unchecked_multiply_vref (arg1, arg2) -> 
-       EvalArithBinOp (Checked.(*), Checked.(*), Checked.(*), Checked.(*), Checked.(*), Checked.(*), Checked.(*), Checked.(*)) g (EvalAttribArgExpr g arg1) (EvalAttribArgExpr g arg2)
-#endif
+        let v1 = EvalAttribArgExpr g arg1
+
+        match v1 with
+        | IntegerConstExpr ->
+            EvalArithBinOp ((|||), (|||), (|||), (|||), (|||), (|||), (|||), (|||), ignore2, ignore2) v1 (EvalAttribArgExpr g arg2) 
+        | _ ->
+            errorR (Error ( FSComp.SR.tastNotAConstantExpression(), x.Range))
+            x
+    | SpecificBinopExpr g g.unchecked_addition_vref (arg1, arg2) ->
+        // At compile-time we check arithmetic
+        let v1, v2 = EvalAttribArgExpr g arg1, EvalAttribArgExpr g arg2
+        match v1, v2 with
+        | Expr.Const (Const.String x1, m, ty), Expr.Const (Const.String x2, _, _) ->
+            Expr.Const (Const.String (x1 + x2), m, ty)
+        | Expr.Const (Const.Char x1, m, ty), Expr.Const (Const.Char x2, _, _) when arithmeticInLiteralsEnabled ->
+            Expr.Const (Const.Char (x1 + x2), m, ty)
+        | _ ->
+            if arithmeticInLiteralsEnabled then
+                EvalArithBinOp (Checked.(+), Checked.(+), Checked.(+), Checked.(+), Checked.(+), Checked.(+), Checked.(+), Checked.(+), Checked.(+), Checked.(+)) v1 v2
+            else
+                errorR (Error ( FSComp.SR.tastNotAConstantExpression(), x.Range))
+                x
+    | SpecificBinopExpr g g.unchecked_subtraction_vref (arg1, arg2) when arithmeticInLiteralsEnabled ->
+        let v1, v2 = EvalAttribArgExpr g arg1, EvalAttribArgExpr g arg2
+        match v1, v2 with
+        | Expr.Const (Const.Char x1, m, ty), Expr.Const (Const.Char x2, _, _) ->
+            Expr.Const (Const.Char (x1 - x2), m, ty)
+        | _ ->
+            EvalArithBinOp (Checked.(-), Checked.(-), Checked.(-), Checked.(-), Checked.(-), Checked.(-), Checked.(-), Checked.(-), Checked.(-), Checked.(-)) v1 v2
+    | SpecificBinopExpr g g.unchecked_multiply_vref (arg1, arg2) when arithmeticInLiteralsEnabled ->
+        EvalArithBinOp (Checked.(*), Checked.(*), Checked.(*), Checked.(*), Checked.(*), Checked.(*), Checked.(*), Checked.(*), Checked.(*), Checked.(*)) (EvalAttribArgExpr g arg1) (EvalAttribArgExpr g arg2)
+    | SpecificBinopExpr g g.unchecked_division_vref (arg1, arg2) when arithmeticInLiteralsEnabled ->
+        EvalArithBinOp ((/), (/), (/), (/), (/), (/), (/), (/), (/), (/)) (EvalAttribArgExpr g arg1) (EvalAttribArgExpr g arg2)
+    | SpecificBinopExpr g g.unchecked_modulus_vref (arg1, arg2) when arithmeticInLiteralsEnabled ->
+        EvalArithBinOp ((%), (%), (%), (%), (%), (%), (%), (%), (%), (%)) (EvalAttribArgExpr g arg1) (EvalAttribArgExpr g arg2)
+    | SpecificBinopExpr g g.bitwise_shift_left_vref (arg1, arg2) when arithmeticInLiteralsEnabled ->
+        EvalArithShiftOp ((<<<), (<<<), (<<<), (<<<), (<<<), (<<<), (<<<), (<<<)) (EvalAttribArgExpr g arg1) (EvalAttribArgExpr g arg2)
+    | SpecificBinopExpr g g.bitwise_shift_right_vref (arg1, arg2) when arithmeticInLiteralsEnabled ->
+        EvalArithShiftOp ((>>>), (>>>), (>>>), (>>>), (>>>), (>>>), (>>>), (>>>)) (EvalAttribArgExpr g arg1) (EvalAttribArgExpr g arg2)
+    | SpecificBinopExpr g g.bitwise_and_vref (arg1, arg2) when arithmeticInLiteralsEnabled ->
+        let v1 = EvalAttribArgExpr g arg1
+
+        match v1 with
+        | IntegerConstExpr ->
+            EvalArithBinOp ((&&&), (&&&), (&&&), (&&&), (&&&), (&&&), (&&&), (&&&), ignore2, ignore2) v1 (EvalAttribArgExpr g arg2)
+        | _ ->
+            errorR (Error ( FSComp.SR.tastNotAConstantExpression(), x.Range))
+            x
+    | SpecificUnopExpr g g.unchecked_unary_minus_vref arg1 when arithmeticInLiteralsEnabled ->
+        let v1 = EvalAttribArgExpr g arg1
+
+        match v1 with
+        | SignedConstExpr ->
+            EvalArithUnOp (Checked.(~-), Checked.(~-), Checked.(~-), Checked.(~-), ignore, ignore, ignore, ignore, Checked.(~-), Checked.(~-)) v1
+        | _ ->
+            errorR (Error ( FSComp.SR.tastNotAConstantExpression(), v1.Range))
+            x
+    | SpecificUnopExpr g g.unchecked_unary_plus_vref arg1 when arithmeticInLiteralsEnabled ->
+        EvalArithUnOp ((~+), (~+), (~+), (~+), (~+), (~+), (~+), (~+), (~+), (~+)) (EvalAttribArgExpr g arg1)
+    | SpecificUnopExpr g g.unchecked_unary_not_vref arg1 when arithmeticInLiteralsEnabled ->
+        match EvalAttribArgExpr g arg1 with
+        | Expr.Const (Const.Bool value, m, ty) ->
+            Expr.Const (Const.Bool (not value), m, ty)
+        | expr ->
+            errorR (Error ( FSComp.SR.tastNotAConstantExpression(), expr.Range))
+            x
+    // Detect logical operations on booleans, which are represented as a match expression
+    | Expr.Match (decision = TDSwitch (input = input; cases = [ TCase (DecisionTreeTest.Const (Const.Bool test), TDSuccess ([], targetNum)) ]); targets = [| TTarget (_, t0, _); TTarget (_, t1, _) |]) when arithmeticInLiteralsEnabled ->
+        match EvalAttribArgExpr g (stripDebugPoints input) with
+        | Expr.Const (Const.Bool value, _, _) ->
+            let pass, fail =
+                if targetNum = 0 then
+                    t0, t1
+                else
+                    t1, t0
+
+            if value = test then
+                EvalAttribArgExpr g (stripDebugPoints pass)
+            else
+                EvalAttribArgExpr g (stripDebugPoints fail)
+        | _ ->
+            errorR (Error ( FSComp.SR.tastNotAConstantExpression(), x.Range))
+            x
     | _ -> 
         errorR (Error ( FSComp.SR.tastNotAConstantExpression(), x.Range))
         x
 
-
 and EvaledAttribExprEquality g e1 e2 = 
     match e1, e2 with 
     | Expr.Const (c1, _, _), Expr.Const (c2, _, _) -> c1 = c2
@@ -10195,14 +10252,6 @@ let (|ResumableEntryMatchExpr|_|) g expr =
         | _ -> None
     | _ -> None
 
-let (|PossiblyCompiledTypeOfExpr|_|) g expr =
-    match expr with 
-    | TypeOfExpr g ty -> Some ty
-    | Expr.Op(TOp.ILCall (_, _, _, _, _, _, _, ilMethRef, _, _, _), [],[Expr.Op (TOp.ILAsm ([ I_ldtoken (ILToken.ILType _) ], _), [ty], _, _)], _)
-              when ilMethRef.DeclaringTypeRef.Name = "System.Type" && ilMethRef.Name = "GetTypeFromHandle" -> 
-        Some ty
-    | _ -> None
-
 let (|StructStateMachineExpr|_|) g expr =
     match expr with
     | ValApp g g.cgh__stateMachine_vref ([dataTy; _resultTy], [moveNext; setStateMachine; afterCode], _m) ->
diff --git a/src/Compiler/TypedTree/TypedTreeOps.fsi b/src/Compiler/TypedTree/TypedTreeOps.fsi
index ae58019683a..60bc899d662 100755
--- a/src/Compiler/TypedTree/TypedTreeOps.fsi
+++ b/src/Compiler/TypedTree/TypedTreeOps.fsi
@@ -665,7 +665,7 @@ val isTyparTy: TcGlobals -> TType -> bool
 
 val isAnyParTy: TcGlobals -> TType -> bool
 
-val tryAnyParTy: TcGlobals -> TType -> ValueOption<Typar>
+val tryAnyParTy: TcGlobals -> TType -> Typar voption
 
 val tryAnyParTyOption: TcGlobals -> TType -> Typar option
 
@@ -679,26 +679,26 @@ val isProvenUnionCaseTy: TType -> bool
 
 val isAppTy: TcGlobals -> TType -> bool
 
-val tryAppTy: TcGlobals -> TType -> ValueOption<TyconRef * TypeInst>
+val tryAppTy: TcGlobals -> TType -> (TyconRef * TypeInst) voption
 
 val destAppTy: TcGlobals -> TType -> TyconRef * TypeInst
 
 val tcrefOfAppTy: TcGlobals -> TType -> TyconRef
 
-val tryTcrefOfAppTy: TcGlobals -> TType -> ValueOption<TyconRef>
+val tryTcrefOfAppTy: TcGlobals -> TType -> TyconRef voption
 
-val tryDestTyparTy: TcGlobals -> TType -> ValueOption<Typar>
+val tryDestTyparTy: TcGlobals -> TType -> Typar voption
 
-val tryDestFunTy: TcGlobals -> TType -> ValueOption<TType * TType>
+val tryDestFunTy: TcGlobals -> TType -> (TType * TType) voption
 
-val tryDestAnonRecdTy: TcGlobals -> TType -> ValueOption<AnonRecdTypeInfo * TType list>
+val tryDestAnonRecdTy: TcGlobals -> TType -> (AnonRecdTypeInfo * TType list) voption
 
 val argsOfAppTy: TcGlobals -> TType -> TypeInst
 
 val mkInstForAppTy: TcGlobals -> TType -> TyparInstantiation
 
 /// Try to get a TyconRef for a type without erasing type abbreviations
-val tryNiceEntityRefOfTy: TType -> ValueOption<TyconRef>
+val tryNiceEntityRefOfTy: TType -> TyconRef voption
 
 val tryNiceEntityRefOfTyOption: TType -> TyconRef option
 
@@ -1089,7 +1089,7 @@ val tagEntityRefName: xref: EntityRef -> name: string -> TaggedText
 /// Return the full text for an item as we want it displayed to the user as a fully qualified entity
 val fullDisplayTextOfModRef: ModuleOrNamespaceRef -> string
 
-val fullDisplayTextOfParentOfModRef: ModuleOrNamespaceRef -> ValueOption<string>
+val fullDisplayTextOfParentOfModRef: ModuleOrNamespaceRef -> string voption
 
 val fullDisplayTextOfValRef: ValRef -> string
 
@@ -1303,10 +1303,10 @@ val wrapModuleOrNamespaceTypeInNamespace:
 val wrapModuleOrNamespaceType: Ident -> CompilationPath -> ModuleOrNamespaceType -> ModuleOrNamespace
 
 /// Given a namespace, module or type definition, try to produce a reference to that entity.
-val tryRescopeEntity: CcuThunk -> Entity -> ValueOption<EntityRef>
+val tryRescopeEntity: CcuThunk -> Entity -> EntityRef voption
 
 /// Given a value definition, try to produce a reference to that value. Fails for local values.
-val tryRescopeVal: CcuThunk -> Remap -> Val -> ValueOption<ValRef>
+val tryRescopeVal: CcuThunk -> Remap -> Val -> ValRef voption
 
 /// Make the substitution (remapping) table for viewing a module or namespace 'from the outside'
 ///
@@ -1526,7 +1526,7 @@ val isOptionTy: TcGlobals -> TType -> bool
 val destOptionTy: TcGlobals -> TType -> TType
 
 /// Try to take apart an option type
-val tryDestOptionTy: TcGlobals -> TType -> ValueOption<TType>
+val tryDestOptionTy: TcGlobals -> TType -> TType voption
 
 /// Try to take apart an option type
 val destValueOptionTy: TcGlobals -> TType -> TType
@@ -1535,7 +1535,7 @@ val destValueOptionTy: TcGlobals -> TType -> TType
 val isNullableTy: TcGlobals -> TType -> bool
 
 /// Try to take apart a System.Nullable type
-val tryDestNullableTy: TcGlobals -> TType -> ValueOption<TType>
+val tryDestNullableTy: TcGlobals -> TType -> TType voption
 
 /// Take apart a System.Nullable type
 val destNullableTy: TcGlobals -> TType -> TType
@@ -2449,6 +2449,8 @@ type Entity with
 
     member HasMember: TcGlobals -> string -> TType list -> bool
 
+    member internal TryGetMember: TcGlobals -> string -> TType list -> ValRef option
+
 type EntityRef with
 
     member HasInterface: TcGlobals -> TType -> bool
diff --git a/src/Compiler/TypedTree/TypedTreePickle.fs b/src/Compiler/TypedTree/TypedTreePickle.fs
index 90fd15fa1e2..f19ca1caaa1 100644
--- a/src/Compiler/TypedTree/TypedTreePickle.fs
+++ b/src/Compiler/TypedTree/TypedTreePickle.fs
@@ -240,8 +240,6 @@ let bits_of_float32 (x: float32) = System.BitConverter.ToInt32(System.BitConvert
 let bits_of_float (x: float) = System.BitConverter.DoubleToInt64Bits x
 
 let p_single i st = p_int32 (bits_of_float32 i) st
-let p_double i st = p_int64 (bits_of_float i) st
-let p_ieee64 i st = p_int64 (bits_of_float i) st
 let p_char i st = p_uint16 (uint16 (int32 i)) st
 
 let inline p_tup2 p1 p2 (a, b) (st: WriterState) =
@@ -259,18 +257,9 @@ let inline  p_tup5 p1 p2 p3 p4 p5 (a, b, c, d, e) (st: WriterState) =
 let inline  p_tup6 p1 p2 p3 p4 p5 p6 (a, b, c, d, e, f) (st: WriterState) =
     (p1 a st : unit); (p2 b st : unit); (p3 c st : unit); (p4 d st : unit); (p5 e st : unit); (p6 f st : unit)
 
-let inline  p_tup7 p1 p2 p3 p4 p5 p6 p7 (a, b, c, d, e, f, x7) (st: WriterState) =
-    (p1 a st : unit); (p2 b st : unit); (p3 c st : unit); (p4 d st : unit); (p5 e st : unit); (p6 f st : unit); (p7 x7 st : unit)
-
-let inline  p_tup8 p1 p2 p3 p4 p5 p6 p7 p8 (a, b, c, d, e, f, x7, x8) (st: WriterState) =
-    (p1 a st : unit); (p2 b st : unit); (p3 c st : unit); (p4 d st : unit); (p5 e st : unit); (p6 f st : unit); (p7 x7 st : unit); (p8 x8 st : unit)
-
 let inline  p_tup9 p1 p2 p3 p4 p5 p6 p7 p8 p9 (a, b, c, d, e, f, x7, x8, x9) (st: WriterState) =
     (p1 a st : unit); (p2 b st : unit); (p3 c st : unit); (p4 d st : unit); (p5 e st : unit); (p6 f st : unit); (p7 x7 st : unit); (p8 x8 st : unit); (p9 x9 st : unit)
 
-let inline  p_tup10 p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 (a, b, c, d, e, f, x7, x8, x9, x10) (st: WriterState) =
-    (p1 a st : unit); (p2 b st : unit); (p3 c st : unit); (p4 d st : unit); (p5 e st : unit); (p6 f st : unit); (p7 x7 st : unit); (p8 x8 st : unit); (p9 x9 st : unit); (p10 x10 st : unit)
-
 let inline  p_tup11 p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 (a, b, c, d, e, f, x7, x8, x9, x10, x11) (st: WriterState) =
     (p1 a st : unit); (p2 b st : unit); (p3 c st : unit); (p4 d st : unit); (p5 e st : unit); (p6 f st : unit); (p7 x7 st : unit); (p8 x8 st : unit); (p9 x9 st : unit); (p10 x10 st : unit); (p11 x11 st : unit)
 
@@ -327,10 +316,6 @@ let float32_of_bits (x: int32) = System.BitConverter.ToSingle(System.BitConverte
 let float_of_bits (x: int64) = System.BitConverter.Int64BitsToDouble x
 
 let u_single st = float32_of_bits (u_int32 st)
-let u_double st = float_of_bits (u_int64 st)
-
-let u_ieee64 st = float_of_bits (u_int64 st)
-
 let u_char st = char (int32 (u_uint16 st))
 let u_space n st =
     for i = 0 to n - 1 do
@@ -370,57 +355,18 @@ let inline u_tup5 p1 p2 p3 p4 p5 (st: ReaderState) =
 let inline u_tup6 p1 p2 p3 p4 p5 p6 (st: ReaderState) =
   let a = p1 st in let b = p2 st in let c = p3 st in let d = p4 st in let e = p5 st in let f = p6 st in (a, b, c, d, e, f)
 
-let inline u_tup7 p1 p2 p3 p4 p5 p6 p7 (st: ReaderState) =
-  let a = p1 st in let b = p2 st in let c = p3 st in let d = p4 st in let e = p5 st in let f = p6 st in let x7 = p7 st in (a, b, c, d, e, f, x7)
-
 let inline u_tup8 p1 p2 p3 p4 p5 p6 p7 p8 (st: ReaderState) =
   let a = p1 st in let b = p2 st in let c = p3 st in let d = p4 st in let e = p5 st in let f = p6 st in let x7 = p7 st in let x8 = p8 st in  (a, b, c, d, e, f, x7, x8)
 
 let inline u_tup9 p1 p2 p3 p4 p5 p6 p7 p8 p9 (st: ReaderState) =
   let a = p1 st in let b = p2 st in let c = p3 st in let d = p4 st in let e = p5 st in let f = p6 st in let x7 = p7 st in let x8 = p8 st in let x9 = p9 st in (a, b, c, d, e, f, x7, x8, x9)
 
-let inline u_tup10 p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 (st: ReaderState) =
-  let a = p1 st in let b = p2 st in let c = p3 st in let d = p4 st in
-  let e = p5 st in let f = p6 st in let x7 = p7 st in let x8 = p8 st in
-  let x9 = p9 st in let x10 = p10 st in (a, b, c, d, e, f, x7, x8, x9, x10)
-
-let inline u_tup11 p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 (st: ReaderState) =
-  let a = p1 st in let b = p2 st in let c = p3 st in let d = p4 st in
-  let e = p5 st in let f = p6 st in let x7 = p7 st in let x8 = p8 st in
-  let x9 = p9 st in let x10 = p10 st in let x11 = p11 st in (a, b, c, d, e, f, x7, x8, x9, x10, x11)
-
-let inline u_tup12 p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 p12 (st: ReaderState) =
-  let a = p1 st in let b = p2 st in let c = p3 st in let d = p4 st in
-  let e = p5 st in let f = p6 st in let x7 = p7 st in let x8 = p8 st in
-  let x9 = p9 st in let x10 = p10 st in let x11 = p11 st in let x12 = p12 st in
-  (a, b, c, d, e, f, x7, x8, x9, x10, x11, x12)
-
 let inline u_tup13 p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 p12 p13 (st: ReaderState) =
   let a = p1 st in let b = p2 st in let c = p3 st in let d = p4 st in
   let e = p5 st in let f = p6 st in let x7 = p7 st in let x8 = p8 st in
   let x9 = p9 st in let x10 = p10 st in let x11 = p11 st in let x12 = p12 st in let x13 = p13 st in
   (a, b, c, d, e, f, x7, x8, x9, x10, x11, x12, x13)
 
-let inline u_tup14 p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 p12 p13 p14 (st: ReaderState) =
-  let a = p1 st in let b = p2 st in let c = p3 st in let d = p4 st in
-  let e = p5 st in let f = p6 st in let x7 = p7 st in let x8 = p8 st in
-  let x9 = p9 st in let x10 = p10 st in let x11 = p11 st in let x12 = p12 st in let x13 = p13 st in
-  let x14 = p14 st in
-  (a, b, c, d, e, f, x7, x8, x9, x10, x11, x12, x13, x14)
-let inline u_tup15 p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 p12 p13 p14 p15 (st: ReaderState) =
-  let a = p1 st in let b = p2 st in let c = p3 st in let d = p4 st in
-  let e = p5 st in let f = p6 st in let x7 = p7 st in let x8 = p8 st in
-  let x9 = p9 st in let x10 = p10 st in let x11 = p11 st in let x12 = p12 st in let x13 = p13 st in
-  let x14 = p14 st in let x15 = p15 st in
-  (a, b, c, d, e, f, x7, x8, x9, x10, x11, x12, x13, x14, x15)
-
-let inline u_tup16 p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 p12 p13 p14 p15 p16 (st: ReaderState) =
-  let a = p1 st in let b = p2 st in let c = p3 st in let d = p4 st in
-  let e = p5 st in let f = p6 st in let x7 = p7 st in let x8 = p8 st in
-  let x9 = p9 st in let x10 = p10 st in let x11 = p11 st in let x12 = p12 st in let x13 = p13 st in
-  let x14 = p14 st in let x15 = p15 st in let x16 = p16 st in
-  (a, b, c, d, e, f, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16)
-
 let inline u_tup17 p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 p12 p13 p14 p15 p16 p17 (st: ReaderState) =
   let a = p1 st in let b = p2 st in let c = p3 st in let d = p4 st in
   let e = p5 st in let f = p6 st in let x7 = p7 st in let x8 = p8 st in
@@ -489,17 +435,6 @@ let p_array f (x: 'T[]) st =
     p_int x.Length st
     p_array_core f x st
 
-// Optionally encode an extra item using a marker bit.
-// When extraf is None, the marker bit is not set, and this is identical to p_array.
-let p_array_ext extraf f (x: 'T[]) st =
-    let n = x.Length
-    let n = if Option.isSome extraf then n ||| 0x80000000 else n
-    p_int n st
-    match extraf with
-    | None -> ()
-    | Some f -> f st
-    p_array_core f x st
-
 let p_list_core f (xs: 'T list) st =
     for x in xs do
         f x st
@@ -587,18 +522,6 @@ let u_array f st =
     let n = u_int st
     u_array_core f n st
 
-// Optionally decode an extra item if a marker bit is present.
-// When the marker bit is not set this is identical to u_array, and extraf is not called
-let u_array_ext extraf f st =
-    let n = u_int st
-    let extraItem =
-        if n &&& 0x80000000 = 0x80000000 then
-            Some (extraf st)
-        else
-            None
-    let arr = u_array_core f (n &&& 0x7FFFFFFF) st
-    extraItem, arr
-
 let u_list_core f n st =
     List.init n (fun _ -> f st)
 
@@ -628,13 +551,6 @@ let u_List f st = List(u_array f st)
 let u_List f st = u_array f st
 #endif
 
-let u_array_revi f st =
-    let n = u_int st
-    let res = Array.zeroCreate n
-    for i = 0 to n-1 do
-        res[i] <- f st (n-1-i)
-    res
-
 // Mark up default constraints with a priority in reverse order: last gets 0 etc. See comment on TyparConstraint.DefaultsTo
 let u_list_revi f st =
     let n = u_int st
@@ -706,18 +622,13 @@ let lookup_string st stringTab x = lookup_uniq st stringTab x
 let u_encoded_string = u_prim_string
 let u_string st   = lookup_uniq st st.istrings (u_int st)
 let u_strings = u_list u_string
-let u_ints = u_list u_int
-
-
 let p_encoded_string = p_prim_string
 let p_string s st = p_int (encode_string st.ostrings s) st
 let p_strings = p_list p_string
-let p_ints = p_list p_int
 
 // CCU References
 // A huge number of these occur in pickled F# data, so make them unique
 let encode_ccuref ccuTab (x: CcuThunk) = encode_uniq ccuTab x.AssemblyName
-let decode_ccuref x = x
 let lookup_ccuref st ccuTab x = lookup_uniq st ccuTab x
 let u_encoded_ccuref st =
     match u_byte st with
@@ -734,7 +645,6 @@ let p_ccuref s st = p_int (encode_ccuref st.occus s) st
 // References to public items in this module
 // A huge number of these occur in pickled F# data, so make them unique
 let decode_pubpath st stringTab a = PubPath(Array.map (lookup_string st stringTab) a)
-let lookup_pubpath st pubpathTab x = lookup_uniq st pubpathTab x
 let u_encoded_pubpath = u_array u_int
 let u_pubpath st = lookup_uniq st st.ipubpaths (u_int st)
 
@@ -771,13 +681,10 @@ let p_nleref x st = p_int (encode_nleref st.occus st.ostrings st.onlerefs st.osc
 // Simple types are types like "int", represented as TType(Ref_nonlocal(..., "int"), []).
 // A huge number of these occur in pickled F# data, so make them unique.
 let decode_simpletyp st _ccuTab _stringTab nlerefTab a = TType_app(ERefNonLocal (lookup_nleref st nlerefTab a), [], 0uy)
-let lookup_simpletyp st simpleTyTab x = lookup_uniq st simpleTyTab x
 let u_encoded_simpletyp st = u_int  st
-let u_encoded_anoninfo st = u_int  st
 let u_simpletyp st = lookup_uniq st st.isimpletys (u_int st)
 let encode_simpletyp ccuTab stringTab nlerefTab simpleTyTab thisCcu a = encode_uniq simpleTyTab (encode_nleref ccuTab stringTab nlerefTab thisCcu a)
 let p_encoded_simpletyp x st = p_int x st
-let p_encoded_anoninfo x st = p_int x st
 let p_simpletyp x st = p_int (encode_simpletyp st.occus st.ostrings st.onlerefs st.osimpletys st.oscope x) st
 
 /// Arbitrary value
@@ -1152,7 +1059,6 @@ let [<Literal>] itag_shr_un        = 17
 let [<Literal>] itag_neg           = 18
 let [<Literal>] itag_not           = 19
 let [<Literal>] itag_conv          = 20
-let [<Literal>] itag_conv_un       = 21
 let [<Literal>] itag_conv_ovf      = 22
 let [<Literal>] itag_conv_ovf_un   = 23
 let [<Literal>] itag_callvirt      = 24
@@ -1881,9 +1787,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 in (CompPath(a, b))
 
-
-let rec dummy x = x
-and p_tycon_repr x st =
+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.
     match x with
     | TFSharpRecdRepr fs         -> p_byte 1 st; p_byte 0 st; p_rfield_table fs st; false
@@ -1922,8 +1826,6 @@ and p_unioncase_spec x st =
     p_string x.XmlDocSig st
     p_access x.Accessibility st
 
-and p_exnc_spec_data x st = p_entity_spec_data x st
-
 and p_exnc_repr x st =
     match x with
     | TExnAbbrevRepr x -> p_byte 0 st; (p_tcref "exn abbrev") x st
@@ -1931,8 +1833,6 @@ and p_exnc_repr x st =
     | TExnFresh x      -> p_byte 2 st; p_rfield_table x st
     | TExnNone         -> p_byte 3 st
 
-and p_exnc_spec x st = p_entity_spec x st
-
 and p_access (TAccess n) st = p_list p_cpath n st
 
 and p_recdfield_spec x st =
@@ -2149,8 +2049,6 @@ and u_unioncase_spec st =
       Accessibility=i
       OtherRangeOpt=None }
 
-and u_exnc_spec_data st = u_entity_spec_data st
-
 and u_exnc_repr st =
     let tag = u_byte st
     match tag with
@@ -2160,8 +2058,6 @@ and u_exnc_repr st =
     | 3 -> TExnNone
     | _ -> ufailwith st "u_exnc_repr"
 
-and u_exnc_spec st = u_entity_spec st
-
 and u_access st =
     match u_list u_cpath st with
     | [] -> taccessPublic // save unnecessary allocations
diff --git a/src/Compiler/Utilities/Activity.fs b/src/Compiler/Utilities/Activity.fs
index 2ae87433ce5..a5f8000cfa0 100644
--- a/src/Compiler/Utilities/Activity.fs
+++ b/src/Compiler/Utilities/Activity.fs
@@ -4,11 +4,62 @@ namespace FSharp.Compiler.Diagnostics
 
 open System
 open System.Diagnostics
+open System.IO
+open System.Text
 
 [<RequireQualifiedAccess>]
-module Activity =
+module internal Activity =
+
+    module Tags =
+        let fileName = "fileName"
+        let project = "project"
+        let qualifiedNameOfFile = "qualifiedNameOfFile"
+        let userOpName = "userOpName"
+        let length = "length"
+        let cache = "cache"
+        let cpuDelta = "cpuDelta(s)"
+        let realDelta = "realDelta(s)"
+        let gc0 = "gc0"
+        let gc1 = "gc1"
+        let gc2 = "gc2"
+        let outputDllFile = "outputDllFile"
+
+        let AllKnownTags =
+            [|
+                fileName
+                project
+                qualifiedNameOfFile
+                userOpName
+                length
+                cache
+                cpuDelta
+                realDelta
+                gc0
+                gc1
+                gc2
+                outputDllFile
+            |]
 
     let private activitySourceName = "fsc"
+    let private profiledSourceName = "fsc_with_env_stats"
+
+    type System.Diagnostics.Activity with
+
+        member this.RootId =
+            let rec rootID (act: Activity) =
+                if isNull act.ParentId then act.Id else rootID act.Parent
+
+            rootID this
+
+        member this.Depth =
+            let rec depth (act: Activity) acc =
+                if isNull act.ParentId then
+                    acc
+                else
+                    depth act.Parent (acc + 1)
+
+            depth this 0
+
     let private activitySource = new ActivitySource(activitySourceName)
 
     let start (name: string) (tags: (string * string) seq) : IDisposable =
@@ -23,3 +74,168 @@ module Activity =
         activity
 
     let startNoTags (name: string) : IDisposable = activitySource.StartActivity(name)
+
+    module Profiling =
+
+        module Tags =
+            let workingSetMB = "workingSet(MB)"
+            let gc0 = "gc0"
+            let gc1 = "gc1"
+            let gc2 = "gc2"
+            let handles = "handles"
+            let threads = "threads"
+
+            let profilingTags = [| workingSetMB; gc0; gc1; gc2; handles; threads |]
+
+        let private profiledSource = new ActivitySource(profiledSourceName)
+
+        let startAndMeasureEnvironmentStats (name: string) : IDisposable = profiledSource.StartActivity(name)
+
+        type private GCStats = int[]
+
+        let private collectGCStats () : GCStats =
+            [| for i in 0 .. GC.MaxGeneration -> GC.CollectionCount i |]
+
+        let private addStatsMeasurementListener () =
+            let gcStatsInnerTag = "#gc_stats_internal"
+
+            let l =
+                new ActivityListener(
+                    ShouldListenTo = (fun a -> a.Name = profiledSourceName),
+                    Sample = (fun _ -> ActivitySamplingResult.AllData),
+                    ActivityStarted = (fun a -> a.AddTag(gcStatsInnerTag, collectGCStats ()) |> ignore),
+                    ActivityStopped =
+                        (fun a ->
+                            let statsBefore = a.GetTagItem(gcStatsInnerTag) :?> GCStats
+                            let statsAfter = collectGCStats ()
+                            let p = Process.GetCurrentProcess()
+                            a.AddTag(Tags.workingSetMB, p.WorkingSet64 / 1_000_000L) |> ignore
+                            a.AddTag(Tags.handles, p.HandleCount) |> ignore
+                            a.AddTag(Tags.threads, p.Threads.Count) |> ignore
+
+                            for i = 0 to statsAfter.Length - 1 do
+                                a.AddTag($"gc{i}", statsAfter[i] - statsBefore[i]) |> ignore)
+
+                )
+
+            ActivitySource.AddActivityListener(l)
+            l
+
+        let addConsoleListener () =
+            let statsMeasurementListener = addStatsMeasurementListener ()
+
+            let reportingStart = DateTime.UtcNow
+            let nameColumnWidth = 36
+
+            let header =
+                "|"
+                + "Phase name".PadRight(nameColumnWidth)
+                + "|Elapsed |Duration| WS(MB)|  GC0  |  GC1  |  GC2  |Handles|Threads|"
+
+            let consoleWriterListener =
+                new ActivityListener(
+                    ShouldListenTo = (fun a -> a.Name = profiledSourceName),
+                    Sample = (fun _ -> ActivitySamplingResult.AllData),
+                    ActivityStopped =
+                        (fun a ->
+                            Console.Write('|')
+                            let indentedName = new String('>', a.Depth) + a.DisplayName
+                            Console.Write(indentedName.PadRight(nameColumnWidth))
+
+                            let elapsed = (a.StartTimeUtc + a.Duration - reportingStart).TotalSeconds
+                            Console.Write("|{0,8:N4}|{1,8:N4}|", elapsed, a.Duration.TotalSeconds)
+
+                            for t in Tags.profilingTags do
+                                Console.Write("{0,7}|", a.GetTagItem(t))
+
+                            Console.WriteLine())
+                )
+
+            Console.WriteLine(new String('-', header.Length))
+            Console.WriteLine(header)
+            Console.WriteLine(header |> String.map (fun c -> if c = '|' then c else '-'))
+
+            ActivitySource.AddActivityListener(consoleWriterListener)
+
+            { new IDisposable with
+                member this.Dispose() =
+                    statsMeasurementListener.Dispose()
+                    consoleWriterListener.Dispose()
+                    Console.WriteLine(new String('-', header.Length))
+            }
+
+    module CsvExport =
+
+        let private escapeStringForCsv (o: obj) =
+            if isNull o then
+                ""
+            else
+                let mutable txtVal = o.ToString()
+                let hasComma = txtVal.IndexOf(',') > -1
+                let hasQuote = txtVal.IndexOf('"') > -1
+
+                if hasQuote then
+                    txtVal <- txtVal.Replace("\"", "\\\"")
+
+                if hasQuote || hasComma then
+                    "\"" + txtVal + "\""
+                else
+                    txtVal
+
+        let private createCsvRow (a: Activity) =
+            let sb = new StringBuilder(128)
+
+            let appendWithLeadingComma (s: string) =
+                sb.Append(',') |> ignore
+                sb.Append(s) |> ignore
+
+            // "Name,StartTime,EndTime,Duration,Id,ParentId"
+            sb.Append(a.DisplayName) |> ignore
+            appendWithLeadingComma (a.StartTimeUtc.ToString("HH-mm-ss.ffff"))
+            appendWithLeadingComma ((a.StartTimeUtc + a.Duration).ToString("HH-mm-ss.ffff"))
+            appendWithLeadingComma (a.Duration.TotalSeconds.ToString("000.0000", System.Globalization.CultureInfo.InvariantCulture))
+            appendWithLeadingComma (a.Id)
+            appendWithLeadingComma (a.ParentId)
+            appendWithLeadingComma (a.RootId)
+
+            Tags.AllKnownTags
+            |> Array.iter (fun t -> a.GetTagItem(t) |> escapeStringForCsv |> appendWithLeadingComma)
+
+            sb.ToString()
+
+        let addCsvFileListener pathToFile =
+            if pathToFile |> File.Exists |> not then
+                File.WriteAllLines(
+                    pathToFile,
+                    [
+                        "Name,StartTime,EndTime,Duration(s),Id,ParentId,RootId,"
+                        + String.concat "," Tags.AllKnownTags
+                    ]
+                )
+
+            let sw = new StreamWriter(path = pathToFile, append = true)
+
+            let msgQueue =
+                MailboxProcessor<string>.Start
+                    (fun inbox ->
+                        async {
+                            while true do
+                                let! msg = inbox.Receive()
+                                do! sw.WriteLineAsync(msg) |> Async.AwaitTask
+                        })
+
+            let l =
+                new ActivityListener(
+                    ShouldListenTo = (fun a -> a.Name = activitySourceName || a.Name = profiledSourceName),
+                    Sample = (fun _ -> ActivitySamplingResult.AllData),
+                    ActivityStopped = (fun a -> msgQueue.Post(createCsvRow a))
+                )
+
+            ActivitySource.AddActivityListener(l)
+
+            { new IDisposable with
+                member this.Dispose() =
+                    l.Dispose() // Unregister from listening new activities first
+                    (msgQueue :> IDisposable).Dispose() // Wait for the msg queue to be written out
+                    sw.Dispose() // Only then flush the messages and close the file
+            }
diff --git a/src/Compiler/Utilities/Activity.fsi b/src/Compiler/Utilities/Activity.fsi
index edf0d890c19..746422455bf 100644
--- a/src/Compiler/Utilities/Activity.fsi
+++ b/src/Compiler/Utilities/Activity.fsi
@@ -9,6 +9,21 @@ open System
 [<RequireQualifiedAccess>]
 module internal Activity =
 
+    module Tags =
+        val fileName: string
+        val qualifiedNameOfFile: string
+        val project: string
+        val userOpName: string
+        val length: string
+        val cache: string
+
     val startNoTags: name: string -> IDisposable
 
     val start: name: string -> tags: (string * string) seq -> IDisposable
+
+    module Profiling =
+        val startAndMeasureEnvironmentStats: name: string -> IDisposable
+        val addConsoleListener: unit -> IDisposable
+
+    module CsvExport =
+        val addCsvFileListener: pathToFile: string -> IDisposable
diff --git a/src/Compiler/Utilities/FileSystem.fs b/src/Compiler/Utilities/FileSystem.fs
index 722978e8513..1614400bb48 100644
--- a/src/Compiler/Utilities/FileSystem.fs
+++ b/src/Compiler/Utilities/FileSystem.fs
@@ -35,8 +35,6 @@ module internal Bytes =
 
     let zeroCreate n : byte[] = Array.zeroCreate n
 
-    let sub (b: byte[]) s l = Array.sub b s l
-
     let blit (a: byte[]) b c d e = Array.blit a b c d e
 
     let ofInt32Array (arr: int[]) =
diff --git a/src/Compiler/Utilities/ImmutableArray.fs b/src/Compiler/Utilities/ImmutableArray.fs
index 985799856c0..87774061fb1 100644
--- a/src/Compiler/Utilities/ImmutableArray.fs
+++ b/src/Compiler/Utilities/ImmutableArray.fs
@@ -74,36 +74,6 @@ module ImmutableArray =
 
             builder.MoveToImmutable()
 
-    let map2 (mapper: 'T1 -> 'T2 -> 'T) (arr1: ImmutableArray<'T1>) (arr2: ImmutableArray<'T2>) : ImmutableArray<_> =
-        if arr1.Length <> arr2.Length then
-            invalidOp "Block lengths do not match."
-
-        match arr1.Length with
-        | 0 -> ImmutableArray.Empty
-        | 1 -> ImmutableArray.Create(mapper arr1[0] arr2[0])
-        | n ->
-            let builder = ImmutableArray.CreateBuilder(n)
-
-            for i = 0 to n - 1 do
-                builder.Add(mapper arr1[i] arr2[i])
-
-            builder.MoveToImmutable()
-
-    let mapi2 (mapper: int -> 'T1 -> 'T2 -> 'T) (arr1: ImmutableArray<'T1>) (arr2: ImmutableArray<'T2>) : ImmutableArray<_> =
-        if arr1.Length <> arr2.Length then
-            invalidOp "Block lengths do not match."
-
-        match arr1.Length with
-        | 0 -> ImmutableArray.Empty
-        | 1 -> ImmutableArray.Create(mapper 0 arr1[0] arr2[0])
-        | n ->
-            let builder = ImmutableArray.CreateBuilder(n)
-
-            for i = 0 to n - 1 do
-                builder.Add(mapper i arr1[i] arr2[i])
-
-            builder.MoveToImmutable()
-
     let concat (arrs: ImmutableArray<ImmutableArray<'T>>) : ImmutableArray<'T> =
         match arrs.Length with
         | 0 -> ImmutableArray.Empty
diff --git a/src/Compiler/Utilities/illib.fs b/src/Compiler/Utilities/illib.fs
index d0bb8f7843b..0161ac65167 100644
--- a/src/Compiler/Utilities/illib.fs
+++ b/src/Compiler/Utilities/illib.fs
@@ -85,27 +85,17 @@ module internal PervasiveAutoOpens =
         | Some x -> x
 
     let reportTime =
-        let mutable tFirst = None
-        let mutable tPrev = None
+        let mutable tPrev: IDisposable = null
 
-        fun showTimes descr ->
-            if showTimes then
-                let t = Process.GetCurrentProcess().UserProcessorTime.TotalSeconds
+        fun descr ->
+            if isNotNull tPrev then
+                tPrev.Dispose()
 
-                let prev =
-                    match tPrev with
-                    | None -> 0.0
-                    | Some t -> t
-
-                let first =
-                    match tFirst with
-                    | None ->
-                        (tFirst <- Some t
-                         t)
-                    | Some t -> t
-
-                printf "  ilwrite: Cpu %4.1f (total)   %4.1f (delta) - %s\n" (t - first) (t - prev) descr
-                tPrev <- Some t
+            tPrev <-
+                if descr <> "Finish" then
+                    FSharp.Compiler.Diagnostics.Activity.Profiling.startAndMeasureEnvironmentStats descr
+                else
+                    null
 
     let foldOn p f z x = f z (p x)
 
@@ -918,10 +908,6 @@ module Cancellable =
     let token () =
         Cancellable(fun ct -> ValueOrCancelled.Value ct)
 
-    /// Represents a canceled computation
-    let canceled () =
-        Cancellable(fun ct -> ValueOrCancelled.Cancelled(OperationCanceledException ct))
-
 type CancellableBuilder() =
 
     member inline _.Delay([<InlineIfLambda>] f) =
@@ -1041,28 +1027,21 @@ module CancellableAutoOpens =
 
 /// Generates unique stamps
 type UniqueStampGenerator<'T when 'T: equality>() =
-    let gate = obj ()
-    let encodeTab = ConcurrentDictionary<'T, int>(HashIdentity.Structural)
-    let mutable nItems = 0
+    let encodeTable = ConcurrentDictionary<'T, Lazy<int>>(HashIdentity.Structural)
+    let mutable nItems = -1
 
-    let encode str =
-        match encodeTab.TryGetValue str with
-        | true, idx -> idx
-        | _ ->
-            lock gate (fun () ->
-                let idx = nItems
-                encodeTab[str] <- idx
-                nItems <- nItems + 1
-                idx)
+    let computeFunc = Func<'T, _>(fun _ -> lazy (Interlocked.Increment(&nItems)))
 
-    member _.Encode str = encode str
+    member _.Encode str =
+        encodeTable.GetOrAdd(str, computeFunc).Value
 
-    member _.Table = encodeTab.Keys
+    member _.Table = encodeTable.Keys
 
 /// memoize tables (all entries cached, never collected)
 type MemoizationTable<'T, 'U>(compute: 'T -> 'U, keyComparer: IEqualityComparer<'T>, ?canMemoize) =
 
-    let table = new ConcurrentDictionary<'T, 'U>(keyComparer)
+    let table = new ConcurrentDictionary<'T, Lazy<'U>>(keyComparer)
+    let computeFunc = Func<_, _>(fun key -> lazy (compute key))
 
     member t.Apply x =
         if
@@ -1070,19 +1049,32 @@ type MemoizationTable<'T, 'U>(compute: 'T -> 'U, keyComparer: IEqualityComparer<
              | None -> true
              | Some f -> f x)
         then
-            match table.TryGetValue x with
-            | true, res -> res
-            | _ ->
-                lock table (fun () ->
-                    match table.TryGetValue x with
-                    | true, res -> res
-                    | _ ->
-                        let res = compute x
-                        table[x] <- res
-                        res)
+            table.GetOrAdd(x, computeFunc).Value
         else
             compute x
 
+/// A thread-safe lookup table which is assigning an auto-increment stamp with each insert
+type internal StampedDictionary<'T, 'U>(keyComparer: IEqualityComparer<'T>) =
+    let table = new ConcurrentDictionary<'T, Lazy<int * 'U>>(keyComparer)
+    let mutable count = -1
+
+    member _.Add(key, value) =
+        let entry = table.GetOrAdd(key, lazy (Interlocked.Increment(&count), value))
+        entry.Force() |> ignore
+
+    member _.UpdateIfExists(key, valueReplaceFunc) =
+        match table.TryGetValue key with
+        | true, v ->
+            let (stamp, oldVal) = v.Value
+
+            match valueReplaceFunc oldVal with
+            | None -> ()
+            | Some newVal -> table.TryUpdate(key, lazy (stamp, newVal), v) |> ignore<bool>
+        | _ -> ()
+
+    member _.GetAll() =
+        table |> Seq.map (fun kvp -> kvp.Key, kvp.Value.Value)
+
 exception UndefinedException
 
 type LazyWithContextFailure(exn: exn) =
diff --git a/src/Compiler/Utilities/illib.fsi b/src/Compiler/Utilities/illib.fsi
index 40f8c8f8162..26c8fb21db4 100644
--- a/src/Compiler/Utilities/illib.fsi
+++ b/src/Compiler/Utilities/illib.fsi
@@ -48,7 +48,7 @@ module internal PervasiveAutoOpens =
     /// We set the limit to be 80k to account for larger pointer sizes for when F# is running 64-bit.
     val LOH_SIZE_THRESHOLD_BYTES: int
 
-    val reportTime: (bool -> string -> unit)
+    val reportTime: (string -> unit)
 
     /// Get an initialization hole
     val getHole: r: 'a option ref -> 'a
@@ -438,6 +438,17 @@ type internal MemoizationTable<'T, 'U> =
 
     member Apply: x: 'T -> 'U
 
+/// A thread-safe lookup table which is assigning an auto-increment stamp with each insert
+type internal StampedDictionary<'T, 'U> =
+
+    new: keyComparer: IEqualityComparer<'T> -> StampedDictionary<'T, 'U>
+
+    member Add: key: 'T * value: 'U -> unit
+
+    member UpdateIfExists: key: 'T * valueReplaceFunc: ('U -> 'U option) -> unit
+
+    member GetAll: unit -> seq<'T * (int * 'U)>
+
 exception internal UndefinedException
 
 type internal LazyWithContextFailure =
diff --git a/src/Compiler/Utilities/lib.fs b/src/Compiler/Utilities/lib.fs
index d791bec524c..3db24c66462 100755
--- a/src/Compiler/Utilities/lib.fs
+++ b/src/Compiler/Utilities/lib.fs
@@ -21,7 +21,7 @@ let mutable progress = false
 // Intended to be a general hook to control diagnostic output when tracking down bugs
 let mutable tracking = false
 
-let condition s =
+let isEnvVarSet s =
     try (Environment.GetEnvironmentVariable(s) <> null) with _ -> false
 
 let GetEnvInteger e dflt = match Environment.GetEnvironmentVariable(e) with null -> dflt | t -> try int t with _ -> dflt
@@ -73,37 +73,6 @@ module NameMap =
     let domain m = Map.foldBack (fun x _ acc -> Zset.add x acc) m (Zset.empty String.order)
     let domainL m = Zset.elements (domain m)
 
-// Library: Pre\Post checks
-//-------------------------------------------------------------------------
-module Check =
-
-    /// Throw <cref>System.InvalidOperationException</cref> if argument is <c>None</c>.
-    /// If there is a value (e.g. <c>Some(value)</c>) then value is returned.
-    let NotNone argName (arg:'T option) : 'T =
-        match arg with
-        | None -> raise (InvalidOperationException(argName))
-        | Some x -> x
-
-    /// Throw <cref>System.ArgumentNullException</cref> if argument is <c>null</c>.
-    let ArgumentNotNull arg argName =
-        match box(arg) with
-        | null -> raise (ArgumentNullException(argName))
-        | _ -> ()
-
-    /// Throw <cref>System.ArgumentNullException</cref> if array argument is <c>null</c>.
-    /// Throw <cref>System.ArgumentOutOfRangeException</cref> is array argument is empty.
-    let ArrayArgumentNotNullOrEmpty (arr:'T[]) argName =
-        ArgumentNotNull arr argName
-        if (0 = arr.Length) then
-            raise (ArgumentOutOfRangeException(argName))
-
-    /// Throw <cref>System.ArgumentNullException</cref> if string argument is <c>null</c>.
-    /// Throw <cref>System.ArgumentOutOfRangeException</cref> is string argument is empty.
-    let StringArgumentNotNullOrEmpty (s:string) argName =
-        ArgumentNotNull s argName
-        if s.Length = 0 then
-            raise (ArgumentNullException(argName))
-
 //-------------------------------------------------------------------------
 // Library
 //------------------------------------------------------------------------
@@ -285,8 +254,6 @@ let mapTriple (f1, f2, f3) (a1, a2, a3) = (f1 a1, f2 a2, f3 a3)
 
 let mapQuadruple (f1, f2, f3, f4) (a1, a2, a3, a4) = (f1 a1, f2 a2, f3 a3, f4 a4)
 
-let fmap2Of2 f z (a1, a2) = let z, a2 = f z a2 in z, (a1, a2)
-
 //---------------------------------------------------------------------------
 // Zmap rebinds
 //-------------------------------------------------------------------------
@@ -312,8 +279,6 @@ module Zset =
         if Zset.equal s s0 then s0 (* fixed *)
         else fixpoint f s (* iterate *)
 
-let equalOn f x y = (f x) = (f y)
-
 /// Buffer printing utility
 let buildString f =
     let buf = StringBuilder 100
@@ -420,92 +385,6 @@ type Dumper(x:obj) =
      [<DebuggerBrowsable(DebuggerBrowsableState.Collapsed)>]
      member self.Dump = sprintf "%A" x
 #endif
-
-//---------------------------------------------------------------------------
-// AsyncUtil
-//---------------------------------------------------------------------------
-
-module internal AsyncUtil =
-    open Microsoft.FSharp.Control
-
-    /// Represents the reified result of an asynchronous computation.
-    [<NoEquality; NoComparison>]
-    type AsyncResult<'T> =
-        | AsyncOk of 'T
-        | AsyncException of exn
-        | AsyncCanceled of OperationCanceledException
-
-        static member Commit(res:AsyncResult<'T>) =
-            Async.FromContinuations (fun (cont, eCont, cCont) ->
-                    match res with
-                    | AsyncOk v -> cont v
-                    | AsyncException exn -> eCont exn
-                    | AsyncCanceled exn -> cCont exn)
-
-    /// When using .NET 4.0 you can replace this type by <see cref="Task{T}"/>
-    [<Sealed>]
-    type AsyncResultCell<'T>() =
-        let mutable result = None
-        // The continuation for the result, if any
-        let mutable savedConts = []
-
-        let syncRoot = obj()
-
-
-        // Record the result in the AsyncResultCell.
-        // Ignore subsequent sets of the result. This can happen, e.g. for a race between
-        // a cancellation and a success.
-        member x.RegisterResult (res:AsyncResult<'T>) =
-            let grabbedConts =
-                lock syncRoot (fun () ->
-                    if result.IsSome then
-                        []
-                    else
-                        result <- Some res
-                        // Invoke continuations in FIFO order
-                        // Continuations that Async.FromContinuations provide do QUWI/SyncContext.Post,
-                        // so the order is not overly relevant but still.
-                        List.rev savedConts)
-            let postOrQueue (sc:SynchronizationContext, cont) =
-                match sc with
-                |   null -> ThreadPool.QueueUserWorkItem(fun _ -> cont res) |> ignore
-                |   sc -> sc.Post((fun _ -> cont res), state=null)
-
-            // Run continuations outside the lock
-            match grabbedConts with
-            |   [] -> ()
-            |   [sc, cont as c] ->
-                    if SynchronizationContext.Current = sc then
-                        cont res
-                    else
-                        postOrQueue c
-            |   _ ->
-                    grabbedConts |> List.iter postOrQueue
-
-        /// Get the reified result.
-        member private x.AsyncPrimitiveResult =
-            Async.FromContinuations(fun (cont, _, _) ->
-                let grabbedResult =
-                    lock syncRoot (fun () ->
-                        match result with
-                        | Some _ ->
-                            result
-                        | None ->
-                            // Otherwise save the continuation and call it in RegisterResult
-                            let sc = SynchronizationContext.Current
-                            savedConts <- (sc, cont) :: savedConts
-                            None)
-                // Run the action outside the lock
-                match grabbedResult with
-                | None -> ()
-                | Some res -> cont res)
-
-
-        /// Get the result and Commit(...).
-        member x.AsyncResult =
-            async { let! res = x.AsyncPrimitiveResult
-                    return! AsyncResult.Commit(res) }
-
 //---------------------------------------------------------------------------
 // EnableHeapTerminationOnCorruption()
 //---------------------------------------------------------------------------
diff --git a/src/Compiler/Utilities/lib.fsi b/src/Compiler/Utilities/lib.fsi
index bab85ccd414..2e6b0318f7a 100644
--- a/src/Compiler/Utilities/lib.fsi
+++ b/src/Compiler/Utilities/lib.fsi
@@ -15,7 +15,7 @@ val mutable progress: bool
 
 val mutable tracking: bool
 
-val condition: s: string -> bool
+val isEnvVarSet: s: string -> bool
 
 val GetEnvInteger: e: string -> dflt: int -> int
 
@@ -64,22 +64,6 @@ module NameMap =
 
     val domainL: m: Map<string, 'a> -> string list
 
-module Check =
-    /// Throw <cref>System.InvalidOperationException</cref> if argument is <c>None</c>.
-    /// If there is a value (e.g. <c>Some(value)</c>) then value is returned.
-    val NotNone: argName: string -> arg: 'T option -> 'T
-
-    /// Throw <cref>System.ArgumentNullException</cref> if argument is <c>null</c>.
-    val ArgumentNotNull: arg: 'a -> argName: string -> unit
-
-    /// Throw <cref>System.ArgumentNullException</cref> if array argument is <c>null</c>.
-    /// Throw <cref>System.ArgumentOutOfRangeException</cref> is array argument is empty.
-    val ArrayArgumentNotNullOrEmpty: arr: 'T[] -> argName: string -> unit
-
-    /// Throw <cref>System.ArgumentNullException</cref> if string argument is <c>null</c>.
-    /// Throw <cref>System.ArgumentOutOfRangeException</cref> is string argument is empty.
-    val StringArgumentNotNullOrEmpty: s: string -> argName: string -> unit
-
 type IntMap<'T> = Zmap<int, 'T>
 
 module IntMap =
@@ -214,8 +198,6 @@ val mapQuadruple:
         a1: 'a * a2: 'c * a3: 'e * a4: 'g ->
             'b * 'd * 'f * 'h
 
-val fmap2Of2: f: ('a -> 'b -> 'c * 'd) -> z: 'a -> a1: 'e * a2: 'b -> 'c * ('e * 'd)
-
 module Zmap =
     val force: k: 'a -> mp: Zmap<'a, 'b> -> 'b
     val mapKey: key: 'a -> f: ('b option -> 'b option) -> mp: Zmap<'a, 'b> -> Zmap<'a, 'b>
@@ -224,8 +206,6 @@ module Zset =
     val ofList: order: IComparer<'a> -> xs: 'a list -> Zset<'a>
     val fixpoint: f: (Zset<'a> -> Zset<'a>) -> Zset<'a> -> Zset<'a>
 
-val equalOn: f: ('a -> 'b) -> x: 'a -> y: 'a -> bool when 'b: equality
-
 /// Buffer printing utility
 val buildString: f: (StringBuilder -> unit) -> string
 
@@ -267,25 +247,6 @@ val inline cacheOptRef: cache: 'a option ref -> f: (unit -> 'a) -> 'a
 
 val inline tryGetCacheValue: cache: cache<'a> -> NonNullSlot<'a> voption
 
-module AsyncUtil =
-
-    /// Represents the reified result of an asynchronous computation.
-    [<NoEquality; NoComparison>]
-    type AsyncResult<'T> =
-        | AsyncOk of 'T
-        | AsyncException of exn
-        | AsyncCanceled of System.OperationCanceledException
-
-        static member Commit: res: AsyncResult<'T> -> Async<'T>
-
-    /// When using .NET 4.0 you can replace this type by <see cref="Task{T}"/>
-    [<Sealed>]
-    type AsyncResultCell<'T> =
-
-        new: unit -> AsyncResultCell<'T>
-        member RegisterResult: res: AsyncResult<'T> -> unit
-        member AsyncResult: Async<'T>
-
 module UnmanagedProcessExecutionOptions =
     val EnableHeapTerminationOnCorruption: unit -> unit
 
diff --git a/src/Compiler/Utilities/sformat.fs b/src/Compiler/Utilities/sformat.fs
index 303e2f968b5..5d42dae0b45 100644
--- a/src/Compiler/Utilities/sformat.fs
+++ b/src/Compiler/Utilities/sformat.fs
@@ -119,7 +119,6 @@ type IEnvironment =
 [<AutoOpen>]
 module TaggedText =
     let mkTag tag text = TaggedText(tag, text)
-
     let length (tt: TaggedText) = tt.Text.Length
     let toText (tt: TaggedText) = tt.Text
     let tagClass name = mkTag TextTag.Class name
@@ -135,8 +134,6 @@ module TaggedText =
     let tagMethod t = mkTag TextTag.Method t
     let tagPunctuation t = mkTag TextTag.Punctuation t
     let tagOperator t = mkTag TextTag.Operator t
-    let tagSpace t = mkTag TextTag.Space t
-
     let leftParen = tagPunctuation "("
     let rightParen = tagPunctuation ")"
     let comma = tagPunctuation ","
@@ -146,7 +143,6 @@ module TaggedText =
     let rightBracket = tagPunctuation "]"
     let leftBrace = tagPunctuation "{"
     let rightBrace = tagPunctuation "}"
-    let space = tagSpace " "
     let equals = tagOperator "="
 
 #if COMPILER
@@ -201,6 +197,7 @@ module TaggedText =
     let tagFunction t = mkTag TextTag.Function t
     let tagNamespace t = mkTag TextTag.Namespace t
     let tagParameter t = mkTag TextTag.Parameter t
+    let tagSpace t = mkTag TextTag.Space t
     let tagStruct t = mkTag TextTag.Struct t
     let tagTypeParameter t = mkTag TextTag.TypeParameter t
     let tagActivePatternCase t = mkTag TextTag.ActivePatternCase t
@@ -212,6 +209,7 @@ module TaggedText =
 
     // common tagged literals
     let lineBreak = tagLineBreak "\n"
+    let space = tagSpace " "
     let leftBraceBar = tagPunctuation "{|"
     let rightBraceBar = tagPunctuation "|}"
     let arrow = tagPunctuation "->"
@@ -784,6 +782,7 @@ module Display =
         let rstrs, _ = addL z0 0 layout
         extract rstrs
 
+#if COMPILER
     let outL outAttribute leafFormatter (chan: TaggedTextWriter) layout =
         // write layout to output chan directly
         let write s = chan.Write(s)
@@ -828,6 +827,7 @@ module Display =
 
         let _ = addL z0 0 layout
         ()
+#endif
 
     let unpackCons recd =
         match recd with
@@ -923,6 +923,7 @@ module Display =
 
         "\"" + s + "\""
 
+#if COMPILER
     // Return a truncated version of the string, e.g.
     //   "This is the initial text, which has been truncated"+[12 chars]
     //
@@ -943,6 +944,7 @@ module Display =
         + "+["
         + (str.Length - prefixLength).ToString()
         + " chars]"
+#endif
 
     type Precedence =
         | BracketIfTupleOrNotAtomic = 2
@@ -1423,22 +1425,13 @@ module Display =
 
             // massively reign in deep printing of properties
             let nDepth = depthLim / 10
-#if NETSTANDARD
+
             Array.Sort(
                 propsAndFields,
                 { new IComparer<MemberInfo> with
                     member this.Compare(p1, p2) = compare p1.Name p2.Name
                 }
             )
-#else
-            Array.Sort(
-                (propsAndFields :> Array),
-                { new System.Collections.IComparer with
-                    member this.Compare(p1, p2) =
-                        compare ((p1 :?> MemberInfo).Name) ((p2 :?> MemberInfo).Name)
-                }
-            )
-#endif
 
             if propsAndFields.Length = 0 || (nDepth <= 0) then
                 basicL
@@ -1593,12 +1586,14 @@ module Display =
 
             tagText t
 
+#if COMPILER
     let any_to_layout options (value, typValue) =
         let formatter = ObjectGraphFormatter(options, BindingFlags.Public)
         formatter.Format(ShowAll, value, typValue)
 
     let squashTo width layout =
         layout |> squashToAux (width, leafFormatter FormatOptions.Default)
+#endif
 
     let squash_layout options layout =
         // Print width = 0 implies 1D layout, no squash
@@ -1607,6 +1602,7 @@ module Display =
         else
             layout |> squashToAux (options.PrintWidth, leafFormatter options)
 
+#if COMPILER
     let asTaggedTextWriter (writer: TextWriter) =
         { new TaggedTextWriter with
             member _.Write(t) = writer.Write t.Text
@@ -1617,27 +1613,13 @@ module Display =
         layout
         |> squash_layout options
         |> outL options.AttributeProcessor (leafFormatter options) writer
-
-    let output_layout options writer layout =
-        output_layout_tagged options (asTaggedTextWriter writer) layout
+#endif
 
     let layout_to_string options layout =
         layout
         |> squash_layout options
         |> showL options ((leafFormatter options) >> toText)
 
-    let output_any_ex opts oc x =
-        x |> any_to_layout opts |> output_layout opts oc
-
-    let output_any writer x =
-        output_any_ex FormatOptions.Default writer x
-
-    let layout_as_string options x =
-        x |> any_to_layout options |> layout_to_string options
-
-    let any_to_string x =
-        layout_as_string FormatOptions.Default x
-
 #if COMPILER
     let fsi_any_to_layout options (value, typValue) =
         let formatter = ObjectGraphFormatter(options, BindingFlags.Public)
diff --git a/src/Compiler/Utilities/sformat.fsi b/src/Compiler/Utilities/sformat.fsi
index 72afa8361d3..2707838552e 100644
--- a/src/Compiler/Utilities/sformat.fsi
+++ b/src/Compiler/Utilities/sformat.fsi
@@ -388,10 +388,6 @@ module internal Display =
     val squash_layout: options: FormatOptions -> layout: Layout -> Layout
 
     val output_layout_tagged: options: FormatOptions -> writer: TaggedTextWriter -> layout: Layout -> unit
-
-    val output_layout: options: FormatOptions -> writer: TextWriter -> layout: Layout -> unit
-
-    val layout_as_string: options: FormatOptions -> value: 'T * typValue: Type -> string
 #else
 
     // Most functions aren't needed in FSharp.Core.dll, but we add one inernal entry for printf
diff --git a/src/Compiler/Utilities/sr.fs b/src/Compiler/Utilities/sr.fs
index 77552a03b90..76b374aa311 100644
--- a/src/Compiler/Utilities/sr.fs
+++ b/src/Compiler/Utilities/sr.fs
@@ -29,7 +29,6 @@ module internal DiagnosticMessage =
         FSharpValue.MakeFunction(FSharpType.MakeFunctionType(tys[0], tys[1]), impl)
 
     let funTyC = typeof<obj -> obj>.GetGenericTypeDefinition ()
-    let mkFunTy a b = funTyC.MakeGenericType([| a; b |])
 
     let isNamedType (ty: System.Type) =
         not (ty.IsArray || ty.IsByRef || ty.IsPointer)
diff --git a/src/Compiler/pars.fsy b/src/Compiler/pars.fsy
index a18fb02fbb1..a44a1e69527 100644
--- a/src/Compiler/pars.fsy
+++ b/src/Compiler/pars.fsy
@@ -695,7 +695,7 @@ moduleSpfn:
 valSpfn: 
   | opt_attributes opt_access VAL opt_attributes opt_inline opt_mutable opt_access nameop opt_explicitValTyparDecls COLON topTypeWithTypeConstraints optLiteralValueSpfn
       { if Option.isSome $2 then errorR(Error(FSComp.SR.parsVisibilityDeclarationsShouldComePriorToIdentifier(), rhs parseState 2))
-        let attr1, attr2, isInline, isMutable, vis2, id, doc, explicitValTyparDecls, (ty, arity), (mEquals, konst: SynExpr option) = ($1), ($4), ($5), ($6), ($7), ($8), grabXmlDoc(parseState, $1, 1), ($9), ($11), ($12)
+        let attr1, attr2, isInline, isMutable, vis2, id, doc, explicitValTyparDecls, (ty, arity), (mEquals, konst: SynExpr option) = ($1), ($4), (Option.isSome $5), ($6), ($7), ($8), grabXmlDoc(parseState, $1, 1), ($9), ($11), ($12)
         if not (isNil attr2) then errorR(Deprecated(FSComp.SR.parsAttributesMustComeBeforeVal(), rhs parseState 4))
         let m = 
             rhs2 parseState 1 11 
@@ -705,7 +705,7 @@ valSpfn:
                 | None -> m
                 | Some e -> unionRanges m e.Range
         let mVal = rhs parseState 3
-        let trivia: SynValSigTrivia = { LeadingKeyword = SynLeadingKeyword.Val mVal; WithKeyword = None; EqualsRange = mEquals }
+        let trivia: SynValSigTrivia = { LeadingKeyword = SynLeadingKeyword.Val mVal; InlineKeyword = $5; WithKeyword = None; EqualsRange = mEquals }
         let valSpfn = SynValSig((attr1@attr2), id, explicitValTyparDecls, ty, arity, isInline, isMutable, doc, vis2, konst, m, trivia) 
         SynModuleSigDecl.Val(valSpfn, m)
       }
@@ -913,7 +913,7 @@ classSpfnMembersAtLeastOne:
 classMemberSpfn:
   | opt_attributes opt_access memberSpecFlags opt_inline opt_access nameop opt_explicitValTyparDecls COLON topTypeWithTypeConstraints classMemberSpfnGetSet optLiteralValueSpfn
      { if Option.isSome $2 then errorR(Error(FSComp.SR.parsVisibilityDeclarationsShouldComePriorToIdentifier(), rhs parseState 2))
-       let isInline, doc, vis2, id, explicitValTyparDecls, (ty, arity), (mEquals, optLiteralValue) = $4, grabXmlDoc(parseState, $1, 1), $5, $6, $7, $9, $11
+       let isInline, doc, vis2, id, explicitValTyparDecls, (ty, arity), (mEquals, optLiteralValue) = (Option.isSome $4), grabXmlDoc(parseState, $1, 1), $5, $6, $7, $9, $11
        let mWith, (getSet, getSetRangeOpt) = $10 
        let getSetAdjuster arity = match arity, getSet with SynValInfo([], _), SynMemberKind.Member -> SynMemberKind.PropertyGet | _ -> getSet
        let mWhole = 
@@ -930,7 +930,7 @@ classMemberSpfn:
        
        let flags, leadingKeyword = $3
        let flags = flags (getSetAdjuster arity)
-       let trivia = { LeadingKeyword = leadingKeyword; WithKeyword = mWith; EqualsRange = mEquals }
+       let trivia = { LeadingKeyword = leadingKeyword; InlineKeyword = $4; WithKeyword = mWith; EqualsRange = mEquals }
        let valSpfn = SynValSig($1, id, explicitValTyparDecls, ty, arity, isInline, false, doc, vis2, optLiteralValue, mWhole, trivia)
        let trivia: SynMemberSigMemberTrivia = { GetSetKeywords = getSetRangeOpt }
        SynMemberSig.Member(valSpfn, flags, mWhole, trivia) }
@@ -970,7 +970,7 @@ classMemberSpfn:
        let mNew = rhs parseState 3
        let m = unionRanges (rhs parseState 1) ty.Range |> unionRangeWithXmlDoc doc
        let isInline = false
-       let trivia: SynValSigTrivia = { LeadingKeyword = SynLeadingKeyword.New mNew; WithKeyword = None; EqualsRange = None }
+       let trivia: SynValSigTrivia = { LeadingKeyword = SynLeadingKeyword.New mNew; InlineKeyword = None; WithKeyword = None; EqualsRange = None }
        let valSpfn = SynValSig ($1, (SynIdent(mkSynId (rhs parseState 3) "new", None)), noInferredTypars, ty, valSynInfo, isInline, false, doc, vis, None, m, trivia)
        SynMemberSig.Member(valSpfn, CtorMemberFlags, m, SynMemberSigMemberTrivia.Zero) }
 
@@ -1740,8 +1740,8 @@ memberCore:
             let memFlagsBuilder, leadingKeyword = flagsBuilderAndLeadingKeyword 
             let memberFlags = memFlagsBuilder SynMemberKind.Member
             let mWholeBindLhs = (mBindLhs, attrs) ||> unionRangeWithListBy (fun (a: SynAttributeList) -> a.Range)
-            let trivia: SynBindingTrivia = { LeadingKeyword = leadingKeyword; EqualsRange = Some mEquals }
-            let binding = mkSynBinding (xmlDoc, bindingPat) (vis, $1, false, mWholeBindLhs, DebugPointAtBinding.NoneAtInvisible, optReturnType, $5, mRhs, [], attrs, Some memberFlags, trivia)
+            let trivia: SynBindingTrivia = { LeadingKeyword = leadingKeyword; InlineKeyword = $1; EqualsRange = Some mEquals }
+            let binding = mkSynBinding (xmlDoc, bindingPat) (vis, (Option.isSome $1), false, mWholeBindLhs, DebugPointAtBinding.NoneAtInvisible, optReturnType, $5, mRhs, [], attrs, Some memberFlags, trivia)
             let memberRange = unionRanges rangeStart mRhs |> unionRangeWithXmlDoc xmlDoc
             [ SynMemberDefn.Member (binding, memberRange) ]) }
 
@@ -1819,7 +1819,7 @@ classDefnMember:
         
   | opt_attributes opt_access abstractMemberFlags opt_inline nameop opt_explicitValTyparDecls COLON topTypeWithTypeConstraints classMemberSpfnGetSet  opt_ODECLEND
      { let ty, arity = $8
-       let isInline, doc, id, explicitValTyparDecls = $4, grabXmlDoc(parseState, $1, 1), $5, $6
+       let isInline, doc, id, explicitValTyparDecls = (Option.isSome $4), grabXmlDoc(parseState, $1, 1), $5, $6
        let mWith, (getSet, getSetRangeOpt) = $9
        let getSetAdjuster arity = match arity, getSet with SynValInfo([], _), SynMemberKind.Member -> SynMemberKind.PropertyGet | _ -> getSet
        let mWhole = 
@@ -1830,7 +1830,7 @@ classDefnMember:
            |> unionRangeWithXmlDoc doc
        if Option.isSome $2 then errorR(Error(FSComp.SR.parsAccessibilityModsIllegalForAbstract(), mWhole))
        let mkFlags, leadingKeyword = $3
-       let trivia = { LeadingKeyword = leadingKeyword; WithKeyword = mWith; EqualsRange = None }
+       let trivia = { LeadingKeyword = leadingKeyword; InlineKeyword = $4; WithKeyword = mWith; EqualsRange = None }
        let valSpfn = SynValSig($1, id, explicitValTyparDecls, ty, arity, isInline, false, doc, None, None, mWhole, trivia)
        let trivia: SynMemberDefnAbstractSlotTrivia = { GetSetKeywords = getSetRangeOpt } 
        [ SynMemberDefn.AbstractSlot(valSpfn, mkFlags (getSetAdjuster arity), mWhole, trivia) ] }
@@ -1870,7 +1870,7 @@ classDefnMember:
         let declPat = SynPat.LongIdent (SynLongIdent([mkSynId (rhs parseState 3) "new"], [], [None]), None, Some noInferredTypars, SynArgPats.Pats [$4], vis, rhs parseState 3)
         // Check that 'SynPatForConstructorDecl' matches this correctly
         assert (match declPat with SynPatForConstructorDecl _ -> true | _ -> false)
-        let synBindingTrivia: SynBindingTrivia = { LeadingKeyword = SynLeadingKeyword.New mNew; EqualsRange = Some mEquals }
+        let synBindingTrivia: SynBindingTrivia = { LeadingKeyword = SynLeadingKeyword.New mNew; InlineKeyword = None; EqualsRange = Some mEquals }
         [ SynMemberDefn.Member(SynBinding (None, SynBindingKind.Normal, false, false, $1, xmlDoc, valSynData, declPat, None, expr, mWholeBindLhs, DebugPointAtBinding.NoneAtInvisible, synBindingTrivia), m) ] }
         
   | opt_attributes opt_access STATIC typeKeyword tyconDefn 
@@ -2381,14 +2381,14 @@ attrUnionCaseDecl:
             let mDecl = unionRangeWithXmlDoc xmlDoc mDecl
             Choice2Of2 (SynUnionCase ( $1, $3, SynUnionCaseKind.FullType $5, xmlDoc, None, mDecl, trivia))) }
 
-  | opt_attributes opt_access unionCaseName EQUALS constant
+  | opt_attributes opt_access unionCaseName EQUALS atomicExpr
       { if Option.isSome $2 then errorR(Error(FSComp.SR.parsEnumFieldsCannotHaveVisibilityDeclarations(), rhs parseState 2))
         let mEquals = rhs parseState 4
         let mDecl = rhs2 parseState 1 5
         (fun (xmlDoc, mBar) -> 
             let trivia: SynEnumCaseTrivia = { BarRange = Some mBar; EqualsRange = mEquals }
             let mDecl = unionRangeWithXmlDoc xmlDoc mDecl
-            Choice1Of2 (SynEnumCase ( $1, $3, fst $5, snd $5, xmlDoc, mDecl, trivia))) } 
+            Choice1Of2 (SynEnumCase ( $1, $3, fst $5, xmlDoc, mDecl, trivia))) } 
 
 /* The name of a union case */
 unionCaseName: 
@@ -2412,12 +2412,12 @@ firstUnionCaseDeclOfMany:
         let mDecl = (rhs parseState 1) |> unionRangeWithXmlDoc xmlDoc
         Choice2Of2 (SynUnionCase ( [], (SynIdent($1, None)), SynUnionCaseKind.Fields [], xmlDoc, None, mDecl, trivia)) }
 
-  | ident EQUALS constant opt_OBLOCKSEP
+  | ident EQUALS atomicExpr opt_OBLOCKSEP
       { let mEquals = rhs parseState 2
         let trivia: SynEnumCaseTrivia = { BarRange = None; EqualsRange = mEquals }
         let xmlDoc = grabXmlDoc(parseState, [], 1)
         let mDecl = (rhs2 parseState 1 3) |> unionRangeWithXmlDoc xmlDoc
-        Choice1Of2 (SynEnumCase ([], SynIdent($1, None), fst $3, snd $3, xmlDoc, mDecl, trivia)) }
+        Choice1Of2 (SynEnumCase ([], SynIdent($1, None), fst $3, xmlDoc, mDecl, trivia)) }
 
   | firstUnionCaseDecl opt_OBLOCKSEP
       { $1 }
@@ -2429,12 +2429,12 @@ firstUnionCaseDecl:
        let mDecl = rhs2 parseState 1 3 |> unionRangeWithXmlDoc xmlDoc
        Choice2Of2 (SynUnionCase ( [], SynIdent($1, None), SynUnionCaseKind.Fields $3, xmlDoc, None, mDecl, trivia)) }
 
-  | ident EQUALS constant opt_OBLOCKSEP
+  | ident EQUALS atomicExpr opt_OBLOCKSEP
       { let mEquals = rhs parseState 2
         let trivia: SynEnumCaseTrivia = { BarRange = None; EqualsRange = mEquals }
         let xmlDoc = grabXmlDoc(parseState, [], 1)
         let mDecl = rhs2 parseState 1 3 |> unionRangeWithXmlDoc xmlDoc
-        Choice1Of2 (SynEnumCase ([], SynIdent($1, None), fst $3, snd $3, xmlDoc, mDecl, trivia))  }
+        Choice1Of2 (SynEnumCase ([], SynIdent($1, None), fst $3, xmlDoc, mDecl, trivia))  }
 
 unionCaseReprElements:
   | unionCaseReprElement STAR unionCaseReprElements
@@ -2669,7 +2669,7 @@ cPrototype:
             let bindingPat = SynPat.LongIdent (SynLongIdent([nm], [], [None]), None, Some noInferredTypars, SynArgPats.Pats [SynPat.Tuple(false, args, argsm)], vis, nmm)
             let mWholeBindLhs = (mBindLhs, attrs) ||> unionRangeWithListBy (fun (a: SynAttributeList) -> a.Range)
             let xmlDoc = grabXmlDoc(parseState, attrs, 1)
-            let trivia = { LeadingKeyword = SynLeadingKeyword.Extern mExtern; EqualsRange = None }
+            let trivia = { LeadingKeyword = SynLeadingKeyword.Extern mExtern; InlineKeyword = None; EqualsRange = None }
             let binding =
                 mkSynBinding 
                     (xmlDoc, bindingPat) 
@@ -2792,8 +2792,8 @@ localBinding:
             let mWhole = (unionRanges leadingKeyword.Range mRhs, attrs) ||> unionRangeWithListBy (fun (a: SynAttributeList) -> a.Range)
             let spBind = if IsDebugPointBinding bindingPat expr then DebugPointAtBinding.Yes mWhole else DebugPointAtBinding.NoneAtLet
             let mWholeBindLhs = (mBindLhs, attrs) ||> unionRangeWithListBy (fun (a: SynAttributeList) -> a.Range)
-            let trivia: SynBindingTrivia = { LeadingKeyword = leadingKeyword; EqualsRange = Some mEquals }
-            mkSynBinding (xmlDoc, bindingPat) (vis, $1, $2, mWholeBindLhs, spBind, optReturnType, expr, mRhs, opts, attrs, None, trivia))
+            let trivia: SynBindingTrivia = { LeadingKeyword = leadingKeyword; InlineKeyword = $1; EqualsRange = Some mEquals }
+            mkSynBinding (xmlDoc, bindingPat) (vis, Option.isSome $1, $2, mWholeBindLhs, spBind, optReturnType, expr, mRhs, opts, attrs, None, trivia))
         localBindingRange, localBindingBuilder }
 
   | opt_inline opt_mutable bindingPattern  opt_topReturnTypeWithTypeConstraints EQUALS  error
@@ -2807,8 +2807,8 @@ localBinding:
             let zeroWidthAtEnd = mEquals.EndRange
             let rhsExpr = arbExpr("localBinding1", zeroWidthAtEnd)
             let spBind = if IsDebugPointBinding bindingPat rhsExpr then DebugPointAtBinding.Yes mWhole else DebugPointAtBinding.NoneAtLet
-            let trivia: SynBindingTrivia = { LeadingKeyword = leadingKeyword; EqualsRange = Some mEquals }
-            mkSynBinding (xmlDoc, bindingPat) (vis, $1, $2, mBindLhs, spBind, optReturnType, rhsExpr, mRhs, [], attrs, None, trivia))
+            let trivia: SynBindingTrivia = { LeadingKeyword = leadingKeyword; InlineKeyword = $1; EqualsRange = Some mEquals }
+            mkSynBinding (xmlDoc, bindingPat) (vis, Option.isSome $1, $2, mBindLhs, spBind, optReturnType, rhsExpr, mRhs, [], attrs, None, trivia))
         mWhole, localBindingBuilder }
 
   | opt_inline opt_mutable bindingPattern  opt_topReturnTypeWithTypeConstraints recover
@@ -2820,9 +2820,9 @@ localBinding:
         let localBindingBuilder = 
           (fun xmlDoc attrs vis (leadingKeyword: SynLeadingKeyword) ->
             let spBind = DebugPointAtBinding.Yes (unionRanges leadingKeyword.Range mRhs)
-            let trivia = { LeadingKeyword = leadingKeyword; EqualsRange = None }
+            let trivia = { LeadingKeyword = leadingKeyword; InlineKeyword = $1; EqualsRange = None }
             let rhsExpr = arbExpr("localBinding2", mRhs)
-            mkSynBinding (xmlDoc, bindingPat) (vis, $1, $2, mBindLhs, spBind, optReturnType, rhsExpr, mRhs, [], attrs, None, trivia))
+            mkSynBinding (xmlDoc, bindingPat) (vis, Option.isSome $1, $2, mBindLhs, spBind, optReturnType, rhsExpr, mRhs, [], attrs, None, trivia))
         mWhole, localBindingBuilder }
 
 /* A single expression with an optional type annotation, and an optional static optimization block */
@@ -5816,8 +5816,8 @@ opt_bar:
   | /* EMPTY */ { } 
 
 opt_inline: 
-  | INLINE      { true } 
-  | /* EMPTY */ { false }
+  | INLINE      { Some (rhs parseState 1) } 
+  | /* EMPTY */ { None }
 
 opt_mutable: 
   | MUTABLE     { true } 
diff --git a/src/Compiler/xlf/FSComp.txt.cs.xlf b/src/Compiler/xlf/FSComp.txt.cs.xlf
index 80a628d7595..be4e61a8fe3 100644
--- a/src/Compiler/xlf/FSComp.txt.cs.xlf
+++ b/src/Compiler/xlf/FSComp.txt.cs.xlf
@@ -4,7 +4,12 @@
     <body>
       <trans-unit id="arrayElementHasWrongTypeTuple">
         <source>All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Všechny prvky pole musí být implicitně převoditelné na typ prvního elementu, což je řazená kolekce členů o délce {0} typu\n    {1}    \nTento element je řazená kolekce členů o délce {2} typu\n    {3}    \n</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="buildDuplicateFile">
+        <source>The source file '{0}' (at position {1}/{2}) already appeared in the compilation list (at position {3}/{4}). Please verify that it is included only once in the project file.</source>
+        <target state="translated">Zdrojový soubor {0} (na pozici {1}/{2}) se už zobrazil v seznamu kompilací (na pozici {3}/{4}). Ověřte prosím, že je v souboru projektu zahrnutý jen jednou.</target>
         <note />
       </trans-unit>
       <trans-unit id="buildInvalidSourceFileExtensionML">
@@ -17,9 +22,29 @@
         <target state="translated">Soubor {0} má nerozpoznanou příponu. Zdrojové soubory musí mít příponu .fs, .fsi, .fsx nebo .fsscript.</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkAbstractMembersDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkAdditionalConstructorOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Additional constructor is not allowed.</source>
+        <target state="translated">Pokud typ používá atribut [&lt;Sealed&gt;] i [&lt;AbstractClass&gt;], znamená to, že je statický. Další konstruktor není povolený.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkConstructorWithArgumentsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Constructor with arguments is not allowed.</source>
+        <target state="translated">Pokud typ používá atribut [&lt;Sealed&gt;] i [&lt;AbstractClass&gt;], znamená to, že je statický. Konstruktor s argumenty není povolený.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkDuplicatedMethodParameter">
         <source>Duplicate parameter. The parameter '{0}' has been used more that once in this method.</source>
-        <target state="new">Duplicate parameter. The parameter '{0}' has been used more that once in this method.</target>
+        <target state="translated">Duplicitní parametr Parametr {0} byl v této metodě použit vícekrát.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkExplicitFieldsDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</target>
         <note />
       </trans-unit>
       <trans-unit id="chkFeatureNotLanguageSupported">
@@ -37,6 +62,11 @@
         <target state="translated">Funkce {0} vyžaduje knihovnu F# pro verzi jazyka {1} nebo novější.</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkImplementingInterfacesOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkInfoRefcellAssign">
         <source>The use of ':=' from the F# library is deprecated. See https://aka.ms/fsharp-refcell-ops. For example, please change 'cell := expr' to 'cell.Value &lt;- expr'.</source>
         <target state="translated">Použití := z knihovny F# je zastaralé. Více informací: https://aka.ms/fsharp-refcell-ops. Změňte prosím například cell := expr na cell.Value &lt;- expr.</target>
@@ -57,6 +87,16 @@
         <target state="translated">Použití incr z knihovny F# je zastaralé. Více informací: https://aka.ms/fsharp-refcell-ops. Změňte prosím například incr cell na cell.Value &lt;- cell.Value + 1.</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkInstanceLetBindingOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkInstanceMemberOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance members are not allowed.</source>
+        <target state="translated">Pokud typ používá atribut [&lt;Sealed&gt;] i [&lt;AbstractClass&gt;], znamená to, že je statický. Členové instance nejsou povoleni.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="containerDeprecated">
         <source>The 'AssemblyKeyNameAttribute' has been deprecated. Use 'AssemblyKeyFileAttribute' instead.</source>
         <target state="translated">Atribut AssemblyKeyNameAttribute je zastaralý. Použijte místo něj AssemblyKeyFileAttribute.</target>
@@ -114,7 +154,7 @@
       </trans-unit>
       <trans-unit id="elseBranchHasWrongTypeTuple">
         <source>All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Všechny větve výrazu if musí vracet hodnoty implicitně převoditelné na typ první větve, což je řazená kolekce členů o délce {0} typu\n    {1}    \nTato větev vrací řazenou kolekci členů o délce {2} typu\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="etProviderHasDesignerAssemblyDependency">
@@ -142,6 +182,11 @@
         <target state="translated">aplikativní výpočetní výrazy</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureArithmeticInLiterals">
+        <source>Allow arithmetic and logical operations in literals</source>
+        <target state="translated">Povolit aritmetické a logické operace v literálech</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureAttributesToRightOfModuleKeyword">
         <source>attributes to the right of the 'module' keyword</source>
         <target state="translated">atributy napravo od klíčového slova Module</target>
@@ -154,7 +199,7 @@
       </trans-unit>
       <trans-unit id="featureCSharpExtensionAttributeNotRequired">
         <source>Allow implicit Extension attribute on declaring types, modules</source>
-        <target state="new">Allow implicit Extension attribute on declaring types, modules</target>
+        <target state="translated">Povolit implicitní atribut Extension pro deklarující typy, moduly</target>
         <note />
       </trans-unit>
       <trans-unit id="featureDefaultInterfaceMemberConsumption">
@@ -179,7 +224,7 @@
       </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
-        <target state="new">Raises errors for non-virtual members overrides</target>
+        <target state="translated">Vyvolá chyby pro přepsání jiných než virtuálních členů</target>
         <note />
       </trans-unit>
       <trans-unit id="featureErrorOnDeprecatedRequireQualifiedAccess">
@@ -187,6 +232,16 @@
         <target state="translated">chyba při zastaralém přístupu konstruktoru s atributem RequireQualifiedAccess</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureErrorReportingOnStaticClasses">
+        <source>Error reporting on static classes</source>
+        <target state="translated">Vytváření sestav chyb u statických tříd</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="featureEscapeBracesInFormattableString">
+        <source>Escapes curly braces before calling FormattableStringFactory.Create when interpolated string literal is typed as FormattableString</source>
+        <target state="translated">Uvede složené závorky před voláním formattableStringFactory.Create, pokud je interpolovaný řetězcový literál zadán jako FormattableString.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureExpandedMeasurables">
         <source>more types support units of measure</source>
         <target state="translated">více typů podporuje měrné jednotky</target>
@@ -214,12 +269,12 @@
       </trans-unit>
       <trans-unit id="featureInitProperties">
         <source>support for consuming init properties</source>
-        <target state="new">support for consuming init properties</target>
+        <target state="translated">podpora využívání vlastností init</target>
         <note />
       </trans-unit>
       <trans-unit id="featureInterfacesWithAbstractStaticMembers">
         <source>static abstract interface members</source>
-        <target state="new">static abstract interface members</target>
+        <target state="translated">statičtí abstraktní členové rozhraní</target>
         <note />
       </trans-unit>
       <trans-unit id="featureInterfacesWithMultipleGenericInstantiation">
@@ -229,7 +284,7 @@
       </trans-unit>
       <trans-unit id="featureLowercaseDUWhenRequireQualifiedAccess">
         <source>Allow lowercase DU when RequireQualifiedAccess attribute</source>
-        <target state="new">Allow lowercase DU when RequireQualifiedAccess attribute</target>
+        <target state="translated">Povolit duplikát malými písmeny při atributu RequireQualifiedAccess</target>
         <note />
       </trans-unit>
       <trans-unit id="featureMLCompatRevisions">
@@ -239,7 +294,7 @@
       </trans-unit>
       <trans-unit id="featureMatchNotAllowedForUnionCaseWithNoData">
         <source>Pattern match discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern match discard is not allowed for union case that takes no data.</target>
+        <target state="translated">Zahození shody vzoru není povolené pro případ sjednocení, který nepřijímá žádná data.</target>
         <note />
       </trans-unit>
       <trans-unit id="featureNameOf">
@@ -299,7 +354,7 @@
       </trans-unit>
       <trans-unit id="featureRequiredProperties">
         <source>support for required properties</source>
-        <target state="new">support for required properties</target>
+        <target state="translated">podpora požadovaných vlastností</target>
         <note />
       </trans-unit>
       <trans-unit id="featureResumableStateMachines">
@@ -309,7 +364,7 @@
       </trans-unit>
       <trans-unit id="featureSelfTypeConstraints">
         <source>self type constraints</source>
-        <target state="new">self type constraints</target>
+        <target state="translated">omezení vlastního typu</target>
         <note />
       </trans-unit>
       <trans-unit id="featureSingleUnderscorePattern">
@@ -327,6 +382,11 @@
         <target state="translated">reprezentace struktury aktivních vzorů</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureWarningWhenInliningMethodImplNoInlineMarkedFunction">
+        <source>Raises warnings when 'let inline ... =' is used together with [&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;] attribute. Function is not getting inlined.</source>
+        <target state="translated">Vyvolá upozornění, když se použije „let inline ... =“ společně s atributem [&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;]. Funkce není vkládána.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureWildCardInForLoop">
         <source>wild card in for loop</source>
         <target state="translated">zástupný znak ve smyčce for</target>
@@ -339,7 +399,7 @@
       </trans-unit>
       <trans-unit id="followingPatternMatchClauseHasWrongTypeTuple">
         <source>All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Všechny větve výrazu shody vzoru musí vracet hodnoty implicitně převoditelné na typ první větve, což je řazená kolekce členů o délce {0} typu\n    {1}    \nTato větev vrací řazenou kolekci členů o délce {2} typu\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="forFormatInvalidForInterpolated">
@@ -364,7 +424,7 @@
       </trans-unit>
       <trans-unit id="forPercentAInReflectionFreeCode">
         <source>The '%A' format specifier may not be used in an assembly being compiled with option '--reflectionfree'. This construct implicitly uses reflection.</source>
-        <target state="new">The '%A' format specifier may not be used in an assembly being compiled with option '--reflectionfree'. This construct implicitly uses reflection.</target>
+        <target state="translated">Specifikátor formátu %A nelze použít v sestavení kompilovaném s možností --reflectionfree. Tento konstruktor implicitně používá reflexi.</target>
         <note />
       </trans-unit>
       <trans-unit id="formatDashItem">
@@ -384,7 +444,7 @@
       </trans-unit>
       <trans-unit id="ifExpressionTuple">
         <source>The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Výraz if musí vrátit řazenou kolekci členů o délce {0} typu\n    {1}    \nto splňovat požadavky na typ kontextu. Aktuálně vrací řazenou kolekci členů o délce {2} typu\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="ilxGenUnknownDebugPoint">
@@ -409,7 +469,7 @@
       </trans-unit>
       <trans-unit id="keywordDescriptionAnd">
         <source>Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</source>
-        <target state="new">Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</target>
+        <target state="translated">Používá se ve vzájemně rekurzivních vazbách, v deklaracích vlastností a s několika omezeními u generických parametrů.</target>
         <note />
       </trans-unit>
       <trans-unit id="keywordDescriptionConst">
@@ -419,7 +479,7 @@
       </trans-unit>
       <trans-unit id="keywordDescriptionTypeTest">
         <source>Used to check if an object is of the given type in a pattern or binding.</source>
-        <target state="new">Used to check if an object is of the given type in a pattern or binding.</target>
+        <target state="translated">Slouží ke kontrole, zda je objekt daného typu ve vzoru nebo vazbě.</target>
         <note />
       </trans-unit>
       <trans-unit id="lexByteStringMayNotBeInterpolated">
@@ -449,12 +509,12 @@
       </trans-unit>
       <trans-unit id="listElementHasWrongTypeTuple">
         <source>All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Všechny prvky seznamu musí být implicitně převoditelné na typ prvního prvku, což je řazená kolekce členů o délce {0} typu\n    {1}    \nTento element je řazená kolekce členů o délce {2} typu\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="matchNotAllowedForUnionCaseWithNoData">
         <source>Pattern discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern discard is not allowed for union case that takes no data.</target>
+        <target state="translated">Pro případ sjednocení, který nepřijímá žádná data, se zahození vzoru nepovoluje.</target>
         <note />
       </trans-unit>
       <trans-unit id="mlCompatError">
@@ -529,17 +589,17 @@
       </trans-unit>
       <trans-unit id="optsCompressMetadata">
         <source>Compress interface and optimization data files</source>
-        <target state="new">Compress interface and optimization data files</target>
+        <target state="translated">Komprimovat datové soubory rozhraní a optimalizace</target>
         <note />
       </trans-unit>
       <trans-unit id="optsGetLangVersions">
         <source>Display the allowed values for language version.</source>
-        <target state="new">Display the allowed values for language version.</target>
+        <target state="translated">Zobrazí povolené hodnoty pro jazykovou verzi.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsInvalidRefAssembly">
         <source>Invalid use of emitting a reference assembly, do not use '--standalone or --staticlink' with '--refonly or --refout'.</source>
-        <target state="needs-review-translation">Neplatné použití generování referenčního sestavení, nepoužívejte --staticlink ani --refonly a --refout společně.</target>
+        <target state="translated">Neplatné použití generování referenčního sestavení, nepoužívejte --standalone ani --staticlink s --refonly nebo --refout.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsInvalidRefOut">
@@ -549,12 +609,12 @@
       </trans-unit>
       <trans-unit id="optsOptimizationData">
         <source>Specify included optimization information, the default is file. Important for distributed libraries.</source>
-        <target state="new">Specify included optimization information, the default is file. Important for distributed libraries.</target>
+        <target state="translated">Zadejte zahrnuté informace o optimalizaci, výchozí hodnota je soubor. Důležité pro distribuované knihovny.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsPdbMatchesOutputFileName">
         <source>The pdb output file name cannot match the build output filename use --pdb:filename.pdb</source>
-        <target state="new">The pdb output file name cannot match the build output filename use --pdb:filename.pdb</target>
+        <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="optsRefOnly">
@@ -569,17 +629,17 @@
       </trans-unit>
       <trans-unit id="optsReflectionFree">
         <source>Disable implicit generation of constructs using reflection</source>
-        <target state="new">Disable implicit generation of constructs using reflection</target>
+        <target state="translated">Zakázat implicitní generování konstruktorů pomocí reflexe</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSetLangVersion">
         <source>Specify language version such as 'latest' or 'preview'.</source>
-        <target state="new">Specify language version such as 'latest' or 'preview'.</target>
+        <target state="translated">Upřesněte verzi jazyka, například „latest“ nebo „preview“.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSignatureData">
         <source>Include F# interface information, the default is file. Essential for distributing libraries.</source>
-        <target state="new">Include F# interface information, the default is file. Essential for distributing libraries.</target>
+        <target state="translated">Zahrnout informace o rozhraní F#, výchozí je soubor. Klíčové pro distribuci knihoven.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSupportedLangVersions">
@@ -589,12 +649,12 @@
       </trans-unit>
       <trans-unit id="optsUnknownOptimizationData">
         <source>Invalid value '{0}' for --optimizationdata, valid value are: none, file, compress.</source>
-        <target state="new">Invalid value '{0}' for --optimizationdata, valid value are: none, file, compress.</target>
+        <target state="translated">Neplatná hodnota '{0}' pro --optimizationdata, platná hodnota: none, file, compress.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsUnknownSignatureData">
         <source>Invalid value '{0}' for --interfacedata, valid value are: none, file, compress.</source>
-        <target state="new">Invalid value '{0}' for --interfacedata, valid value are: none, file, compress.</target>
+        <target state="translated">Neplatná hodnota „{0}“ pro --interfacedata, platná hodnota je: none, file, compress.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsUnrecognizedLanguageVersion">
@@ -649,7 +709,7 @@
       </trans-unit>
       <trans-unit id="parsExpectedPatternAfterToken">
         <source>Expected a pattern after this point</source>
-        <target state="new">Expected a pattern after this point</target>
+        <target state="translated">Za tímto bodem byl očekáván vzor</target>
         <note />
       </trans-unit>
       <trans-unit id="parsExpectingExpressionInTuple">
@@ -659,17 +719,17 @@
       </trans-unit>
       <trans-unit id="parsExpectingPatternInTuple">
         <source>Expecting pattern</source>
-        <target state="new">Expecting pattern</target>
+        <target state="translated">Očekává se vzorek.</target>
         <note />
       </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
         <source>Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</source>
-        <target state="new">Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</target>
+        <target state="translated">Neúplný znakový literál (příklad: Q) nebo volání kvalifikovaného typu (příklad: T.Name)</target>
         <note />
       </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr2">
         <source>Incomplete operator expression (example a^b) or qualified type invocation (example: ^T.Name)</source>
-        <target state="new">Incomplete operator expression (example a^b) or qualified type invocation (example: ^T.Name)</target>
+        <target state="translated">Neúplný výraz operátoru (například^b) nebo volání kvalifikovaného typu (příklad: ^T.Name)</target>
         <note />
       </trans-unit>
       <trans-unit id="parsNewExprMemberAccess">
@@ -849,7 +909,7 @@
       </trans-unit>
       <trans-unit id="tcInitOnlyPropertyCannotBeSet1">
         <source>Init-only property '{0}' cannot be set outside the initialization code. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</source>
-        <target state="new">Init-only property '{0}' cannot be set outside the initialization code. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
+        <target state="translated">Vlastnost init-only „{0}“ nelze nastavit mimo inicializační kód. Zobrazit https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
         <note />
       </trans-unit>
       <trans-unit id="tcInlineIfLambdaUsedOnNonInlineFunctionOrMethod">
@@ -879,7 +939,7 @@
       </trans-unit>
       <trans-unit id="tcInvalidSelfConstraint">
         <source>Invalid constraint. Valid constraint forms include \"'T :&gt; ISomeInterface\" for interface constraints and \"SomeConstrainingType&lt;'T&gt;\" for self-constraints. See https://aka.ms/fsharp-type-constraints.</source>
-        <target state="new">Invalid constraint. Valid constraint forms include \"'T :&gt; ISomeInterface\" for interface constraints and \"SomeConstrainingType&lt;'T&gt;\" for self-constraints. See https://aka.ms/fsharp-type-constraints.</target>
+        <target state="translated">Neplatné omezení. Platné formuláře omezení zahrnují "T :&gt; ISomeInterface\" pro omezení rozhraní a \"SomeConstrainingType&lt;'T&gt;\" pro vlastní omezení. Viz https://aka.ms/fsharp-type-constraints.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcInvalidStructReturn">
@@ -924,7 +984,7 @@
       </trans-unit>
       <trans-unit id="tcMissingRequiredMembers">
         <source>The following required properties have to be initalized:{0}</source>
-        <target state="new">The following required properties have to be initalized:{0}</target>
+        <target state="translated">Je třeba inicializovat následující požadované vlastnosti:{0}</target>
         <note />
       </trans-unit>
       <trans-unit id="tcNoEagerConstraintApplicationAttribute">
@@ -1009,7 +1069,7 @@
       </trans-unit>
       <trans-unit id="tcSetterForInitOnlyPropertyCannotBeCalled1">
         <source>Cannot call '{0}' - a setter for init-only property, please use object initialization instead. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</source>
-        <target state="new">Cannot call '{0}' - a setter for init-only property, please use object initialization instead. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
+        <target state="translated">Nelze volat „{0}“ - metodu setter pro vlastnost pouze init. Použijte místo toho inicializaci objektu. Viz https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
         <note />
       </trans-unit>
       <trans-unit id="tcSubsumptionImplicitConversionUsed">
@@ -1019,32 +1079,32 @@
       </trans-unit>
       <trans-unit id="tcSynTypeOrInvalidInDeclaration">
         <source>SynType.Or is not permitted in this declaration</source>
-        <target state="new">SynType.Or is not permitted in this declaration</target>
+        <target state="translated">SynType.Or není v této deklaraci povoleno</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitHasMultipleSupportTypes">
         <source>The trait '{0}' invoked by this call has multiple support types. This invocation syntax is not permitted for such traits. See https://aka.ms/fsharp-srtp for guidance.</source>
-        <target state="new">The trait '{0}' invoked by this call has multiple support types. This invocation syntax is not permitted for such traits. See https://aka.ms/fsharp-srtp for guidance.</target>
+        <target state="translated">Vlastnost{0}vyvolaná tímto voláním má více typů podpory. Tato syntaxe volání není pro takové vlastnosti povolená. Pokyny najdete v https://aka.ms/fsharp-srtp.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitInvocationShouldUseTick">
         <source>Invocation of a static constraint should use \"'T.Ident\" and not \"^T.Ident\", even for statically resolved type parameters.</source>
-        <target state="new">Invocation of a static constraint should use \"'T.Ident\" and not \"^T.Ident\", even for statically resolved type parameters.</target>
+        <target state="translated">Volání statického omezení by mělo používat "T.Ident\" a nikoli \"^T.Ident\", a to i pro staticky přeložené parametry typu.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitIsNotStatic">
         <source>Trait '{0}' is not static</source>
-        <target state="new">Trait '{0}' is not static</target>
+        <target state="translated">Vlastnost „{0}“ není statická.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitIsStatic">
         <source>Trait '{0}' is static</source>
-        <target state="new">Trait '{0}' is static</target>
+        <target state="translated">Vlastnost „{0}“ je statická.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitMayNotUseComplexThings">
         <source>A trait may not specify optional, in, out, ParamArray, CallerInfo or Quote arguments</source>
-        <target state="new">A trait may not specify optional, in, out, ParamArray, CallerInfo or Quote arguments</target>
+        <target state="translated">Vlastnost nesmí určovat volitelné argumenty, in, out, ParamArray, CallerInfo nebo Quote.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcUnableToParseInterpolatedString">
@@ -1054,12 +1114,12 @@
       </trans-unit>
       <trans-unit id="tcUsingInterfaceWithStaticAbstractMethodAsType">
         <source>'{0}' is normally used as a type constraint in generic code, e.g. \"'T when ISomeInterface&lt;'T&gt;\" or \"let f (x: #ISomeInterface&lt;_&gt;)\". See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3536\"' or '--nowarn:3536'.</source>
-        <target state="new">'{0}' is normally used as a type constraint in generic code, e.g. \"'T when ISomeInterface&lt;'T&gt;\" or \"let f (x: #ISomeInterface&lt;_&gt;)\". See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3536\"' or '--nowarn:3536'.</target>
+        <target state="translated">'{0}' se obvykle používá jako omezení typu v obecném kódu, například \"T when ISomeInterface&lt;'T&gt;\" nebo \"let f (x: #ISomeInterface&lt;_&gt;)\". Pokyny najdete v https://aka.ms/fsharp-iwsams. Toto upozornění můžete zakázat pomocí #nowarn \"3536\" nebo '--nowarn:3536'.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcUsingInterfacesWithStaticAbstractMethods">
         <source>Declaring \"interfaces with static abstract methods\" is an advanced feature. See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3535\"' or '--nowarn:3535'.</source>
-        <target state="new">Declaring \"interfaces with static abstract methods\" is an advanced feature. See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3535\"' or '--nowarn:3535'.</target>
+        <target state="translated">Deklarování \"interfaces with static abstract methods\" (rozhraní se statickými abstraktními metodami) je pokročilá funkce. Pokyny najdete v https://aka.ms/fsharp-iwsams. Toto upozornění můžete zakázat pomocí #nowarn \"3535\" nebo '--nowarn:3535'.</target>
         <note />
       </trans-unit>
       <trans-unit id="typrelInterfaceMemberNoMostSpecificImplementation">
@@ -3849,7 +3909,7 @@
       </trans-unit>
       <trans-unit id="tcUnionCaseExpectsTupledArguments">
         <source>This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</source>
-        <target state="new">This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</target>
+        <target state="translated">Tento případ sjednocení očekává argumenty {0} ve formě řazené kolekce členů, ale byl zadán {1}. Argumenty chybějícího pole mohou být následující:{2}</target>
         <note />
       </trans-unit>
       <trans-unit id="tcFieldIsNotStatic">
@@ -7529,7 +7589,7 @@
       </trans-unit>
       <trans-unit id="tcStructUnionMultiCaseDistinctFields">
         <source>If a multicase union type is a struct, then all union cases must have unique names. For example: 'type A = B of b: int | C of c: int'.</source>
-        <target state="needs-review-translation">Pokud je typ sjednocení struktura a obsahuje více než jeden případ, všem polím v tomto typu sjednocení se musí přiřadit jedinečný název.</target>
+        <target state="translated">Pokud je typ sjednocení s více písmeny struktura, musí mít všechny případy sjednocení jedinečné názvy. Příklad: 'type A = B of b: int | C z c: int</target>
         <note />
       </trans-unit>
       <trans-unit id="CallerMemberNameIsOverriden">
diff --git a/src/Compiler/xlf/FSComp.txt.de.xlf b/src/Compiler/xlf/FSComp.txt.de.xlf
index 595eedd84a1..5d662b8bf27 100644
--- a/src/Compiler/xlf/FSComp.txt.de.xlf
+++ b/src/Compiler/xlf/FSComp.txt.de.xlf
@@ -4,7 +4,12 @@
     <body>
       <trans-unit id="arrayElementHasWrongTypeTuple">
         <source>All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Alle Elemente eines Arrays müssen implizit in den Typ des ersten Elements konvertiert werden. Hierbei handelt es sich um ein Tupel der Länge {0} vom Typ\n    {1}    \nDieses Element ist ein Tupel der Länge {2} vom Typ\n    {3}.    \n</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="buildDuplicateFile">
+        <source>The source file '{0}' (at position {1}/{2}) already appeared in the compilation list (at position {3}/{4}). Please verify that it is included only once in the project file.</source>
+        <target state="translated">Die Quelldatei „{0}“ (an Position {1}/{2}) wurde bereits in der Kompilierungsliste angezeigt (an Position {3}/{4}). Bitte stellen Sie sicher, dass sie nur einmal in der Projektdatei enthalten ist.</target>
         <note />
       </trans-unit>
       <trans-unit id="buildInvalidSourceFileExtensionML">
@@ -17,9 +22,29 @@
         <target state="translated">Die Dateierweiterung von „{0}“ wurde nicht erkannt. Quelldateien müssen die Erweiterung .fs, .fsi, .fsx oder .fsscript haben</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkAbstractMembersDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkAdditionalConstructorOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Additional constructor is not allowed.</source>
+        <target state="translated">Wenn ein Typ sowohl das Attribute [&lt;Sealed&gt;] wie auch [&lt;AbstractClass&gt;] verwendet, bedeutet dies, dass er statisch ist. Ein zusätzlicher Konstruktor ist nicht zulässig.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkConstructorWithArgumentsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Constructor with arguments is not allowed.</source>
+        <target state="translated">Wenn ein Typ sowohl das Attribute [&lt;Sealed&gt;] wie auch [&lt;AbstractClass&gt;] verwendet, bedeutet dies, dass er statisch ist. Der Konstruktor mit Argumenten ist nicht zulässig.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkDuplicatedMethodParameter">
         <source>Duplicate parameter. The parameter '{0}' has been used more that once in this method.</source>
-        <target state="new">Duplicate parameter. The parameter '{0}' has been used more that once in this method.</target>
+        <target state="translated">Doppelter Parameter. Der Parameter „{0}“ wurde in dieser Methode mehrmals verwendet.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkExplicitFieldsDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</target>
         <note />
       </trans-unit>
       <trans-unit id="chkFeatureNotLanguageSupported">
@@ -37,6 +62,11 @@
         <target state="translated">Für das Feature "{0}" ist die F#-Bibliothek für die Sprachversion {1} oder höher erforderlich.</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkImplementingInterfacesOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkInfoRefcellAssign">
         <source>The use of ':=' from the F# library is deprecated. See https://aka.ms/fsharp-refcell-ops. For example, please change 'cell := expr' to 'cell.Value &lt;- expr'.</source>
         <target state="translated">Die Verwendung von ":=" aus der F#-Bibliothek ist veraltet. Siehe https://aka.ms/fsharp-refcell-ops. Ändern Sie z. B. "cell := expr" in "cell.Value &lt;- expr".</target>
@@ -57,6 +87,16 @@
         <target state="translated">Die Verwendung von "incr" aus der F#-Bibliothek ist veraltet. Siehe https://aka.ms/fsharp-refcell-ops. Ändern Sie z. B. "incr cell" in "cell.Value &lt;- cell.Value + 1".</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkInstanceLetBindingOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkInstanceMemberOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance members are not allowed.</source>
+        <target state="translated">Wenn ein Typ sowohl das Attribute [&lt;Sealed&gt;] wie auch [&lt;AbstractClass&gt;] verwendet, bedeutet dies, dass er statisch ist. Members in Instanzen sind nicht zulässig.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="containerDeprecated">
         <source>The 'AssemblyKeyNameAttribute' has been deprecated. Use 'AssemblyKeyFileAttribute' instead.</source>
         <target state="translated">"AssemblyKeyNameAttribute" gilt als veraltet. Verwenden Sie stattdessen "AssemblyKeyFileAttribute".</target>
@@ -114,7 +154,7 @@
       </trans-unit>
       <trans-unit id="elseBranchHasWrongTypeTuple">
         <source>All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Alle Verzweigungen eines „If-Ausdrucks“ müssen Werte zurückgeben, die implizit in den Typ der ersten Verzweigung konvertierbar sind. In diesem Fall handelt es sich dabei um ein Tupel der Länge {0} des Typs.\n    {1}    \nDiese Verzweigung gibt ein Tupel der Länge {2} des Typs\n    {3}    \nzurück.</target>
         <note />
       </trans-unit>
       <trans-unit id="etProviderHasDesignerAssemblyDependency">
@@ -142,6 +182,11 @@
         <target state="translated">applikative Berechnungsausdrücke</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureArithmeticInLiterals">
+        <source>Allow arithmetic and logical operations in literals</source>
+        <target state="translated">Arithmetische und logische Vorgänge in Literalen zulassen</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureAttributesToRightOfModuleKeyword">
         <source>attributes to the right of the 'module' keyword</source>
         <target state="translated">Attribute rechts vom "Module"-Schlüsselwort</target>
@@ -154,7 +199,7 @@
       </trans-unit>
       <trans-unit id="featureCSharpExtensionAttributeNotRequired">
         <source>Allow implicit Extension attribute on declaring types, modules</source>
-        <target state="new">Allow implicit Extension attribute on declaring types, modules</target>
+        <target state="translated">Implizites Erweiterungsattribut für deklarierende Typen und Module zulassen</target>
         <note />
       </trans-unit>
       <trans-unit id="featureDefaultInterfaceMemberConsumption">
@@ -179,7 +224,7 @@
       </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
-        <target state="new">Raises errors for non-virtual members overrides</target>
+        <target state="translated">Löst Fehler für Außerkraftsetzungen nicht virtueller Member aus.</target>
         <note />
       </trans-unit>
       <trans-unit id="featureErrorOnDeprecatedRequireQualifiedAccess">
@@ -187,6 +232,16 @@
         <target state="translated">Beim veralteten Zugriff auf das Konstrukt mit dem RequireQualifiedAccess-Attribut wird ein Fehler ausgegeben.</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureErrorReportingOnStaticClasses">
+        <source>Error reporting on static classes</source>
+        <target state="translated">Fehlerberichterstattung für statische Klassen</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="featureEscapeBracesInFormattableString">
+        <source>Escapes curly braces before calling FormattableStringFactory.Create when interpolated string literal is typed as FormattableString</source>
+        <target state="translated">Escapezeichen mit geschweiften Klammern, bevor FormattableStringFactory.Create aufgerufen wird, wenn ein interpoliertes Zeichenfolgenliteral als FormattableString eingegeben wird.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureExpandedMeasurables">
         <source>more types support units of measure</source>
         <target state="translated">Maßeinheitenunterstützung durch weitere Typen</target>
@@ -214,12 +269,12 @@
       </trans-unit>
       <trans-unit id="featureInitProperties">
         <source>support for consuming init properties</source>
-        <target state="new">support for consuming init properties</target>
+        <target state="translated">Unterstützung für die Nutzung von Initialisierungseigenschaften</target>
         <note />
       </trans-unit>
       <trans-unit id="featureInterfacesWithAbstractStaticMembers">
         <source>static abstract interface members</source>
-        <target state="new">static abstract interface members</target>
+        <target state="translated">statische abstrakte Schnittstellenmitglieder</target>
         <note />
       </trans-unit>
       <trans-unit id="featureInterfacesWithMultipleGenericInstantiation">
@@ -229,7 +284,7 @@
       </trans-unit>
       <trans-unit id="featureLowercaseDUWhenRequireQualifiedAccess">
         <source>Allow lowercase DU when RequireQualifiedAccess attribute</source>
-        <target state="new">Allow lowercase DU when RequireQualifiedAccess attribute</target>
+        <target state="translated">DU in Kleinbuchstaben zulassen, wenn requireQualifiedAccess-Attribut</target>
         <note />
       </trans-unit>
       <trans-unit id="featureMLCompatRevisions">
@@ -239,7 +294,7 @@
       </trans-unit>
       <trans-unit id="featureMatchNotAllowedForUnionCaseWithNoData">
         <source>Pattern match discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern match discard is not allowed for union case that takes no data.</target>
+        <target state="translated">Das Verwerfen von Musterübereinstimmungen ist für einen Union-Fall, der keine Daten akzeptiert, nicht zulässig.</target>
         <note />
       </trans-unit>
       <trans-unit id="featureNameOf">
@@ -299,7 +354,7 @@
       </trans-unit>
       <trans-unit id="featureRequiredProperties">
         <source>support for required properties</source>
-        <target state="new">support for required properties</target>
+        <target state="translated">Unterstützung für erforderliche Eigenschaften</target>
         <note />
       </trans-unit>
       <trans-unit id="featureResumableStateMachines">
@@ -309,7 +364,7 @@
       </trans-unit>
       <trans-unit id="featureSelfTypeConstraints">
         <source>self type constraints</source>
-        <target state="new">self type constraints</target>
+        <target state="translated">Selbsttypeinschränkungen</target>
         <note />
       </trans-unit>
       <trans-unit id="featureSingleUnderscorePattern">
@@ -327,6 +382,11 @@
         <target state="translated">Strukturdarstellung für aktive Muster</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureWarningWhenInliningMethodImplNoInlineMarkedFunction">
+        <source>Raises warnings when 'let inline ... =' is used together with [&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;] attribute. Function is not getting inlined.</source>
+        <target state="translated">Löst Warnungen aus, wenn „let inline ... =“ zusammen mit dem Attribut [&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;] verwendet wird. Die Funktion wird nicht inline gesetzt.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureWildCardInForLoop">
         <source>wild card in for loop</source>
         <target state="translated">Platzhalter in for-Schleife</target>
@@ -339,7 +399,7 @@
       </trans-unit>
       <trans-unit id="followingPatternMatchClauseHasWrongTypeTuple">
         <source>All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Alle Verzweigungen eines Musterübereinstimmungsausdrucks müssen Werte zurückgeben, die implizit in den Typ der ersten Verzweigung konvertierbar sind. In diesem Fall handelt es sich dabei um ein Tupel der Länge {0} des Typs.\n    {1}    \nDiese Verzweigung gibt ein Tupel der Länge {2} des Typs\n    {3}    \nzurück.</target>
         <note />
       </trans-unit>
       <trans-unit id="forFormatInvalidForInterpolated">
@@ -364,7 +424,7 @@
       </trans-unit>
       <trans-unit id="forPercentAInReflectionFreeCode">
         <source>The '%A' format specifier may not be used in an assembly being compiled with option '--reflectionfree'. This construct implicitly uses reflection.</source>
-        <target state="new">The '%A' format specifier may not be used in an assembly being compiled with option '--reflectionfree'. This construct implicitly uses reflection.</target>
+        <target state="translated">Der Formatbezeichner „%A“ darf nicht in einer Assembly verwendet werden, die mit der Option „--reflectionfree“ kompiliert wird. Dieses Konstrukt verwendet implizit die Reflektion.</target>
         <note />
       </trans-unit>
       <trans-unit id="formatDashItem">
@@ -384,7 +444,7 @@
       </trans-unit>
       <trans-unit id="ifExpressionTuple">
         <source>The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Der „if“-Ausdruck muss ein Tupel mit der Länge {0} vom Typ\n    {1}    \nzurückgeben, um die Kontexttypanforderungen zu erfüllen. Derzeit wird ein Tupel mit der Länge {2} vom Typ\n    {3}    \nzurückgegeben.</target>
         <note />
       </trans-unit>
       <trans-unit id="ilxGenUnknownDebugPoint">
@@ -409,7 +469,7 @@
       </trans-unit>
       <trans-unit id="keywordDescriptionAnd">
         <source>Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</source>
-        <target state="new">Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</target>
+        <target state="translated">Wird in gegenseitig rekursiven Bindungen, in Eigenschaftendeklarationen und bei mehreren Beschränkungen in Bezug auf generische Parameter verwendet.</target>
         <note />
       </trans-unit>
       <trans-unit id="keywordDescriptionConst">
@@ -419,7 +479,7 @@
       </trans-unit>
       <trans-unit id="keywordDescriptionTypeTest">
         <source>Used to check if an object is of the given type in a pattern or binding.</source>
-        <target state="new">Used to check if an object is of the given type in a pattern or binding.</target>
+        <target state="translated">Wird verwendet, um zu überprüfen, ob ein Objekt in einem Muster oder einer Bindung vom angegebenen Typ ist.</target>
         <note />
       </trans-unit>
       <trans-unit id="lexByteStringMayNotBeInterpolated">
@@ -449,12 +509,12 @@
       </trans-unit>
       <trans-unit id="listElementHasWrongTypeTuple">
         <source>All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Alle Elemente einer Liste müssen implizit in den Typ des ersten Elements konvertiert werden. Hierbei handelt es sich um ein Tupel der Länge {0} vom Typ\n    {1}    \nDieses Element ist ein Tupel der Länge {2} vom Typ\n    {3}.    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="matchNotAllowedForUnionCaseWithNoData">
         <source>Pattern discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern discard is not allowed for union case that takes no data.</target>
+        <target state="translated">Das Verwerfen von Mustern ist für Union-Fall, der keine Daten akzeptiert, nicht zulässig.</target>
         <note />
       </trans-unit>
       <trans-unit id="mlCompatError">
@@ -529,17 +589,17 @@
       </trans-unit>
       <trans-unit id="optsCompressMetadata">
         <source>Compress interface and optimization data files</source>
-        <target state="new">Compress interface and optimization data files</target>
+        <target state="translated">Komprimieren von Schnittstellen- und Optimierungsdatendateien</target>
         <note />
       </trans-unit>
       <trans-unit id="optsGetLangVersions">
         <source>Display the allowed values for language version.</source>
-        <target state="new">Display the allowed values for language version.</target>
+        <target state="translated">Anzeigen der zulässigen Werte für die Sprachversion.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsInvalidRefAssembly">
         <source>Invalid use of emitting a reference assembly, do not use '--standalone or --staticlink' with '--refonly or --refout'.</source>
-        <target state="needs-review-translation">Ungültige Verwendung der Ausgabe einer Referenzassembly. Verwenden Sie nicht "--staticlink" oder "--refonly" und "--refout" zusammen.</target>
+        <target state="translated">Ungültige Verwendung der Ausgabe einer Referenzassembly. Verwenden Sie nicht „--standalone“ oder „--staticlink“ mit „--refonly“ oder „--refout“.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsInvalidRefOut">
@@ -549,12 +609,12 @@
       </trans-unit>
       <trans-unit id="optsOptimizationData">
         <source>Specify included optimization information, the default is file. Important for distributed libraries.</source>
-        <target state="new">Specify included optimization information, the default is file. Important for distributed libraries.</target>
+        <target state="translated">Geben Sie die enthaltenen Optimierungsinformationen an, der Standardwert ist „file“. Wichtig für verteilte Bibliotheken.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsPdbMatchesOutputFileName">
         <source>The pdb output file name cannot match the build output filename use --pdb:filename.pdb</source>
-        <target state="new">The pdb output file name cannot match the build output filename use --pdb:filename.pdb</target>
+        <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="optsRefOnly">
@@ -569,17 +629,17 @@
       </trans-unit>
       <trans-unit id="optsReflectionFree">
         <source>Disable implicit generation of constructs using reflection</source>
-        <target state="new">Disable implicit generation of constructs using reflection</target>
+        <target state="translated">Deaktivieren der impliziten Generierung von Konstrukten mithilfe von Reflektion</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSetLangVersion">
         <source>Specify language version such as 'latest' or 'preview'.</source>
-        <target state="new">Specify language version such as 'latest' or 'preview'.</target>
+        <target state="translated">Geben Sie eine Sprachversion wie „latest“ oder „preview“ an.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSignatureData">
         <source>Include F# interface information, the default is file. Essential for distributing libraries.</source>
-        <target state="new">Include F# interface information, the default is file. Essential for distributing libraries.</target>
+        <target state="translated">Schließen Sie F#-Schnittstelleninformationen ein, der Standardwert ist „file“. Wesentlich für die Verteilung von Bibliotheken.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSupportedLangVersions">
@@ -589,12 +649,12 @@
       </trans-unit>
       <trans-unit id="optsUnknownOptimizationData">
         <source>Invalid value '{0}' for --optimizationdata, valid value are: none, file, compress.</source>
-        <target state="new">Invalid value '{0}' for --optimizationdata, valid value are: none, file, compress.</target>
+        <target state="translated">Ungültiger Wert „{0}“ für --optimizationdata. Gültige Werte sind: none, file, compress.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsUnknownSignatureData">
         <source>Invalid value '{0}' for --interfacedata, valid value are: none, file, compress.</source>
-        <target state="new">Invalid value '{0}' for --interfacedata, valid value are: none, file, compress.</target>
+        <target state="translated">Ungültiger Wert „{0}“ für --interfacedata. Gültige Werte sind: none, file, compress.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsUnrecognizedLanguageVersion">
@@ -649,7 +709,7 @@
       </trans-unit>
       <trans-unit id="parsExpectedPatternAfterToken">
         <source>Expected a pattern after this point</source>
-        <target state="new">Expected a pattern after this point</target>
+        <target state="translated">Nach diesem Punkt wurde ein Muster erwartet.</target>
         <note />
       </trans-unit>
       <trans-unit id="parsExpectingExpressionInTuple">
@@ -659,17 +719,17 @@
       </trans-unit>
       <trans-unit id="parsExpectingPatternInTuple">
         <source>Expecting pattern</source>
-        <target state="new">Expecting pattern</target>
+        <target state="translated">Muster wird erwartet</target>
         <note />
       </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
         <source>Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</source>
-        <target state="new">Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</target>
+        <target state="translated">Unvollständiges Zeichenliteral (Beispiel: „Q“) oder qualifizierter Typaufruf (Beispiel: „T.Name“)</target>
         <note />
       </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr2">
         <source>Incomplete operator expression (example a^b) or qualified type invocation (example: ^T.Name)</source>
-        <target state="new">Incomplete operator expression (example a^b) or qualified type invocation (example: ^T.Name)</target>
+        <target state="translated">Unvollständiger Operatorausdruck (Beispiel: a^b) oder qualifizierter Typaufruf (Beispiel: ^T.Name)</target>
         <note />
       </trans-unit>
       <trans-unit id="parsNewExprMemberAccess">
@@ -849,7 +909,7 @@
       </trans-unit>
       <trans-unit id="tcInitOnlyPropertyCannotBeSet1">
         <source>Init-only property '{0}' cannot be set outside the initialization code. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</source>
-        <target state="new">Init-only property '{0}' cannot be set outside the initialization code. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
+        <target state="translated">Die Eigenschaft „{0}“ nur für die Initialisierung kann nicht außerhalb des Initialisierungscodes festgelegt werden. Siehe https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
         <note />
       </trans-unit>
       <trans-unit id="tcInlineIfLambdaUsedOnNonInlineFunctionOrMethod">
@@ -879,7 +939,7 @@
       </trans-unit>
       <trans-unit id="tcInvalidSelfConstraint">
         <source>Invalid constraint. Valid constraint forms include \"'T :&gt; ISomeInterface\" for interface constraints and \"SomeConstrainingType&lt;'T&gt;\" for self-constraints. See https://aka.ms/fsharp-type-constraints.</source>
-        <target state="new">Invalid constraint. Valid constraint forms include \"'T :&gt; ISomeInterface\" for interface constraints and \"SomeConstrainingType&lt;'T&gt;\" for self-constraints. See https://aka.ms/fsharp-type-constraints.</target>
+        <target state="translated">Ungültige Einschränkung. Gültige Einschränkungsformen sind \"'T :&gt; ISomeInterface\" für Schnittstelleneinschränkungen und\"SomeConstrainingType&lt;'T&gt;\" für Selbsteinschränkungen. Siehe https://aka.ms/fsharp-type-constraints.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcInvalidStructReturn">
@@ -924,7 +984,7 @@
       </trans-unit>
       <trans-unit id="tcMissingRequiredMembers">
         <source>The following required properties have to be initalized:{0}</source>
-        <target state="new">The following required properties have to be initalized:{0}</target>
+        <target state="translated">Die folgenden erforderlichen Eigenschaften müssen initialisiert werden:{0}</target>
         <note />
       </trans-unit>
       <trans-unit id="tcNoEagerConstraintApplicationAttribute">
@@ -1009,7 +1069,7 @@
       </trans-unit>
       <trans-unit id="tcSetterForInitOnlyPropertyCannotBeCalled1">
         <source>Cannot call '{0}' - a setter for init-only property, please use object initialization instead. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</source>
-        <target state="new">Cannot call '{0}' - a setter for init-only property, please use object initialization instead. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
+        <target state="translated">„{0}“ kann nicht aufgerufen werden – ein Setter für die Eigenschaft nur für die Initialisierung. Bitte verwenden Sie stattdessen die Objektinitialisierung. Siehe https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
         <note />
       </trans-unit>
       <trans-unit id="tcSubsumptionImplicitConversionUsed">
@@ -1019,32 +1079,32 @@
       </trans-unit>
       <trans-unit id="tcSynTypeOrInvalidInDeclaration">
         <source>SynType.Or is not permitted in this declaration</source>
-        <target state="new">SynType.Or is not permitted in this declaration</target>
+        <target state="translated">SynType.Or ist in dieser Deklaration nicht zulässig.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitHasMultipleSupportTypes">
         <source>The trait '{0}' invoked by this call has multiple support types. This invocation syntax is not permitted for such traits. See https://aka.ms/fsharp-srtp for guidance.</source>
-        <target state="new">The trait '{0}' invoked by this call has multiple support types. This invocation syntax is not permitted for such traits. See https://aka.ms/fsharp-srtp for guidance.</target>
+        <target state="translated">Das Merkmal „{0}“, das von diesem Aufruf aufgerufen wird, weist mehrere Unterstützungstypen auf. Diese Aufrufsyntax ist für solche Merkmale nicht zulässig. Anleitungen finden Sie unter https://aka.ms/fsharp-srtp.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitInvocationShouldUseTick">
         <source>Invocation of a static constraint should use \"'T.Ident\" and not \"^T.Ident\", even for statically resolved type parameters.</source>
-        <target state="new">Invocation of a static constraint should use \"'T.Ident\" and not \"^T.Ident\", even for statically resolved type parameters.</target>
+        <target state="translated">Beim Aufruf einer statischen Einschränkung sollte \"'T.Ident\" verwendet werden und nicht \"^T.Ident\", selbst für statisch aufgelöste Typparameter.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitIsNotStatic">
         <source>Trait '{0}' is not static</source>
-        <target state="new">Trait '{0}' is not static</target>
+        <target state="translated">Das Merkmal „{0}“ ist nicht statisch.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitIsStatic">
         <source>Trait '{0}' is static</source>
-        <target state="new">Trait '{0}' is static</target>
+        <target state="translated">Das Merkmal „{0}“ ist statisch.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitMayNotUseComplexThings">
         <source>A trait may not specify optional, in, out, ParamArray, CallerInfo or Quote arguments</source>
-        <target state="new">A trait may not specify optional, in, out, ParamArray, CallerInfo or Quote arguments</target>
+        <target state="translated">Ein Merkmal darf keine Argumente für „optional“, „in“, „out“, „ParamArray“", „CallerInfo“ oder „Quote“ angeben.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcUnableToParseInterpolatedString">
@@ -1054,12 +1114,12 @@
       </trans-unit>
       <trans-unit id="tcUsingInterfaceWithStaticAbstractMethodAsType">
         <source>'{0}' is normally used as a type constraint in generic code, e.g. \"'T when ISomeInterface&lt;'T&gt;\" or \"let f (x: #ISomeInterface&lt;_&gt;)\". See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3536\"' or '--nowarn:3536'.</source>
-        <target state="new">'{0}' is normally used as a type constraint in generic code, e.g. \"'T when ISomeInterface&lt;'T&gt;\" or \"let f (x: #ISomeInterface&lt;_&gt;)\". See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3536\"' or '--nowarn:3536'.</target>
+        <target state="translated">„{0}“ wird normalerweise als Typeinschränkung im generischen Code verwendet, z. B. \"'T when ISomeInterface&lt;'T&gt;\" oder \"let f (x: #ISomeInterface&lt;_&gt;)\". Anleitungen finden Sie unter https://aka.ms/fsharp-iwsams. Sie können diese Warnung deaktivieren, indem Sie „#nowarn \"3536\"“ or „--nowarn:3536“ verwenden.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcUsingInterfacesWithStaticAbstractMethods">
         <source>Declaring \"interfaces with static abstract methods\" is an advanced feature. See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3535\"' or '--nowarn:3535'.</source>
-        <target state="new">Declaring \"interfaces with static abstract methods\" is an advanced feature. See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3535\"' or '--nowarn:3535'.</target>
+        <target state="translated">Das Deklarieren von \"Schnittstellen mit statischen abstrakten Methoden\" ist ein erweitertes Feature. Anleitungen finden Sie unter https://aka.ms/fsharp-iwsams. Sie können diese Warnung deaktivieren, indem Sie „#nowarn \"3535\"“ or „--nowarn:3535“ verwenden.</target>
         <note />
       </trans-unit>
       <trans-unit id="typrelInterfaceMemberNoMostSpecificImplementation">
@@ -3849,7 +3909,7 @@
       </trans-unit>
       <trans-unit id="tcUnionCaseExpectsTupledArguments">
         <source>This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</source>
-        <target state="new">This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</target>
+        <target state="translated">Dieser Union-Fall erwartet {0} Argumente in Tupelform, es wurden jedoch {1} angegeben. Zu den fehlenden Feldargumenten gehören möglicherweise folgende: {2}.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcFieldIsNotStatic">
@@ -7529,7 +7589,7 @@
       </trans-unit>
       <trans-unit id="tcStructUnionMultiCaseDistinctFields">
         <source>If a multicase union type is a struct, then all union cases must have unique names. For example: 'type A = B of b: int | C of c: int'.</source>
-        <target state="needs-review-translation">Wenn ein Union-Typ mehrere case-Anweisungen aufweist und eine Struktur ist, müssen für alle Felder im Union-Typ eindeutige Namen angegeben werden.</target>
+        <target state="translated">Wenn ein Mehrfach-Union-Typ eine Struktur ist, müssen alle Union-Fälle eindeutige Namen aufweisen. Beispiel: „type A = B von b: int | C von c: int“.</target>
         <note />
       </trans-unit>
       <trans-unit id="CallerMemberNameIsOverriden">
diff --git a/src/Compiler/xlf/FSComp.txt.es.xlf b/src/Compiler/xlf/FSComp.txt.es.xlf
index 3e2407c1542..1ddc22b8475 100644
--- a/src/Compiler/xlf/FSComp.txt.es.xlf
+++ b/src/Compiler/xlf/FSComp.txt.es.xlf
@@ -4,7 +4,12 @@
     <body>
       <trans-unit id="arrayElementHasWrongTypeTuple">
         <source>All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Todos los elementos de una matriz deben convertirse implícitamente en el tipo del primer elemento, que aquí es una tupla de longitud {0} de tipo\n    {1}    \nEste elemento es una tupla de longitud {2} de tipo\n    {3}    \n</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="buildDuplicateFile">
+        <source>The source file '{0}' (at position {1}/{2}) already appeared in the compilation list (at position {3}/{4}). Please verify that it is included only once in the project file.</source>
+        <target state="translated">El archivo de origen "{0}" (en la posición {1}/{2}) ya aparece en la lista de compilación (en la posición {3}/{4}). Compruebe que solo se incluya una vez en el archivo del proyecto.</target>
         <note />
       </trans-unit>
       <trans-unit id="buildInvalidSourceFileExtensionML">
@@ -17,9 +22,29 @@
         <target state="translated">No se reconoce la extensión de archivo de '{0}'. Los archivos de código fuente deben tener las extensiones .fs, .fsi, .fsx o .fsscript</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkAbstractMembersDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkAdditionalConstructorOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Additional constructor is not allowed.</source>
+        <target state="translated">Si un tipo usa los atributos [&lt;Sealed&gt;] y [&lt;AbstractClass&gt;], significa que es estático. No se permite un constructor adicional.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkConstructorWithArgumentsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Constructor with arguments is not allowed.</source>
+        <target state="translated">Si un tipo usa los atributos [&lt;Sealed&gt;] y [&lt;AbstractClass&gt;], significa que es estático. No se permite un constructor con argumentos.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkDuplicatedMethodParameter">
         <source>Duplicate parameter. The parameter '{0}' has been used more that once in this method.</source>
-        <target state="new">Duplicate parameter. The parameter '{0}' has been used more that once in this method.</target>
+        <target state="translated">Parámetro duplicado. El parámetro '{0}' se ha usado más una vez en este método.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkExplicitFieldsDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</target>
         <note />
       </trans-unit>
       <trans-unit id="chkFeatureNotLanguageSupported">
@@ -37,6 +62,11 @@
         <target state="translated">La característica "{0}" requiere la biblioteca de F# para la versión de lenguaje {1} o superior.</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkImplementingInterfacesOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkInfoRefcellAssign">
         <source>The use of ':=' from the F# library is deprecated. See https://aka.ms/fsharp-refcell-ops. For example, please change 'cell := expr' to 'cell.Value &lt;- expr'.</source>
         <target state="translated">El uso de ":=" de la biblioteca de F# está en desuso. Vea https://aka.ms/fsharp-refcell-ops. Por ejemplo, cambie "cell := expr" a "cell.Value &lt;- expr".</target>
@@ -57,6 +87,16 @@
         <target state="translated">El uso de "incr" de la biblioteca de F# está en desuso. Vea https://aka.ms/fsharp-refcell-ops. Por ejemplo, cambie "incr cell" a "cell.Value &lt;- cell.Value + 1".</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkInstanceLetBindingOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkInstanceMemberOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance members are not allowed.</source>
+        <target state="translated">Si un tipo usa los atributos [&lt;Sealed&gt;] y [&lt;AbstractClass&gt;], significa que es estático. No se permiten miembros de instancia.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="containerDeprecated">
         <source>The 'AssemblyKeyNameAttribute' has been deprecated. Use 'AssemblyKeyFileAttribute' instead.</source>
         <target state="translated">El elemento "AssemblyKeyNameAttribute" está en desuso. Use "AssemblyKeyFileAttribute" en su lugar.</target>
@@ -114,7 +154,7 @@
       </trans-unit>
       <trans-unit id="elseBranchHasWrongTypeTuple">
         <source>All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Todas las ramas de una expresión 'if' deben devolver valores implícitamente convertibles al tipo de la primera rama, que aquí es una tupla de longitud {0} de tipo\n    {1}    \nEsta rama devuelve una tupla de longitud {2} de tipo\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="etProviderHasDesignerAssemblyDependency">
@@ -142,6 +182,11 @@
         <target state="translated">expresiones de cálculo aplicativas</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureArithmeticInLiterals">
+        <source>Allow arithmetic and logical operations in literals</source>
+        <target state="translated">Permitir operaciones aritméticas y lógicas en literales</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureAttributesToRightOfModuleKeyword">
         <source>attributes to the right of the 'module' keyword</source>
         <target state="translated">atributos a la derecha de la palabra clave “módulo”</target>
@@ -154,7 +199,7 @@
       </trans-unit>
       <trans-unit id="featureCSharpExtensionAttributeNotRequired">
         <source>Allow implicit Extension attribute on declaring types, modules</source>
-        <target state="new">Allow implicit Extension attribute on declaring types, modules</target>
+        <target state="translated">Permitir atributo Extension implícito en tipos declarativo, módulos</target>
         <note />
       </trans-unit>
       <trans-unit id="featureDefaultInterfaceMemberConsumption">
@@ -179,7 +224,7 @@
       </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
-        <target state="new">Raises errors for non-virtual members overrides</target>
+        <target state="translated">Genera errores para invalidaciones de miembros no virtuales</target>
         <note />
       </trans-unit>
       <trans-unit id="featureErrorOnDeprecatedRequireQualifiedAccess">
@@ -187,6 +232,16 @@
         <target state="translated">error en el acceso en desuso de la construcción con el atributo RequireQualifiedAccess</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureErrorReportingOnStaticClasses">
+        <source>Error reporting on static classes</source>
+        <target state="translated">Informe de errores en clases estáticas</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="featureEscapeBracesInFormattableString">
+        <source>Escapes curly braces before calling FormattableStringFactory.Create when interpolated string literal is typed as FormattableString</source>
+        <target state="translated">Crea un escape de llaves antes de llamar a FormattableStringFactory.Create cuando el literal de cadena interpolado se escribe como FormattableString.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureExpandedMeasurables">
         <source>more types support units of measure</source>
         <target state="translated">más tipos admiten las unidades de medida</target>
@@ -214,12 +269,12 @@
       </trans-unit>
       <trans-unit id="featureInitProperties">
         <source>support for consuming init properties</source>
-        <target state="new">support for consuming init properties</target>
+        <target state="translated">compatibilidad con el consumo de propiedades init</target>
         <note />
       </trans-unit>
       <trans-unit id="featureInterfacesWithAbstractStaticMembers">
         <source>static abstract interface members</source>
-        <target state="new">static abstract interface members</target>
+        <target state="translated">miembros de interfaz abstracta estática</target>
         <note />
       </trans-unit>
       <trans-unit id="featureInterfacesWithMultipleGenericInstantiation">
@@ -229,7 +284,7 @@
       </trans-unit>
       <trans-unit id="featureLowercaseDUWhenRequireQualifiedAccess">
         <source>Allow lowercase DU when RequireQualifiedAccess attribute</source>
-        <target state="new">Allow lowercase DU when RequireQualifiedAccess attribute</target>
+        <target state="translated">Permitir DU en minúsculas con el atributo RequireQualifiedAccess</target>
         <note />
       </trans-unit>
       <trans-unit id="featureMLCompatRevisions">
@@ -239,7 +294,7 @@
       </trans-unit>
       <trans-unit id="featureMatchNotAllowedForUnionCaseWithNoData">
         <source>Pattern match discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern match discard is not allowed for union case that takes no data.</target>
+        <target state="translated">No se permite el descarte de coincidencia de patrón para un caso de unión que no tome datos.</target>
         <note />
       </trans-unit>
       <trans-unit id="featureNameOf">
@@ -299,7 +354,7 @@
       </trans-unit>
       <trans-unit id="featureRequiredProperties">
         <source>support for required properties</source>
-        <target state="new">support for required properties</target>
+        <target state="translated">compatibilidad con las propiedades necesarias</target>
         <note />
       </trans-unit>
       <trans-unit id="featureResumableStateMachines">
@@ -309,7 +364,7 @@
       </trans-unit>
       <trans-unit id="featureSelfTypeConstraints">
         <source>self type constraints</source>
-        <target state="new">self type constraints</target>
+        <target state="translated">restricciones de tipo propio</target>
         <note />
       </trans-unit>
       <trans-unit id="featureSingleUnderscorePattern">
@@ -327,6 +382,11 @@
         <target state="translated">representación de struct para modelos activos</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureWarningWhenInliningMethodImplNoInlineMarkedFunction">
+        <source>Raises warnings when 'let inline ... =' is used together with [&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;] attribute. Function is not getting inlined.</source>
+        <target state="translated">Genera advertencias cuando se usa "let inline ... =" junto con el atributo [&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;]. La función no se está insertando.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureWildCardInForLoop">
         <source>wild card in for loop</source>
         <target state="translated">carácter comodín en bucle for</target>
@@ -339,7 +399,7 @@
       </trans-unit>
       <trans-unit id="followingPatternMatchClauseHasWrongTypeTuple">
         <source>All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Todas las ramas de una expresión de coincidencia de patrón deben devolver valores implícitamente convertibles al tipo de la primera rama, que aquí es una tupla de longitud {0} de tipo\n    {1}    \nEsta rama devuelve una tupla de longitud {2} de tipo\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="forFormatInvalidForInterpolated">
@@ -364,7 +424,7 @@
       </trans-unit>
       <trans-unit id="forPercentAInReflectionFreeCode">
         <source>The '%A' format specifier may not be used in an assembly being compiled with option '--reflectionfree'. This construct implicitly uses reflection.</source>
-        <target state="new">The '%A' format specifier may not be used in an assembly being compiled with option '--reflectionfree'. This construct implicitly uses reflection.</target>
+        <target state="translated">El especificador de formato '%A' no se puede usar en un ensamblado que se está compilando con la opción '--reflectionfree'. Esta construcción usa implícitamente la reflexión.</target>
         <note />
       </trans-unit>
       <trans-unit id="formatDashItem">
@@ -384,7 +444,7 @@
       </trans-unit>
       <trans-unit id="ifExpressionTuple">
         <source>The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">La expresión "if" debe devolver una tupla de longitud {0} de tipo\n    {1}    \npara satisfacer los requisitos de tipo de contexto. Actualmente devuelve una tupla de longitud {2} de tipo\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="ilxGenUnknownDebugPoint">
@@ -409,7 +469,7 @@
       </trans-unit>
       <trans-unit id="keywordDescriptionAnd">
         <source>Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</source>
-        <target state="new">Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</target>
+        <target state="translated">Se usa en enlaces mutuamente recursivos, en declaraciones de propiedad y con varias restricciones en parámetros genéricos.</target>
         <note />
       </trans-unit>
       <trans-unit id="keywordDescriptionConst">
@@ -419,7 +479,7 @@
       </trans-unit>
       <trans-unit id="keywordDescriptionTypeTest">
         <source>Used to check if an object is of the given type in a pattern or binding.</source>
-        <target state="new">Used to check if an object is of the given type in a pattern or binding.</target>
+        <target state="translated">Se usa para comprobar si un objeto es del tipo especificado en un patrón o enlace.</target>
         <note />
       </trans-unit>
       <trans-unit id="lexByteStringMayNotBeInterpolated">
@@ -449,12 +509,12 @@
       </trans-unit>
       <trans-unit id="listElementHasWrongTypeTuple">
         <source>All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Todos los elementos de una lista deben convertirse implícitamente en el tipo del primer elemento, que aquí es una tupla de longitud {0} de tipo\n    {1}    \nEste elemento es una tupla de longitud {2} de tipo\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="matchNotAllowedForUnionCaseWithNoData">
         <source>Pattern discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern discard is not allowed for union case that takes no data.</target>
+        <target state="translated">No se permite el descarte de patrón para un caso de unión que no tome datos.</target>
         <note />
       </trans-unit>
       <trans-unit id="mlCompatError">
@@ -529,17 +589,17 @@
       </trans-unit>
       <trans-unit id="optsCompressMetadata">
         <source>Compress interface and optimization data files</source>
-        <target state="new">Compress interface and optimization data files</target>
+        <target state="translated">Comprimir archivos de datos de interfaz y optimización</target>
         <note />
       </trans-unit>
       <trans-unit id="optsGetLangVersions">
         <source>Display the allowed values for language version.</source>
-        <target state="new">Display the allowed values for language version.</target>
+        <target state="translated">Muestra los valores permitidos para la versión del lenguaje.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsInvalidRefAssembly">
         <source>Invalid use of emitting a reference assembly, do not use '--standalone or --staticlink' with '--refonly or --refout'.</source>
-        <target state="needs-review-translation">Uso no válido de emitir un ensamblado de referencia, no use "--staticlink', or '--refonly' and '--refout" de forma conjunta.</target>
+        <target state="translated">Uso no válido de emisión de un ensamblado de referencia, no use '--standalone or --staticlink' con '--refonly or --refout'.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsInvalidRefOut">
@@ -549,12 +609,12 @@
       </trans-unit>
       <trans-unit id="optsOptimizationData">
         <source>Specify included optimization information, the default is file. Important for distributed libraries.</source>
-        <target state="new">Specify included optimization information, the default is file. Important for distributed libraries.</target>
+        <target state="translated">Especifique la información de optimización incluida, el valor predeterminado es el archivo. Importante para las bibliotecas distribuidas.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsPdbMatchesOutputFileName">
         <source>The pdb output file name cannot match the build output filename use --pdb:filename.pdb</source>
-        <target state="new">The pdb output file name cannot match the build output filename use --pdb:filename.pdb</target>
+        <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="optsRefOnly">
@@ -569,17 +629,17 @@
       </trans-unit>
       <trans-unit id="optsReflectionFree">
         <source>Disable implicit generation of constructs using reflection</source>
-        <target state="new">Disable implicit generation of constructs using reflection</target>
+        <target state="translated">Deshabilitar la generación implícita de construcciones mediante reflexión</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSetLangVersion">
         <source>Specify language version such as 'latest' or 'preview'.</source>
-        <target state="new">Specify language version such as 'latest' or 'preview'.</target>
+        <target state="translated">Especifique la versión de idioma, como "latest" o "preview".</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSignatureData">
         <source>Include F# interface information, the default is file. Essential for distributing libraries.</source>
-        <target state="new">Include F# interface information, the default is file. Essential for distributing libraries.</target>
+        <target state="translated">Incluir información de interfaz de F#, el valor predeterminado es file. Esencial para distribuir bibliotecas.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSupportedLangVersions">
@@ -589,12 +649,12 @@
       </trans-unit>
       <trans-unit id="optsUnknownOptimizationData">
         <source>Invalid value '{0}' for --optimizationdata, valid value are: none, file, compress.</source>
-        <target state="new">Invalid value '{0}' for --optimizationdata, valid value are: none, file, compress.</target>
+        <target state="translated">Valor no válido '{0}' para --optimizationdata; los valores válidos son: none, file, compress.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsUnknownSignatureData">
         <source>Invalid value '{0}' for --interfacedata, valid value are: none, file, compress.</source>
-        <target state="new">Invalid value '{0}' for --interfacedata, valid value are: none, file, compress.</target>
+        <target state="translated">Valor no válido '{0}' para --interfacedata; los valores válidos son: none, file, compress.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsUnrecognizedLanguageVersion">
@@ -649,7 +709,7 @@
       </trans-unit>
       <trans-unit id="parsExpectedPatternAfterToken">
         <source>Expected a pattern after this point</source>
-        <target state="new">Expected a pattern after this point</target>
+        <target state="translated">Se esperaba un patrón después de este punto</target>
         <note />
       </trans-unit>
       <trans-unit id="parsExpectingExpressionInTuple">
@@ -659,17 +719,17 @@
       </trans-unit>
       <trans-unit id="parsExpectingPatternInTuple">
         <source>Expecting pattern</source>
-        <target state="new">Expecting pattern</target>
+        <target state="translated">Se espera un patrón</target>
         <note />
       </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
         <source>Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</source>
-        <target state="new">Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</target>
+        <target state="translated">Literal de carácter incompleto (ejemplo: 'Q') o invocación de tipo completo (ejemplo: 'T.Name)</target>
         <note />
       </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr2">
         <source>Incomplete operator expression (example a^b) or qualified type invocation (example: ^T.Name)</source>
-        <target state="new">Incomplete operator expression (example a^b) or qualified type invocation (example: ^T.Name)</target>
+        <target state="translated">Expresión de operador incompleta (ejemplo, a^b) o invocación de tipo calificada (ejemplo: ^T.Name)</target>
         <note />
       </trans-unit>
       <trans-unit id="parsNewExprMemberAccess">
@@ -849,7 +909,7 @@
       </trans-unit>
       <trans-unit id="tcInitOnlyPropertyCannotBeSet1">
         <source>Init-only property '{0}' cannot be set outside the initialization code. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</source>
-        <target state="new">Init-only property '{0}' cannot be set outside the initialization code. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
+        <target state="translated">No se puede establecer la propiedad init-only '{0}' fuera del código de inicialización. Ver https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
         <note />
       </trans-unit>
       <trans-unit id="tcInlineIfLambdaUsedOnNonInlineFunctionOrMethod">
@@ -879,7 +939,7 @@
       </trans-unit>
       <trans-unit id="tcInvalidSelfConstraint">
         <source>Invalid constraint. Valid constraint forms include \"'T :&gt; ISomeInterface\" for interface constraints and \"SomeConstrainingType&lt;'T&gt;\" for self-constraints. See https://aka.ms/fsharp-type-constraints.</source>
-        <target state="new">Invalid constraint. Valid constraint forms include \"'T :&gt; ISomeInterface\" for interface constraints and \"SomeConstrainingType&lt;'T&gt;\" for self-constraints. See https://aka.ms/fsharp-type-constraints.</target>
+        <target state="translated">Restricción no válida. Los formularios de restricción válidos incluyen \"'T :&gt; ISomeInterface\" para restricciones de interfaz y \"SomeConstrainingType&lt;'T&gt;\" para restricciones propias. Ver https://aka.ms/fsharp-type-constraints.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcInvalidStructReturn">
@@ -924,7 +984,7 @@
       </trans-unit>
       <trans-unit id="tcMissingRequiredMembers">
         <source>The following required properties have to be initalized:{0}</source>
-        <target state="new">The following required properties have to be initalized:{0}</target>
+        <target state="translated">Se deben inicializar las siguientes propiedades necesarias:{0}</target>
         <note />
       </trans-unit>
       <trans-unit id="tcNoEagerConstraintApplicationAttribute">
@@ -1009,7 +1069,7 @@
       </trans-unit>
       <trans-unit id="tcSetterForInitOnlyPropertyCannotBeCalled1">
         <source>Cannot call '{0}' - a setter for init-only property, please use object initialization instead. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</source>
-        <target state="new">Cannot call '{0}' - a setter for init-only property, please use object initialization instead. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
+        <target state="translated">No se puede llamar a '{0}': un establecedor para una propiedad de solo inicialización. Use la inicialización del objeto en su lugar. Ver https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
         <note />
       </trans-unit>
       <trans-unit id="tcSubsumptionImplicitConversionUsed">
@@ -1019,32 +1079,32 @@
       </trans-unit>
       <trans-unit id="tcSynTypeOrInvalidInDeclaration">
         <source>SynType.Or is not permitted in this declaration</source>
-        <target state="new">SynType.Or is not permitted in this declaration</target>
+        <target state="translated">SynType.Or no se permite en esta declaración</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitHasMultipleSupportTypes">
         <source>The trait '{0}' invoked by this call has multiple support types. This invocation syntax is not permitted for such traits. See https://aka.ms/fsharp-srtp for guidance.</source>
-        <target state="new">The trait '{0}' invoked by this call has multiple support types. This invocation syntax is not permitted for such traits. See https://aka.ms/fsharp-srtp for guidance.</target>
+        <target state="translated">El rasgo '{0}' invocado por esta llamada tiene varios tipos de soporte. No se permite esta sintaxis de invocación para estos rasgos. Consulte https://aka.ms/fsharp-srtp para obtener instrucciones.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitInvocationShouldUseTick">
         <source>Invocation of a static constraint should use \"'T.Ident\" and not \"^T.Ident\", even for statically resolved type parameters.</source>
-        <target state="new">Invocation of a static constraint should use \"'T.Ident\" and not \"^T.Ident\", even for statically resolved type parameters.</target>
+        <target state="translated">La invocación de una restricción estática debe usar \"'T.Ident\" y no \"^T.Ident\", incluso para parámetros de tipo resueltos estáticamente.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitIsNotStatic">
         <source>Trait '{0}' is not static</source>
-        <target state="new">Trait '{0}' is not static</target>
+        <target state="translated">El rasgo '{0}' no es estático</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitIsStatic">
         <source>Trait '{0}' is static</source>
-        <target state="new">Trait '{0}' is static</target>
+        <target state="translated">El rasgo '{0}' es estático</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitMayNotUseComplexThings">
         <source>A trait may not specify optional, in, out, ParamArray, CallerInfo or Quote arguments</source>
-        <target state="new">A trait may not specify optional, in, out, ParamArray, CallerInfo or Quote arguments</target>
+        <target state="translated">Un rasgo no puede especificar argumentos opcionales, in, out, ParamArray, CallerInfo o Quote</target>
         <note />
       </trans-unit>
       <trans-unit id="tcUnableToParseInterpolatedString">
@@ -1054,12 +1114,12 @@
       </trans-unit>
       <trans-unit id="tcUsingInterfaceWithStaticAbstractMethodAsType">
         <source>'{0}' is normally used as a type constraint in generic code, e.g. \"'T when ISomeInterface&lt;'T&gt;\" or \"let f (x: #ISomeInterface&lt;_&gt;)\". See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3536\"' or '--nowarn:3536'.</source>
-        <target state="new">'{0}' is normally used as a type constraint in generic code, e.g. \"'T when ISomeInterface&lt;'T&gt;\" or \"let f (x: #ISomeInterface&lt;_&gt;)\". See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3536\"' or '--nowarn:3536'.</target>
+        <target state="translated">'{0}' se usa normalmente como restricción de tipo en código genérico; por ejemplo, \"'T when ISomeInterface&lt;'T&gt;\" o \"let f (x: #ISomeInterface&lt;_&gt;)\". Consulte https://aka.ms/fsharp-iwsams para obtener instrucciones. Puede deshabilitar esta advertencia con "#nowarn \"3536\"" o "--nowarn:3536".</target>
         <note />
       </trans-unit>
       <trans-unit id="tcUsingInterfacesWithStaticAbstractMethods">
         <source>Declaring \"interfaces with static abstract methods\" is an advanced feature. See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3535\"' or '--nowarn:3535'.</source>
-        <target state="new">Declaring \"interfaces with static abstract methods\" is an advanced feature. See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3535\"' or '--nowarn:3535'.</target>
+        <target state="translated">Declarar \"interfaces con métodos abstractos estáticos\" es una característica avanzada. Consulte https://aka.ms/fsharp-iwsams para obtener instrucciones. Puede deshabilitar esta advertencia con "#nowarn \"3535\"" o "--nowarn:3535".</target>
         <note />
       </trans-unit>
       <trans-unit id="typrelInterfaceMemberNoMostSpecificImplementation">
@@ -3849,7 +3909,7 @@
       </trans-unit>
       <trans-unit id="tcUnionCaseExpectsTupledArguments">
         <source>This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</source>
-        <target state="new">This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</target>
+        <target state="translated">Este caso de unión espera {0} argumentos en forma de combinación, pero se han proporcionado {1}. Los argumentos de campo que faltan pueden ser cualquiera de:{2}</target>
         <note />
       </trans-unit>
       <trans-unit id="tcFieldIsNotStatic">
@@ -7529,7 +7589,7 @@
       </trans-unit>
       <trans-unit id="tcStructUnionMultiCaseDistinctFields">
         <source>If a multicase union type is a struct, then all union cases must have unique names. For example: 'type A = B of b: int | C of c: int'.</source>
-        <target state="needs-review-translation">Si un tipo de unión tiene más de un caso y un struct, a todos los campos dentro del tipo de unión se les deben dar nombres únicos.</target>
+        <target state="translated">Si un tipo de unión multicase es un struct, todos los casos de unión deben tener nombres únicos. Por ejemplo: 'type A = B of b: int | C of c: int'.</target>
         <note />
       </trans-unit>
       <trans-unit id="CallerMemberNameIsOverriden">
diff --git a/src/Compiler/xlf/FSComp.txt.fr.xlf b/src/Compiler/xlf/FSComp.txt.fr.xlf
index 54cad306cd2..a7b82e51172 100644
--- a/src/Compiler/xlf/FSComp.txt.fr.xlf
+++ b/src/Compiler/xlf/FSComp.txt.fr.xlf
@@ -4,7 +4,12 @@
     <body>
       <trans-unit id="arrayElementHasWrongTypeTuple">
         <source>All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Tous les éléments d’un tableau doivent être implicitement convertibles en type du premier élément, qui est ici un tuple de longueur {0} de type\n    {1}    \nCet élément est un tuple de longueur {2} de type\n    {3}    \n</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="buildDuplicateFile">
+        <source>The source file '{0}' (at position {1}/{2}) already appeared in the compilation list (at position {3}/{4}). Please verify that it is included only once in the project file.</source>
+        <target state="translated">Le fichier source « {0} » (à la position {1}/{2}) apparaît déjà dans la liste de compilation (à la position {3}/{4}). Vérifiez qu’il n’est inclus qu’une seule fois dans le fichier projet.</target>
         <note />
       </trans-unit>
       <trans-unit id="buildInvalidSourceFileExtensionML">
@@ -17,9 +22,29 @@
         <target state="translated">L'extension de fichier de '{0}' n'est pas reconnue. Les fichiers sources doivent avoir l'extension .fs, .fsi, .fsx, ou .fsscript.</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkAbstractMembersDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkAdditionalConstructorOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Additional constructor is not allowed.</source>
+        <target state="translated">Si un type utilise les attributs [&lt;Sealed&gt;] et [&lt;AbstractClass&gt;], cela signifie qu’il est statique. Un constructeur supplémentaire n’est pas autorisé.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkConstructorWithArgumentsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Constructor with arguments is not allowed.</source>
+        <target state="translated">Si un type utilise les attributs [&lt;Sealed&gt;] et [&lt;AbstractClass&gt;], cela signifie qu’il est statique. Le constructeur avec des arguments n’est pas autorisé.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkDuplicatedMethodParameter">
         <source>Duplicate parameter. The parameter '{0}' has been used more that once in this method.</source>
-        <target state="new">Duplicate parameter. The parameter '{0}' has been used more that once in this method.</target>
+        <target state="translated">Paramètre dupliqué. Le paramètre « {0} » a été utilisé une fois de plus dans cette méthode.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkExplicitFieldsDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</target>
         <note />
       </trans-unit>
       <trans-unit id="chkFeatureNotLanguageSupported">
@@ -37,6 +62,11 @@
         <target state="translated">La fonctionnalité '{0}' nécessite la bibliothèque F# pour le langage version {1} ou ultérieure.</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkImplementingInterfacesOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkInfoRefcellAssign">
         <source>The use of ':=' from the F# library is deprecated. See https://aka.ms/fsharp-refcell-ops. For example, please change 'cell := expr' to 'cell.Value &lt;- expr'.</source>
         <target state="translated">L’utilisation de « := » à partir de la bibliothèque F# est déconseillée. Voir https://aka.ms/fsharp-refcell-ops. Par exemple, veuillez remplacer « cell := expr » par « cell.Value &lt;- expr ».</target>
@@ -57,6 +87,16 @@
         <target state="translated">L’utilisation de « incr » à partir de la bibliothèque F# est déconseillée. Voir https://aka.ms/fsharp-refcell-ops. Par exemple, veuillez remplacer « incr cell » par « cell.Value &lt;- cell.Value + 1 ».</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkInstanceLetBindingOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkInstanceMemberOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance members are not allowed.</source>
+        <target state="translated">Si un type utilise les attributs [&lt;Sealed&gt;] et [&lt;AbstractClass&gt;], cela signifie qu’il est statique. Les membres de l’instance ne sont pas autorisés.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="containerDeprecated">
         <source>The 'AssemblyKeyNameAttribute' has been deprecated. Use 'AssemblyKeyFileAttribute' instead.</source>
         <target state="translated">'AssemblyKeyNameAttribute' a été déprécié. Utilisez 'AssemblyKeyFileAttribute' à la place.</target>
@@ -114,7 +154,7 @@
       </trans-unit>
       <trans-unit id="elseBranchHasWrongTypeTuple">
         <source>All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Toutes les branches d’une expression « if » doivent retourner des valeurs implicitement convertibles au type de la première branche, qui est ici un tuple de longueur {0} de type\n    {1}    \nCette branche renvoie un tuple de longueur {2} de type\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="etProviderHasDesignerAssemblyDependency">
@@ -142,6 +182,11 @@
         <target state="translated">expressions de calcul applicatives</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureArithmeticInLiterals">
+        <source>Allow arithmetic and logical operations in literals</source>
+        <target state="translated">Autoriser les opérations arithmétiques et logiques dans les littéraux</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureAttributesToRightOfModuleKeyword">
         <source>attributes to the right of the 'module' keyword</source>
         <target state="translated">attributs à droite du mot clé 'module'</target>
@@ -154,7 +199,7 @@
       </trans-unit>
       <trans-unit id="featureCSharpExtensionAttributeNotRequired">
         <source>Allow implicit Extension attribute on declaring types, modules</source>
-        <target state="new">Allow implicit Extension attribute on declaring types, modules</target>
+        <target state="translated">Autoriser l’attribut implicite Extension lors de la déclaration des types, modules</target>
         <note />
       </trans-unit>
       <trans-unit id="featureDefaultInterfaceMemberConsumption">
@@ -179,7 +224,7 @@
       </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
-        <target state="new">Raises errors for non-virtual members overrides</target>
+        <target state="translated">Déclenche des erreurs pour les remplacements de membres non virtuels</target>
         <note />
       </trans-unit>
       <trans-unit id="featureErrorOnDeprecatedRequireQualifiedAccess">
@@ -187,6 +232,16 @@
         <target state="translated">donner une erreur sur l’accès déconseillé de la construction avec l’attribut RequireQualifiedAccess</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureErrorReportingOnStaticClasses">
+        <source>Error reporting on static classes</source>
+        <target state="translated">Rapport d’erreurs sur les classes statiques</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="featureEscapeBracesInFormattableString">
+        <source>Escapes curly braces before calling FormattableStringFactory.Create when interpolated string literal is typed as FormattableString</source>
+        <target state="translated">Échappe les accolades avant d’appeler FormattableStringFactory.Create lorsque le littéral de chaîne interpolé est tapé en tant que FormattableString.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureExpandedMeasurables">
         <source>more types support units of measure</source>
         <target state="translated">d'autres types prennent en charge les unités de mesure</target>
@@ -214,12 +269,12 @@
       </trans-unit>
       <trans-unit id="featureInitProperties">
         <source>support for consuming init properties</source>
-        <target state="new">support for consuming init properties</target>
+        <target state="translated">prise en charge de la consommation des propriétés init</target>
         <note />
       </trans-unit>
       <trans-unit id="featureInterfacesWithAbstractStaticMembers">
         <source>static abstract interface members</source>
-        <target state="new">static abstract interface members</target>
+        <target state="translated">membres d’interface abstraite statiques</target>
         <note />
       </trans-unit>
       <trans-unit id="featureInterfacesWithMultipleGenericInstantiation">
@@ -229,7 +284,7 @@
       </trans-unit>
       <trans-unit id="featureLowercaseDUWhenRequireQualifiedAccess">
         <source>Allow lowercase DU when RequireQualifiedAccess attribute</source>
-        <target state="new">Allow lowercase DU when RequireQualifiedAccess attribute</target>
+        <target state="translated">Autoriser les DU en minuscules pour l'attribut RequireQualifiedAccess</target>
         <note />
       </trans-unit>
       <trans-unit id="featureMLCompatRevisions">
@@ -239,7 +294,7 @@
       </trans-unit>
       <trans-unit id="featureMatchNotAllowedForUnionCaseWithNoData">
         <source>Pattern match discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern match discard is not allowed for union case that takes no data.</target>
+        <target state="translated">L’abandon des correspondances de modèle n’est pas autorisé pour un cas d’union qui n’accepte aucune donnée.</target>
         <note />
       </trans-unit>
       <trans-unit id="featureNameOf">
@@ -299,7 +354,7 @@
       </trans-unit>
       <trans-unit id="featureRequiredProperties">
         <source>support for required properties</source>
-        <target state="new">support for required properties</target>
+        <target state="translated">prise en charge des propriétés obligatoires</target>
         <note />
       </trans-unit>
       <trans-unit id="featureResumableStateMachines">
@@ -309,7 +364,7 @@
       </trans-unit>
       <trans-unit id="featureSelfTypeConstraints">
         <source>self type constraints</source>
-        <target state="new">self type constraints</target>
+        <target state="translated">contraintes d’auto-type</target>
         <note />
       </trans-unit>
       <trans-unit id="featureSingleUnderscorePattern">
@@ -327,6 +382,11 @@
         <target state="translated">représentation de structure pour les modèles actifs</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureWarningWhenInliningMethodImplNoInlineMarkedFunction">
+        <source>Raises warnings when 'let inline ... =' is used together with [&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;] attribute. Function is not getting inlined.</source>
+        <target state="translated">Génère des avertissements lorsque « let inline ... = » est utilisé avec l’attribut [&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;]. La fonction n’est pas inlined.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureWildCardInForLoop">
         <source>wild card in for loop</source>
         <target state="translated">caractère générique dans une boucle for</target>
@@ -339,7 +399,7 @@
       </trans-unit>
       <trans-unit id="followingPatternMatchClauseHasWrongTypeTuple">
         <source>All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Toutes les branches d’une expression de correspondance de motifs doivent retourner des valeurs implicitement convertibles au type de la première branche, qui est ici un tuple de longueur {0} de type\n    {1}    \nCette branche renvoie un tuple de longueur {2} de type\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="forFormatInvalidForInterpolated">
@@ -364,7 +424,7 @@
       </trans-unit>
       <trans-unit id="forPercentAInReflectionFreeCode">
         <source>The '%A' format specifier may not be used in an assembly being compiled with option '--reflectionfree'. This construct implicitly uses reflection.</source>
-        <target state="new">The '%A' format specifier may not be used in an assembly being compiled with option '--reflectionfree'. This construct implicitly uses reflection.</target>
+        <target state="translated">Le spécificateur de format '%A' ne peut pas être utilisé dans un assembly compilé avec l’option '--reflectionfree'. Cette construction utilise implicitement la réflexion.</target>
         <note />
       </trans-unit>
       <trans-unit id="formatDashItem">
@@ -384,7 +444,7 @@
       </trans-unit>
       <trans-unit id="ifExpressionTuple">
         <source>The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">L’expression « if » doit retourner un tuple de longueur {0} de type\n    {1}    \npour répondre aux exigences de type de contexte. Il retourne actuellement un tuple de longueur {2} de type\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="ilxGenUnknownDebugPoint">
@@ -409,7 +469,7 @@
       </trans-unit>
       <trans-unit id="keywordDescriptionAnd">
         <source>Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</source>
-        <target state="new">Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</target>
+        <target state="translated">Utilisé dans les liaisons mutuellement récursives, dans les déclarations de propriété et avec plusieurs contraintes sur des paramètres génériques.</target>
         <note />
       </trans-unit>
       <trans-unit id="keywordDescriptionConst">
@@ -419,7 +479,7 @@
       </trans-unit>
       <trans-unit id="keywordDescriptionTypeTest">
         <source>Used to check if an object is of the given type in a pattern or binding.</source>
-        <target state="new">Used to check if an object is of the given type in a pattern or binding.</target>
+        <target state="translated">Permet de vérifier si un objet est du type donné dans un modèle ou une liaison.</target>
         <note />
       </trans-unit>
       <trans-unit id="lexByteStringMayNotBeInterpolated">
@@ -449,12 +509,12 @@
       </trans-unit>
       <trans-unit id="listElementHasWrongTypeTuple">
         <source>All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Tous les éléments d’une liste doivent être implicitement convertibles en type du premier élément, qui est ici un tuple de longueur {0} de type\n    {1}    \nCet élément est un tuple de longueur {2} de type\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="matchNotAllowedForUnionCaseWithNoData">
         <source>Pattern discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern discard is not allowed for union case that takes no data.</target>
+        <target state="translated">L’abandon de modèle n’est pas autorisé pour un cas d’union qui n’accepte aucune donnée.</target>
         <note />
       </trans-unit>
       <trans-unit id="mlCompatError">
@@ -529,17 +589,17 @@
       </trans-unit>
       <trans-unit id="optsCompressMetadata">
         <source>Compress interface and optimization data files</source>
-        <target state="new">Compress interface and optimization data files</target>
+        <target state="translated">Compresser les fichiers de données d’interface et d’optimisation</target>
         <note />
       </trans-unit>
       <trans-unit id="optsGetLangVersions">
         <source>Display the allowed values for language version.</source>
-        <target state="new">Display the allowed values for language version.</target>
+        <target state="translated">Affichez les valeurs autorisées pour la version du langage.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsInvalidRefAssembly">
         <source>Invalid use of emitting a reference assembly, do not use '--standalone or --staticlink' with '--refonly or --refout'.</source>
-        <target state="needs-review-translation">Utilisation non valide de l’émission d’un assembly de référence. N’utilisez pas '--staticlink' ni '--refonly' et '--refout' ensemble.</target>
+        <target state="translated">Utilisation non valide de l’émission d’un assembly de référence, n’utilisez pas '--standalone ou --staticlink' avec '--refonly ou --refout'.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsInvalidRefOut">
@@ -549,12 +609,12 @@
       </trans-unit>
       <trans-unit id="optsOptimizationData">
         <source>Specify included optimization information, the default is file. Important for distributed libraries.</source>
-        <target state="new">Specify included optimization information, the default is file. Important for distributed libraries.</target>
+        <target state="translated">Spécifiez les informations d’optimisation incluses, la valeur par défaut est le fichier. Important pour les bibliothèques distribuées.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsPdbMatchesOutputFileName">
         <source>The pdb output file name cannot match the build output filename use --pdb:filename.pdb</source>
-        <target state="new">The pdb output file name cannot match the build output filename use --pdb:filename.pdb</target>
+        <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="optsRefOnly">
@@ -569,17 +629,17 @@
       </trans-unit>
       <trans-unit id="optsReflectionFree">
         <source>Disable implicit generation of constructs using reflection</source>
-        <target state="new">Disable implicit generation of constructs using reflection</target>
+        <target state="translated">Désactiver la génération implicite de constructions à l’aide de la réflexion</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSetLangVersion">
         <source>Specify language version such as 'latest' or 'preview'.</source>
-        <target state="new">Specify language version such as 'latest' or 'preview'.</target>
+        <target state="translated">Spécifiez une version de langage telle que 'latest' ou 'preview'.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSignatureData">
         <source>Include F# interface information, the default is file. Essential for distributing libraries.</source>
-        <target state="new">Include F# interface information, the default is file. Essential for distributing libraries.</target>
+        <target state="translated">Incluez les informations de l’interface F#, la valeur par défaut est un fichier. Essentiel pour la distribution des bibliothèques.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSupportedLangVersions">
@@ -589,12 +649,12 @@
       </trans-unit>
       <trans-unit id="optsUnknownOptimizationData">
         <source>Invalid value '{0}' for --optimizationdata, valid value are: none, file, compress.</source>
-        <target state="new">Invalid value '{0}' for --optimizationdata, valid value are: none, file, compress.</target>
+        <target state="translated">Valeur non valide '{0}' pour --optimizationdata. Les valeurs valides sont : none, file, compress.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsUnknownSignatureData">
         <source>Invalid value '{0}' for --interfacedata, valid value are: none, file, compress.</source>
-        <target state="new">Invalid value '{0}' for --interfacedata, valid value are: none, file, compress.</target>
+        <target state="translated">Valeur non valide '{0}' pour --interfacedata. Les valeurs valides sont : none, file, compress.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsUnrecognizedLanguageVersion">
@@ -649,7 +709,7 @@
       </trans-unit>
       <trans-unit id="parsExpectedPatternAfterToken">
         <source>Expected a pattern after this point</source>
-        <target state="new">Expected a pattern after this point</target>
+        <target state="translated">Modèle attendu après ce point</target>
         <note />
       </trans-unit>
       <trans-unit id="parsExpectingExpressionInTuple">
@@ -659,17 +719,17 @@
       </trans-unit>
       <trans-unit id="parsExpectingPatternInTuple">
         <source>Expecting pattern</source>
-        <target state="new">Expecting pattern</target>
+        <target state="translated">Modèle attendu</target>
         <note />
       </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
         <source>Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</source>
-        <target state="new">Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</target>
+        <target state="translated">Littéral de caractère incomplet (exemple : 'Q') ou appel de type qualifié (exemple : 'T.Name)</target>
         <note />
       </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr2">
         <source>Incomplete operator expression (example a^b) or qualified type invocation (example: ^T.Name)</source>
-        <target state="new">Incomplete operator expression (example a^b) or qualified type invocation (example: ^T.Name)</target>
+        <target state="translated">Expression d’opérateur incomplète (exemple a^b) ou appel de type qualifié (exemple : ^T.Name)</target>
         <note />
       </trans-unit>
       <trans-unit id="parsNewExprMemberAccess">
@@ -849,7 +909,7 @@
       </trans-unit>
       <trans-unit id="tcInitOnlyPropertyCannotBeSet1">
         <source>Init-only property '{0}' cannot be set outside the initialization code. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</source>
-        <target state="new">Init-only property '{0}' cannot be set outside the initialization code. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
+        <target state="translated">La propriété init-only '{0}' ne peut pas être définie en dehors du code d’initialisation. Voir https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
         <note />
       </trans-unit>
       <trans-unit id="tcInlineIfLambdaUsedOnNonInlineFunctionOrMethod">
@@ -879,7 +939,7 @@
       </trans-unit>
       <trans-unit id="tcInvalidSelfConstraint">
         <source>Invalid constraint. Valid constraint forms include \"'T :&gt; ISomeInterface\" for interface constraints and \"SomeConstrainingType&lt;'T&gt;\" for self-constraints. See https://aka.ms/fsharp-type-constraints.</source>
-        <target state="new">Invalid constraint. Valid constraint forms include \"'T :&gt; ISomeInterface\" for interface constraints and \"SomeConstrainingType&lt;'T&gt;\" for self-constraints. See https://aka.ms/fsharp-type-constraints.</target>
+        <target state="translated">Contrainte non valide. Les formes de contrainte valides incluent \"'T :&gt; ISomeInterface\" pour les contraintes d’interface et \"SomeConstrainingType&lt;'T&gt;\" pour les contraintes automatiques. Consultez https://aka.ms/fsharp-type-constraints.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcInvalidStructReturn">
@@ -924,7 +984,7 @@
       </trans-unit>
       <trans-unit id="tcMissingRequiredMembers">
         <source>The following required properties have to be initalized:{0}</source>
-        <target state="new">The following required properties have to be initalized:{0}</target>
+        <target state="translated">Les propriétés requises suivantes doivent être initialisées :{0}</target>
         <note />
       </trans-unit>
       <trans-unit id="tcNoEagerConstraintApplicationAttribute">
@@ -1009,7 +1069,7 @@
       </trans-unit>
       <trans-unit id="tcSetterForInitOnlyPropertyCannotBeCalled1">
         <source>Cannot call '{0}' - a setter for init-only property, please use object initialization instead. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</source>
-        <target state="new">Cannot call '{0}' - a setter for init-only property, please use object initialization instead. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
+        <target state="translated">Nous n’avons pas pu appeler '{0}' - méthode setter pour la propriété init-only. Utilisez plutôt l’initialisation d’objet. Consultez https://aka.ms/fsharp-assigning-values-to-properties-at-initialization.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcSubsumptionImplicitConversionUsed">
@@ -1019,32 +1079,32 @@
       </trans-unit>
       <trans-unit id="tcSynTypeOrInvalidInDeclaration">
         <source>SynType.Or is not permitted in this declaration</source>
-        <target state="new">SynType.Or is not permitted in this declaration</target>
+        <target state="translated">SynType.Or n’est pas autorisé dans cette déclaration</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitHasMultipleSupportTypes">
         <source>The trait '{0}' invoked by this call has multiple support types. This invocation syntax is not permitted for such traits. See https://aka.ms/fsharp-srtp for guidance.</source>
-        <target state="new">The trait '{0}' invoked by this call has multiple support types. This invocation syntax is not permitted for such traits. See https://aka.ms/fsharp-srtp for guidance.</target>
+        <target state="translated">La caractéristique '{0}' invoquée par cet appel a plusieurs types de prise en charge. Cette syntaxe d’appel n’est pas autorisée pour de telles caractéristiques. Consultez https://aka.ms/fsharp-srtp pour obtenir de l’aide.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitInvocationShouldUseTick">
         <source>Invocation of a static constraint should use \"'T.Ident\" and not \"^T.Ident\", even for statically resolved type parameters.</source>
-        <target state="new">Invocation of a static constraint should use \"'T.Ident\" and not \"^T.Ident\", even for statically resolved type parameters.</target>
+        <target state="translated">L’appel d’une contrainte statique doit utiliser \"'T.Ident\" et non \"^T.Ident\", même pour les paramètres de type résolus statiquement.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitIsNotStatic">
         <source>Trait '{0}' is not static</source>
-        <target state="new">Trait '{0}' is not static</target>
+        <target state="translated">Le '{0}' de caractéristique n’est pas statique.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitIsStatic">
         <source>Trait '{0}' is static</source>
-        <target state="new">Trait '{0}' is static</target>
+        <target state="translated">Le '{0}' de caractéristique est statique.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitMayNotUseComplexThings">
         <source>A trait may not specify optional, in, out, ParamArray, CallerInfo or Quote arguments</source>
-        <target state="new">A trait may not specify optional, in, out, ParamArray, CallerInfo or Quote arguments</target>
+        <target state="translated">Une caractéristique ne peut pas spécifier d’arguments facultatifs, in, out, ParamArray, CallerInfo ou Quote</target>
         <note />
       </trans-unit>
       <trans-unit id="tcUnableToParseInterpolatedString">
@@ -1054,12 +1114,12 @@
       </trans-unit>
       <trans-unit id="tcUsingInterfaceWithStaticAbstractMethodAsType">
         <source>'{0}' is normally used as a type constraint in generic code, e.g. \"'T when ISomeInterface&lt;'T&gt;\" or \"let f (x: #ISomeInterface&lt;_&gt;)\". See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3536\"' or '--nowarn:3536'.</source>
-        <target state="new">'{0}' is normally used as a type constraint in generic code, e.g. \"'T when ISomeInterface&lt;'T&gt;\" or \"let f (x: #ISomeInterface&lt;_&gt;)\". See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3536\"' or '--nowarn:3536'.</target>
+        <target state="translated">'{0}' est généralement utilisée comme contrainte de type dans le code générique, par exemple \"'T when ISomeInterface&lt;'T&gt;\" or \"let f (x: #ISomeInterface&lt;_&gt;)\". Consultez https://aka.ms/fsharp-iwsams pour obtenir de l’aide. Vous pouvez désactiver cet avertissement à l’aide de '#nowarn \"3536\"' or '--nowarn:3536'.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcUsingInterfacesWithStaticAbstractMethods">
         <source>Declaring \"interfaces with static abstract methods\" is an advanced feature. See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3535\"' or '--nowarn:3535'.</source>
-        <target state="new">Declaring \"interfaces with static abstract methods\" is an advanced feature. See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3535\"' or '--nowarn:3535'.</target>
+        <target state="translated">La déclaration de \"interfaces with static abstract methods\" est une fonctionnalité avancée. Consultez https://aka.ms/fsharp-iwsams pour obtenir de l’aide. Vous pouvez désactiver cet avertissement à l’aide de '#nowarn \"3535\"' or '--nowarn:3535'.</target>
         <note />
       </trans-unit>
       <trans-unit id="typrelInterfaceMemberNoMostSpecificImplementation">
@@ -3849,7 +3909,7 @@
       </trans-unit>
       <trans-unit id="tcUnionCaseExpectsTupledArguments">
         <source>This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</source>
-        <target state="new">This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</target>
+        <target state="translated">Ce cas d’union attend des arguments {0} sous forme tuple, mais a reçu {1}. Les arguments de champ manquants peuvent être l’un des suivants : {2}</target>
         <note />
       </trans-unit>
       <trans-unit id="tcFieldIsNotStatic">
@@ -7529,7 +7589,7 @@
       </trans-unit>
       <trans-unit id="tcStructUnionMultiCaseDistinctFields">
         <source>If a multicase union type is a struct, then all union cases must have unique names. For example: 'type A = B of b: int | C of c: int'.</source>
-        <target state="needs-review-translation">Si un type union a plusieurs étiquettes case, et s'il s'agit d'un struct, tous les champs du type union doivent avoir des noms uniques.</target>
+        <target state="translated">Si un type d’union multi-cas est un struct, alors tous les cas d’union doivent avoir des noms uniques. Par exemple : 'type A = B de b : int | C de c : int'.</target>
         <note />
       </trans-unit>
       <trans-unit id="CallerMemberNameIsOverriden">
diff --git a/src/Compiler/xlf/FSComp.txt.it.xlf b/src/Compiler/xlf/FSComp.txt.it.xlf
index 007dc9646b8..fcd590c3b39 100644
--- a/src/Compiler/xlf/FSComp.txt.it.xlf
+++ b/src/Compiler/xlf/FSComp.txt.it.xlf
@@ -4,7 +4,12 @@
     <body>
       <trans-unit id="arrayElementHasWrongTypeTuple">
         <source>All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Tutti gli elementi di una matrice devono essere convertibili in modo implicito nel tipo del primo elemento, che qui è una tupla di lunghezza {0} di tipo\n {1}    \nQuesto elemento è una tupla di lunghezza {2} di tipo\n    {3} \n</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="buildDuplicateFile">
+        <source>The source file '{0}' (at position {1}/{2}) already appeared in the compilation list (at position {3}/{4}). Please verify that it is included only once in the project file.</source>
+        <target state="translated">Il file di origine '{0}' (nella posizione {1}/{2}) è già presente nell'elenco di compilazione (nella posizione {3}/{4}). Verificare che sia incluso solo una volta nel file di progetto.</target>
         <note />
       </trans-unit>
       <trans-unit id="buildInvalidSourceFileExtensionML">
@@ -17,9 +22,29 @@
         <target state="translated">Estensione di file di '{0}' non riconosciuta. I file di origine devono avere estensione .fs, .fsi, .fsx or .fsscript</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkAbstractMembersDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkAdditionalConstructorOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Additional constructor is not allowed.</source>
+        <target state="translated">Se un tipo usa entrambi gli attributi [&lt;Sealed&gt;] e [&lt;AbstractClass&gt;], significa che è statico. Non sono ammessi costruttori aggiuntivi.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkConstructorWithArgumentsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Constructor with arguments is not allowed.</source>
+        <target state="translated">Se un tipo usa entrambi gli attributi [&lt;Sealed&gt;] e [&lt;AbstractClass&gt;], significa che è statico. Costruttore con argomenti non consentito.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkDuplicatedMethodParameter">
         <source>Duplicate parameter. The parameter '{0}' has been used more that once in this method.</source>
-        <target state="new">Duplicate parameter. The parameter '{0}' has been used more that once in this method.</target>
+        <target state="translated">Parametro duplicato. Il parametro '{0}' è stato utilizzato più volte in questo metodo.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkExplicitFieldsDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</target>
         <note />
       </trans-unit>
       <trans-unit id="chkFeatureNotLanguageSupported">
@@ -37,6 +62,11 @@
         <target state="translated">Con la funzionalità '{0}' è richiesta la libreria F# per la versione {1} o successiva del linguaggio.</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkImplementingInterfacesOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkInfoRefcellAssign">
         <source>The use of ':=' from the F# library is deprecated. See https://aka.ms/fsharp-refcell-ops. For example, please change 'cell := expr' to 'cell.Value &lt;- expr'.</source>
         <target state="translated">L'uso di ':=' dalla libreria F # è deprecato. Vedere https://aka.ms/fsharp-refcell-ops. Ad esempio, modificare 'cell:= expr' in 'cell.Value &lt;- expr'.</target>
@@ -57,6 +87,16 @@
         <target state="translated">L'uso di 'incr' dalla libreria F # è deprecato. Vedere https://aka.ms/fsharp-refcell-ops. Ad esempio, modificare 'incr cell' in 'cell.Value &lt;- cell.Value + 1'.</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkInstanceLetBindingOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkInstanceMemberOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance members are not allowed.</source>
+        <target state="translated">Se un tipo usa entrambi gli attributi [&lt;Sealed&gt;] e [&lt;AbstractClass&gt;], significa che è statico. Membri dell'istanza non consentiti.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="containerDeprecated">
         <source>The 'AssemblyKeyNameAttribute' has been deprecated. Use 'AssemblyKeyFileAttribute' instead.</source>
         <target state="translated">L'attributo 'AssemblyKeyNameAttribute' è deprecato. In alternativa, usare 'AssemblyKeyFileAttribute'.</target>
@@ -114,7 +154,7 @@
       </trans-unit>
       <trans-unit id="elseBranchHasWrongTypeTuple">
         <source>All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Tutti i rami di un'espressione 'if' devono restituire valori convertibili in modo implicito nel tipo del primo ramo, che è una tupla di lunghezza {0} di tipo\n    {1}     \nQuesto ramo restituisce una tupla di lunghezza {2} di tipo\n    {3} \n</target>
         <note />
       </trans-unit>
       <trans-unit id="etProviderHasDesignerAssemblyDependency">
@@ -142,6 +182,11 @@
         <target state="translated">espressioni di calcolo applicativo</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureArithmeticInLiterals">
+        <source>Allow arithmetic and logical operations in literals</source>
+        <target state="translated">Consentire operazioni aritmetiche e logiche in valori letterali</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureAttributesToRightOfModuleKeyword">
         <source>attributes to the right of the 'module' keyword</source>
         <target state="translated">attributi a destra della parola chiave 'module'</target>
@@ -154,7 +199,7 @@
       </trans-unit>
       <trans-unit id="featureCSharpExtensionAttributeNotRequired">
         <source>Allow implicit Extension attribute on declaring types, modules</source>
-        <target state="new">Allow implicit Extension attribute on declaring types, modules</target>
+        <target state="translated">Consentire l'attributo estensione implicito per i tipi dichiarabili, i moduli</target>
         <note />
       </trans-unit>
       <trans-unit id="featureDefaultInterfaceMemberConsumption">
@@ -179,7 +224,7 @@
       </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
-        <target state="new">Raises errors for non-virtual members overrides</target>
+        <target state="translated">Genera errori per gli override dei membri non virtuali</target>
         <note />
       </trans-unit>
       <trans-unit id="featureErrorOnDeprecatedRequireQualifiedAccess">
@@ -187,6 +232,16 @@
         <target state="translated">errore durante l'accesso deprecato del costrutto con l'attributo RequireQualifiedAccess</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureErrorReportingOnStaticClasses">
+        <source>Error reporting on static classes</source>
+        <target state="translated">Segnalazione errori nelle classi statiche</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="featureEscapeBracesInFormattableString">
+        <source>Escapes curly braces before calling FormattableStringFactory.Create when interpolated string literal is typed as FormattableString</source>
+        <target state="translated">Trasferisce le parentesi graffe prima di chiamare FormattableStringFactory.Create quando il valore letterale stringa interpolato viene digitato come FormattableString</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureExpandedMeasurables">
         <source>more types support units of measure</source>
         <target state="translated">più tipi supportano le unità di misura</target>
@@ -214,12 +269,12 @@
       </trans-unit>
       <trans-unit id="featureInitProperties">
         <source>support for consuming init properties</source>
-        <target state="new">support for consuming init properties</target>
+        <target state="translated">supporto per l'utilizzo delle proprietà init</target>
         <note />
       </trans-unit>
       <trans-unit id="featureInterfacesWithAbstractStaticMembers">
         <source>static abstract interface members</source>
-        <target state="new">static abstract interface members</target>
+        <target state="translated">membri dell'interfaccia astratta statica</target>
         <note />
       </trans-unit>
       <trans-unit id="featureInterfacesWithMultipleGenericInstantiation">
@@ -229,7 +284,7 @@
       </trans-unit>
       <trans-unit id="featureLowercaseDUWhenRequireQualifiedAccess">
         <source>Allow lowercase DU when RequireQualifiedAccess attribute</source>
-        <target state="new">Allow lowercase DU when RequireQualifiedAccess attribute</target>
+        <target state="translated">Consentire l’unione discriminata minuscola quando l'attributo RequireQualifiedAccess</target>
         <note />
       </trans-unit>
       <trans-unit id="featureMLCompatRevisions">
@@ -239,7 +294,7 @@
       </trans-unit>
       <trans-unit id="featureMatchNotAllowedForUnionCaseWithNoData">
         <source>Pattern match discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern match discard is not allowed for union case that takes no data.</target>
+        <target state="translated">L'eliminazione della corrispondenza dei criteri non è consentita per case di unione che non accetta dati.</target>
         <note />
       </trans-unit>
       <trans-unit id="featureNameOf">
@@ -299,7 +354,7 @@
       </trans-unit>
       <trans-unit id="featureRequiredProperties">
         <source>support for required properties</source>
-        <target state="new">support for required properties</target>
+        <target state="translated">supporto per le proprietà obbligatorie</target>
         <note />
       </trans-unit>
       <trans-unit id="featureResumableStateMachines">
@@ -309,7 +364,7 @@
       </trans-unit>
       <trans-unit id="featureSelfTypeConstraints">
         <source>self type constraints</source>
-        <target state="new">self type constraints</target>
+        <target state="translated">vincoli di tipo automatico</target>
         <note />
       </trans-unit>
       <trans-unit id="featureSingleUnderscorePattern">
@@ -327,6 +382,11 @@
         <target state="translated">rappresentazione struct per criteri attivi</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureWarningWhenInliningMethodImplNoInlineMarkedFunction">
+        <source>Raises warnings when 'let inline ... =' is used together with [&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;] attribute. Function is not getting inlined.</source>
+        <target state="translated">Genera avvisi quando 'let inline ... =' viene usato insieme all'attributo [&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;]. La funzione non viene resa inline.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureWildCardInForLoop">
         <source>wild card in for loop</source>
         <target state="translated">carattere jolly nel ciclo for</target>
@@ -339,7 +399,7 @@
       </trans-unit>
       <trans-unit id="followingPatternMatchClauseHasWrongTypeTuple">
         <source>All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Tutti i rami di un'espressione di corrispondenza criterio devono restituire valori convertibili in modo implicito nel tipo del primo ramo, che è una tupla di lunghezza {0} di tipo\n    {1}     \nQuesto ramo restituisce una tupla di lunghezza {2} di tipo\n    {3} \n</target>
         <note />
       </trans-unit>
       <trans-unit id="forFormatInvalidForInterpolated">
@@ -364,7 +424,7 @@
       </trans-unit>
       <trans-unit id="forPercentAInReflectionFreeCode">
         <source>The '%A' format specifier may not be used in an assembly being compiled with option '--reflectionfree'. This construct implicitly uses reflection.</source>
-        <target state="new">The '%A' format specifier may not be used in an assembly being compiled with option '--reflectionfree'. This construct implicitly uses reflection.</target>
+        <target state="translated">L'identificatore di formato '%A' non può essere utilizzato in un assembly compilato con l'opzione '--reflectionfree'. Questo costrutto usa in modo implicito reflection.</target>
         <note />
       </trans-unit>
       <trans-unit id="formatDashItem">
@@ -384,7 +444,7 @@
       </trans-unit>
       <trans-unit id="ifExpressionTuple">
         <source>The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">L'espressione 'if' deve restituire una tupla di lunghezza {0} di tipo\n    {1} \nper soddisfare i requisiti del tipo di contesto. Restituisce attualmente una tupla di lunghezza {2} di tipo\n    {3} \n</target>
         <note />
       </trans-unit>
       <trans-unit id="ilxGenUnknownDebugPoint">
@@ -409,7 +469,7 @@
       </trans-unit>
       <trans-unit id="keywordDescriptionAnd">
         <source>Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</source>
-        <target state="new">Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</target>
+        <target state="translated">Usata in binding ricorsivi reciproci, dichiarazioni di proprietà e con più vincoli su parametri generici.</target>
         <note />
       </trans-unit>
       <trans-unit id="keywordDescriptionConst">
@@ -419,7 +479,7 @@
       </trans-unit>
       <trans-unit id="keywordDescriptionTypeTest">
         <source>Used to check if an object is of the given type in a pattern or binding.</source>
-        <target state="new">Used to check if an object is of the given type in a pattern or binding.</target>
+        <target state="translated">Usato per controllare se un oggetto è del tipo specificato in un criterio o in un'associazione.</target>
         <note />
       </trans-unit>
       <trans-unit id="lexByteStringMayNotBeInterpolated">
@@ -449,12 +509,12 @@
       </trans-unit>
       <trans-unit id="listElementHasWrongTypeTuple">
         <source>All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Tutti gli elementi di un elenco devono essere convertibili in modo implicito nel tipo del primo elemento, che qui è una tupla di lunghezza {0} di tipo\n {1}    \nQuesto elemento è una tupla di lunghezza {2} di tipo\n    {3} \n</target>
         <note />
       </trans-unit>
       <trans-unit id="matchNotAllowedForUnionCaseWithNoData">
         <source>Pattern discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern discard is not allowed for union case that takes no data.</target>
+        <target state="translated">L'eliminazione del criterio non è consentita per case di unione che non accetta dati.</target>
         <note />
       </trans-unit>
       <trans-unit id="mlCompatError">
@@ -529,17 +589,17 @@
       </trans-unit>
       <trans-unit id="optsCompressMetadata">
         <source>Compress interface and optimization data files</source>
-        <target state="new">Compress interface and optimization data files</target>
+        <target state="translated">File di dati di compressione dell’interfaccia e ottimizzazione</target>
         <note />
       </trans-unit>
       <trans-unit id="optsGetLangVersions">
         <source>Display the allowed values for language version.</source>
-        <target state="new">Display the allowed values for language version.</target>
+        <target state="translated">Visualizzare i valori consentiti per la versione della lingua.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsInvalidRefAssembly">
         <source>Invalid use of emitting a reference assembly, do not use '--standalone or --staticlink' with '--refonly or --refout'.</source>
-        <target state="needs-review-translation">Utilizzo non valido della creazione di un assembly di riferimento. Non usare insieme '--staticlink' o '--refonly' e '--refout'.</target>
+        <target state="translated">Utilizzo non valido della creazione di un assembly di riferimento. Non usare insieme '--standalone o --staticlink' con '--refonly o --refout'..</target>
         <note />
       </trans-unit>
       <trans-unit id="optsInvalidRefOut">
@@ -549,12 +609,12 @@
       </trans-unit>
       <trans-unit id="optsOptimizationData">
         <source>Specify included optimization information, the default is file. Important for distributed libraries.</source>
-        <target state="new">Specify included optimization information, the default is file. Important for distributed libraries.</target>
+        <target state="translated">Specificare le informazioni di ottimizzazione incluse. Il valore predefinito è file. Important per le librerie distribuite.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsPdbMatchesOutputFileName">
         <source>The pdb output file name cannot match the build output filename use --pdb:filename.pdb</source>
-        <target state="new">The pdb output file name cannot match the build output filename use --pdb:filename.pdb</target>
+        <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="optsRefOnly">
@@ -569,17 +629,17 @@
       </trans-unit>
       <trans-unit id="optsReflectionFree">
         <source>Disable implicit generation of constructs using reflection</source>
-        <target state="new">Disable implicit generation of constructs using reflection</target>
+        <target state="translated">Disabilitare la generazione implicita di costrutti usando reflection</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSetLangVersion">
         <source>Specify language version such as 'latest' or 'preview'.</source>
-        <target state="new">Specify language version such as 'latest' or 'preview'.</target>
+        <target state="translated">Specificare la versione della lingua, ad esempio 'latest' o 'preview'.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSignatureData">
         <source>Include F# interface information, the default is file. Essential for distributing libraries.</source>
-        <target state="new">Include F# interface information, the default is file. Essential for distributing libraries.</target>
+        <target state="translated">Includere le informazioni sull'interfaccia F#. Il valore predefinito è file. Essential per la distribuzione di librerie.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSupportedLangVersions">
@@ -589,12 +649,12 @@
       </trans-unit>
       <trans-unit id="optsUnknownOptimizationData">
         <source>Invalid value '{0}' for --optimizationdata, valid value are: none, file, compress.</source>
-        <target state="new">Invalid value '{0}' for --optimizationdata, valid value are: none, file, compress.</target>
+        <target state="translated">Valore non valido '{0}' per --optimizationdata. Valori validi sono: none, file, compress.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsUnknownSignatureData">
         <source>Invalid value '{0}' for --interfacedata, valid value are: none, file, compress.</source>
-        <target state="new">Invalid value '{0}' for --interfacedata, valid value are: none, file, compress.</target>
+        <target state="translated">Valore non valido '{0}' per --interfacedata. Valori validi sono: none, file, compress.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsUnrecognizedLanguageVersion">
@@ -649,7 +709,7 @@
       </trans-unit>
       <trans-unit id="parsExpectedPatternAfterToken">
         <source>Expected a pattern after this point</source>
-        <target state="new">Expected a pattern after this point</target>
+        <target state="translated">Previsto un criterio dopo questa posizione</target>
         <note />
       </trans-unit>
       <trans-unit id="parsExpectingExpressionInTuple">
@@ -659,17 +719,17 @@
       </trans-unit>
       <trans-unit id="parsExpectingPatternInTuple">
         <source>Expecting pattern</source>
-        <target state="new">Expecting pattern</target>
+        <target state="translated">Criterio previsto</target>
         <note />
       </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
         <source>Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</source>
-        <target state="new">Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</target>
+        <target state="translated">Valore letterale carattere incompleto (ad esempio: 'Q') o chiamata di tipo qualificato (ad esempio: 'T.Name)</target>
         <note />
       </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr2">
         <source>Incomplete operator expression (example a^b) or qualified type invocation (example: ^T.Name)</source>
-        <target state="new">Incomplete operator expression (example a^b) or qualified type invocation (example: ^T.Name)</target>
+        <target state="translated">Espressione operatore incompleta (ad esempio a^b) o chiamata di tipo qualificato (ad esempio: ^T.Name)</target>
         <note />
       </trans-unit>
       <trans-unit id="parsNewExprMemberAccess">
@@ -849,7 +909,7 @@
       </trans-unit>
       <trans-unit id="tcInitOnlyPropertyCannotBeSet1">
         <source>Init-only property '{0}' cannot be set outside the initialization code. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</source>
-        <target state="new">Init-only property '{0}' cannot be set outside the initialization code. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
+        <target state="translated">La proprietà init-only '{0}' non può essere impostata al di fuori del codice di inizializzazione. Vedere https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
         <note />
       </trans-unit>
       <trans-unit id="tcInlineIfLambdaUsedOnNonInlineFunctionOrMethod">
@@ -879,7 +939,7 @@
       </trans-unit>
       <trans-unit id="tcInvalidSelfConstraint">
         <source>Invalid constraint. Valid constraint forms include \"'T :&gt; ISomeInterface\" for interface constraints and \"SomeConstrainingType&lt;'T&gt;\" for self-constraints. See https://aka.ms/fsharp-type-constraints.</source>
-        <target state="new">Invalid constraint. Valid constraint forms include \"'T :&gt; ISomeInterface\" for interface constraints and \"SomeConstrainingType&lt;'T&gt;\" for self-constraints. See https://aka.ms/fsharp-type-constraints.</target>
+        <target state="translated">Vincolo non valido. Forme di vincoli validi includono \"'T :&gt; ISomeInterface\" per i vincoli di interfaccia e \"SomeConstrainingType&lt;'T&gt;\" per i vincoli automatici. Vedere https://aka.ms/fsharp-type-constraints.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcInvalidStructReturn">
@@ -924,7 +984,7 @@
       </trans-unit>
       <trans-unit id="tcMissingRequiredMembers">
         <source>The following required properties have to be initalized:{0}</source>
-        <target state="new">The following required properties have to be initalized:{0}</target>
+        <target state="translated">È necessario inizializzare le proprietà obbligatorie seguenti:{0}</target>
         <note />
       </trans-unit>
       <trans-unit id="tcNoEagerConstraintApplicationAttribute">
@@ -1009,7 +1069,7 @@
       </trans-unit>
       <trans-unit id="tcSetterForInitOnlyPropertyCannotBeCalled1">
         <source>Cannot call '{0}' - a setter for init-only property, please use object initialization instead. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</source>
-        <target state="new">Cannot call '{0}' - a setter for init-only property, please use object initialization instead. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
+        <target state="translated">Non è possibile chiamare '{0}', un setter per la proprietà init-only. Usare invece l'inizializzazione dell'oggetto. Vedere https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
         <note />
       </trans-unit>
       <trans-unit id="tcSubsumptionImplicitConversionUsed">
@@ -1019,32 +1079,32 @@
       </trans-unit>
       <trans-unit id="tcSynTypeOrInvalidInDeclaration">
         <source>SynType.Or is not permitted in this declaration</source>
-        <target state="new">SynType.Or is not permitted in this declaration</target>
+        <target state="translated">SynType.Or non è consentito in questa dichiarazione</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitHasMultipleSupportTypes">
         <source>The trait '{0}' invoked by this call has multiple support types. This invocation syntax is not permitted for such traits. See https://aka.ms/fsharp-srtp for guidance.</source>
-        <target state="new">The trait '{0}' invoked by this call has multiple support types. This invocation syntax is not permitted for such traits. See https://aka.ms/fsharp-srtp for guidance.</target>
+        <target state="translated">Il tratto '{0}' chiamato da questa chiamata ha più tipi di supporto. Questa sintassi di chiamata non è consentita per tali tratti. Per indicazioni, vedere https://aka.ms/fsharp-srtp.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitInvocationShouldUseTick">
         <source>Invocation of a static constraint should use \"'T.Ident\" and not \"^T.Ident\", even for statically resolved type parameters.</source>
-        <target state="new">Invocation of a static constraint should use \"'T.Ident\" and not \"^T.Ident\", even for statically resolved type parameters.</target>
+        <target state="translated">La chiamata di un vincolo statico deve usare \"'T.Ident\" e non \"^T.Ident\", anche per i parametri di tipo risolti in modo statico.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitIsNotStatic">
         <source>Trait '{0}' is not static</source>
-        <target state="new">Trait '{0}' is not static</target>
+        <target state="translated">Il tratto '{0}' non è statico</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitIsStatic">
         <source>Trait '{0}' is static</source>
-        <target state="new">Trait '{0}' is static</target>
+        <target state="translated">Il tratto '{0}' è statico</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitMayNotUseComplexThings">
         <source>A trait may not specify optional, in, out, ParamArray, CallerInfo or Quote arguments</source>
-        <target state="new">A trait may not specify optional, in, out, ParamArray, CallerInfo or Quote arguments</target>
+        <target state="translated">Un tratto non può specificare argomenti optional, in, out, ParamArray, CallerInfo o Quote</target>
         <note />
       </trans-unit>
       <trans-unit id="tcUnableToParseInterpolatedString">
@@ -1054,12 +1114,12 @@
       </trans-unit>
       <trans-unit id="tcUsingInterfaceWithStaticAbstractMethodAsType">
         <source>'{0}' is normally used as a type constraint in generic code, e.g. \"'T when ISomeInterface&lt;'T&gt;\" or \"let f (x: #ISomeInterface&lt;_&gt;)\". See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3536\"' or '--nowarn:3536'.</source>
-        <target state="new">'{0}' is normally used as a type constraint in generic code, e.g. \"'T when ISomeInterface&lt;'T&gt;\" or \"let f (x: #ISomeInterface&lt;_&gt;)\". See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3536\"' or '--nowarn:3536'.</target>
+        <target state="translated">'{0}' viene in genere usato come vincolo di tipo nel codice generico, ad esempio \"'T when ISomeInterface&lt;'T&gt;\" o \"let f (x: #ISomeInterface&lt;_&gt;)\". Per indicazioni, vedere https://aka.ms/fsharp-iwsams. È possibile disabilitare questo avviso usando '#nowarn \"3536\"' o '--nowarn:3536'.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcUsingInterfacesWithStaticAbstractMethods">
         <source>Declaring \"interfaces with static abstract methods\" is an advanced feature. See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3535\"' or '--nowarn:3535'.</source>
-        <target state="new">Declaring \"interfaces with static abstract methods\" is an advanced feature. See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3535\"' or '--nowarn:3535'.</target>
+        <target state="translated">La dichiarazione di \"interfaces with static abstract methods\" è una funzionalità avanzata. Per indicazioni, vedere https://aka.ms/fsharp-iwsams. È possibile disabilitare questo avviso usando '#nowarn \"3535\"' o '--nowarn:3535'.</target>
         <note />
       </trans-unit>
       <trans-unit id="typrelInterfaceMemberNoMostSpecificImplementation">
@@ -3849,7 +3909,7 @@
       </trans-unit>
       <trans-unit id="tcUnionCaseExpectsTupledArguments">
         <source>This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</source>
-        <target state="new">This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</target>
+        <target state="translated">Questo case di unione prevede argomenti {0} in forma tupla, ma è stato specificato {1}. Gli argomenti di campo mancanti possono essere uno dei seguenti: {2}</target>
         <note />
       </trans-unit>
       <trans-unit id="tcFieldIsNotStatic">
@@ -7529,7 +7589,7 @@
       </trans-unit>
       <trans-unit id="tcStructUnionMultiCaseDistinctFields">
         <source>If a multicase union type is a struct, then all union cases must have unique names. For example: 'type A = B of b: int | C of c: int'.</source>
-        <target state="needs-review-translation">Se un tipo di unione contiene più di un case ed è una struttura, è necessario assegnare nomi univoci a tutti i campi all'interno del tipo di unione.</target>
+        <target state="translated">Se un tipo di unione multicase è uno struct, tutti i case di unione devono avere nomi univoci. Ad esempio: 'tipo A = B di b: int | C di c: int'.</target>
         <note />
       </trans-unit>
       <trans-unit id="CallerMemberNameIsOverriden">
diff --git a/src/Compiler/xlf/FSComp.txt.ja.xlf b/src/Compiler/xlf/FSComp.txt.ja.xlf
index 3d5ed3c9dae..b064cc8d2b7 100644
--- a/src/Compiler/xlf/FSComp.txt.ja.xlf
+++ b/src/Compiler/xlf/FSComp.txt.ja.xlf
@@ -4,7 +4,12 @@
     <body>
       <trans-unit id="arrayElementHasWrongTypeTuple">
         <source>All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">配列のすべての要素は、最初の要素の型に暗黙的に変換できる必要があります。これは、型の長さ {0} のタプルです\n    {1}    \nこの要素は、型の長さ {2} のタプルです\n    {3}    \n</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="buildDuplicateFile">
+        <source>The source file '{0}' (at position {1}/{2}) already appeared in the compilation list (at position {3}/{4}). Please verify that it is included only once in the project file.</source>
+        <target state="translated">ソース ファイル '{0}' (位置 {1}/{2}) は、コンパイル リスト (位置 {3}/{4}) に既に存在します。プロジェクト ファイルに 1 回だけ含まれていることを確認してください。</target>
         <note />
       </trans-unit>
       <trans-unit id="buildInvalidSourceFileExtensionML">
@@ -17,9 +22,29 @@
         <target state="translated">'{0}' のファイル拡張子は認識されません。ソース ファイルの拡張子は .fs、.fsi、.fsx、または .fsscript にする必要があります。</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkAbstractMembersDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkAdditionalConstructorOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Additional constructor is not allowed.</source>
+        <target state="translated">型が [&lt;Sealed&gt;] と [&lt;AbstractClass&gt;] の両方の属性を使用する場合、それは静的であることを意味します。追加のコンストラクターは許可されていません。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkConstructorWithArgumentsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Constructor with arguments is not allowed.</source>
+        <target state="translated">型が [&lt;Sealed&gt;] と [&lt;AbstractClass&gt;] の両方の属性を使用する場合、それは静的であることを意味します。引数を持つコンストラクターは許可されていません。</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkDuplicatedMethodParameter">
         <source>Duplicate parameter. The parameter '{0}' has been used more that once in this method.</source>
-        <target state="new">Duplicate parameter. The parameter '{0}' has been used more that once in this method.</target>
+        <target state="translated">パラメーターが重複しています。パラメーター '{0}' は、このメソッドで 1 回以上使用されています。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkExplicitFieldsDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</target>
         <note />
       </trans-unit>
       <trans-unit id="chkFeatureNotLanguageSupported">
@@ -37,6 +62,11 @@
         <target state="translated">機能 '{0}' を使用するには、言語バージョン {1} 以上の F# ライブラリが必要です。</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkImplementingInterfacesOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkInfoRefcellAssign">
         <source>The use of ':=' from the F# library is deprecated. See https://aka.ms/fsharp-refcell-ops. For example, please change 'cell := expr' to 'cell.Value &lt;- expr'.</source>
         <target state="translated">F# ライブラリからの ':=' の使用は非推奨です。https://aka.ms/fsharp-refcell-ops を参照してください。たとえば、'cell : = expr' を 'cell.Value &lt;- expr' に変更してください。</target>
@@ -57,6 +87,16 @@
         <target state="translated">F# ライブラリからの 'incr' の使用は非推奨です。https://aka.ms/fsharp-refcell-ops を参照してください。たとえば、'incr cell' を 'cell.Value &lt;- cell.Value +1' に変更してください。</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkInstanceLetBindingOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkInstanceMemberOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance members are not allowed.</source>
+        <target state="translated">型が [&lt;Sealed&gt;] と [&lt;AbstractClass&gt;] の両方の属性を使用する場合、それは静的であることを意味します。インスタンス メンバーは許可されません。</target>
+        <note />
+      </trans-unit>
       <trans-unit id="containerDeprecated">
         <source>The 'AssemblyKeyNameAttribute' has been deprecated. Use 'AssemblyKeyFileAttribute' instead.</source>
         <target state="translated">'AssemblyKeyNameAttribute' は非推奨になりました。代わりに 'AssemblyKeyFileAttribute' を使用してください。</target>
@@ -114,7 +154,7 @@
       </trans-unit>
       <trans-unit id="elseBranchHasWrongTypeTuple">
         <source>All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">'if' 式のすべての分岐は、最初の分岐の型に暗黙的に変換できる値を返す必要があります。これは、型の長さ {0} のタプルです\n    {1}    \nこの分岐は、型の長さ {2} のタプルを返します\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="etProviderHasDesignerAssemblyDependency">
@@ -142,6 +182,11 @@
         <target state="translated">適用できる計算式</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureArithmeticInLiterals">
+        <source>Allow arithmetic and logical operations in literals</source>
+        <target state="translated">リテラルで算術演算と論理演算を許可する</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureAttributesToRightOfModuleKeyword">
         <source>attributes to the right of the 'module' keyword</source>
         <target state="translated">'module' キーワードの右側の属性</target>
@@ -154,7 +199,7 @@
       </trans-unit>
       <trans-unit id="featureCSharpExtensionAttributeNotRequired">
         <source>Allow implicit Extension attribute on declaring types, modules</source>
-        <target state="new">Allow implicit Extension attribute on declaring types, modules</target>
+        <target state="translated">型、モジュールの宣言で暗黙的な拡張属性を許可する</target>
         <note />
       </trans-unit>
       <trans-unit id="featureDefaultInterfaceMemberConsumption">
@@ -179,7 +224,7 @@
       </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
-        <target state="new">Raises errors for non-virtual members overrides</target>
+        <target state="translated">仮想メンバー以外のオーバーライドに対してエラーを発生させます</target>
         <note />
       </trans-unit>
       <trans-unit id="featureErrorOnDeprecatedRequireQualifiedAccess">
@@ -187,6 +232,16 @@
         <target state="translated">RequireQualifiedAccess 属性を持つコンストラクトの非推奨アクセスでエラーが発生しました</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureErrorReportingOnStaticClasses">
+        <source>Error reporting on static classes</source>
+        <target state="translated">静的クラスに関するエラー報告</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="featureEscapeBracesInFormattableString">
+        <source>Escapes curly braces before calling FormattableStringFactory.Create when interpolated string literal is typed as FormattableString</source>
+        <target state="translated">挿入文字列リテラルが FormattableString として型指定されている場合は、FormattableStringFactory.Create を呼び出す前に波かっこをエスケープします</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureExpandedMeasurables">
         <source>more types support units of measure</source>
         <target state="translated">単位をサポートするその他の型</target>
@@ -239,7 +294,7 @@
       </trans-unit>
       <trans-unit id="featureMatchNotAllowedForUnionCaseWithNoData">
         <source>Pattern match discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern match discard is not allowed for union case that takes no data.</target>
+        <target state="translated">データを受け取らない共用体ケースでは、パターン一致の破棄は許可されません。</target>
         <note />
       </trans-unit>
       <trans-unit id="featureNameOf">
@@ -327,6 +382,11 @@
         <target state="translated">アクティブなパターンの構造体表現</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureWarningWhenInliningMethodImplNoInlineMarkedFunction">
+        <source>Raises warnings when 'let inline ... =' is used together with [&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;] attribute. Function is not getting inlined.</source>
+        <target state="translated">'let inline ... =' が [&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;] 属性と一緒に使用されるときに警告を生成します。関数はインライン化されていません。</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureWildCardInForLoop">
         <source>wild card in for loop</source>
         <target state="translated">for ループのワイルド カード</target>
@@ -339,7 +399,7 @@
       </trans-unit>
       <trans-unit id="followingPatternMatchClauseHasWrongTypeTuple">
         <source>All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">パターン一致のすべての分岐は、最初の分岐の型に暗黙的に変換できる値を返す必要があります。これは、型の長さ {0} のタプルです\n    {1}    \nこの分岐は、型の長さ {2} のタプルを返します\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="forFormatInvalidForInterpolated">
@@ -384,7 +444,7 @@
       </trans-unit>
       <trans-unit id="ifExpressionTuple">
         <source>The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">'if' 式は、コンテキスト型の要件を満たすために、\n    {1}    \n 型の長さの {0} のタプルを返す必要があります。現在、型の {2} 長さのタプルを返します\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="ilxGenUnknownDebugPoint">
@@ -409,7 +469,7 @@
       </trans-unit>
       <trans-unit id="keywordDescriptionAnd">
         <source>Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</source>
-        <target state="new">Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</target>
+        <target state="translated">相互に再帰的なバインディング、プロパティの宣言、およびジェネリック パラメーターの複数の制約に使用します。</target>
         <note />
       </trans-unit>
       <trans-unit id="keywordDescriptionConst">
@@ -449,12 +509,12 @@
       </trans-unit>
       <trans-unit id="listElementHasWrongTypeTuple">
         <source>All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">リストのすべての要素は、最初の要素の型に暗黙的に変換できる必要があります。これは、型の長さ {0} のタプルです\n    {1}    \nこの要素は、型の長さ {2} のタプルです\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="matchNotAllowedForUnionCaseWithNoData">
         <source>Pattern discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern discard is not allowed for union case that takes no data.</target>
+        <target state="translated">データを受け取らない共用体ケースでは、パターンの破棄は許可されません。</target>
         <note />
       </trans-unit>
       <trans-unit id="mlCompatError">
@@ -539,7 +599,7 @@
       </trans-unit>
       <trans-unit id="optsInvalidRefAssembly">
         <source>Invalid use of emitting a reference assembly, do not use '--standalone or --staticlink' with '--refonly or --refout'.</source>
-        <target state="needs-review-translation">参照アセンブリの生成の使用が無効です。'--staticlink'、または '--refonly' と '--refout' を同時に使用しないでください。</target>
+        <target state="translated">参照アセンブリの出力の使用が無効です。'--standalone または --staticlink' を '--relabelly または --refout' と共に使用しないでください。</target>
         <note />
       </trans-unit>
       <trans-unit id="optsInvalidRefOut">
@@ -649,7 +709,7 @@
       </trans-unit>
       <trans-unit id="parsExpectedPatternAfterToken">
         <source>Expected a pattern after this point</source>
-        <target state="new">Expected a pattern after this point</target>
+        <target state="translated">このポイントの後にパターンが必要です</target>
         <note />
       </trans-unit>
       <trans-unit id="parsExpectingExpressionInTuple">
@@ -659,7 +719,7 @@
       </trans-unit>
       <trans-unit id="parsExpectingPatternInTuple">
         <source>Expecting pattern</source>
-        <target state="new">Expecting pattern</target>
+        <target state="translated">必要なパターン</target>
         <note />
       </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
@@ -1019,7 +1079,7 @@
       </trans-unit>
       <trans-unit id="tcSynTypeOrInvalidInDeclaration">
         <source>SynType.Or is not permitted in this declaration</source>
-        <target state="new">SynType.Or is not permitted in this declaration</target>
+        <target state="translated">SynType.Or はこの宣言では許可されていません</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitHasMultipleSupportTypes">
@@ -3849,7 +3909,7 @@
       </trans-unit>
       <trans-unit id="tcUnionCaseExpectsTupledArguments">
         <source>This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</source>
-        <target state="new">This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</target>
+        <target state="translated">この共用体の場合は、タプル フォームに {0} 個の引数が必要ですが、{1} 個しか渡されませんでした。不足しているフィールド引数は次のいずれかです:{2}</target>
         <note />
       </trans-unit>
       <trans-unit id="tcFieldIsNotStatic">
@@ -7529,7 +7589,7 @@
       </trans-unit>
       <trans-unit id="tcStructUnionMultiCaseDistinctFields">
         <source>If a multicase union type is a struct, then all union cases must have unique names. For example: 'type A = B of b: int | C of c: int'.</source>
-        <target state="needs-review-translation">共用体型が複数のケースを持つ 1 つの構造体である場合は、共用体型内のすべてのフィールドに一意の名前を付ける必要があります。</target>
+        <target state="translated">マルチケース共用体の型が構造体の場合は、すべての共用体ケースに一意の名前を付ける必要があります。例: 'type A = B of b: int | c の C: int'。</target>
         <note />
       </trans-unit>
       <trans-unit id="CallerMemberNameIsOverriden">
diff --git a/src/Compiler/xlf/FSComp.txt.ko.xlf b/src/Compiler/xlf/FSComp.txt.ko.xlf
index 40bbf8e988a..41fced8e047 100644
--- a/src/Compiler/xlf/FSComp.txt.ko.xlf
+++ b/src/Compiler/xlf/FSComp.txt.ko.xlf
@@ -4,7 +4,12 @@
     <body>
       <trans-unit id="arrayElementHasWrongTypeTuple">
         <source>All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">배열의 모든 요소는 첫 번째 요소의 형식으로 암시적으로 변환할 수 있어야 합니다. 여기서는 형식이 \n    {1}이고 길이가 {0}인 튜플입니다.    \n이 요소는 형식이 \n    {3}이고 길이가 {2}인 튜플입니다.    \n</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="buildDuplicateFile">
+        <source>The source file '{0}' (at position {1}/{2}) already appeared in the compilation list (at position {3}/{4}). Please verify that it is included only once in the project file.</source>
+        <target state="translated">'{0}' 원본 파일(위치: {1}/{2})이 이미 컴파일 목록에 있습니다(위치{3}/{4}). 프로젝트 파일에 한 번만 포함되어 있는지 확인하세요.</target>
         <note />
       </trans-unit>
       <trans-unit id="buildInvalidSourceFileExtensionML">
@@ -17,9 +22,29 @@
         <target state="translated">'{0}'의 파일 확장명을 인식할 수 없습니다. 원본 파일의 확장명은 .fs, .fsi, .fsx 또는 .fsscript여야 합니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkAbstractMembersDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkAdditionalConstructorOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Additional constructor is not allowed.</source>
+        <target state="translated">형식이 [&lt;Sealed&gt;] 및 [&lt;AbstractClass&gt;] 특성을 모두 사용하는 경우 정적임을 의미합니다. 추가 생성자는 허용되지 않습니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkConstructorWithArgumentsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Constructor with arguments is not allowed.</source>
+        <target state="translated">형식이 [&lt;Sealed&gt;] 및 [&lt;AbstractClass&gt;] 특성을 모두 사용하는 경우 정적임을 의미합니다. 인수가 있는 생성자는 허용되지 않습니다.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkDuplicatedMethodParameter">
         <source>Duplicate parameter. The parameter '{0}' has been used more that once in this method.</source>
-        <target state="new">Duplicate parameter. The parameter '{0}' has been used more that once in this method.</target>
+        <target state="translated">매개 변수가 중복되었습니다. 이 메소드에서 매개 변수 '{0}'이(가) 두 번 이상 사용되었습니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkExplicitFieldsDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</target>
         <note />
       </trans-unit>
       <trans-unit id="chkFeatureNotLanguageSupported">
@@ -37,6 +62,11 @@
         <target state="translated">언어 버전 {1} 이상에서 '{0}' 기능을 사용하려면 F# 라이브러리가 필요합니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkImplementingInterfacesOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkInfoRefcellAssign">
         <source>The use of ':=' from the F# library is deprecated. See https://aka.ms/fsharp-refcell-ops. For example, please change 'cell := expr' to 'cell.Value &lt;- expr'.</source>
         <target state="translated">F# 라이브러리의 ':=' 사용은 더 이상 사용되지 않습니다. https://aka.ms/fsharp-refcell-ops를 참조하세요. 예를 들어 'cell := expr'을 'cell.Value &lt;- expr'로 변경하세요.</target>
@@ -57,6 +87,16 @@
         <target state="translated">F# 라이브러리의 'incr' 사용은 더 이상 사용되지 않습니다. https://aka.ms/fsharp-refcell-ops를 참조하세요. 예를 들어 'incr cell'을 'cell.Value &lt;- cell.Value + 1'로 변경하세요.</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkInstanceLetBindingOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkInstanceMemberOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance members are not allowed.</source>
+        <target state="translated">형식이 [&lt;Sealed&gt;] 및 [&lt;AbstractClass&gt;] 특성을 모두 사용하는 경우 정적임을 의미합니다. 인스턴스 멤버는 허용되지 않습니다.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="containerDeprecated">
         <source>The 'AssemblyKeyNameAttribute' has been deprecated. Use 'AssemblyKeyFileAttribute' instead.</source>
         <target state="translated">'AssemblyKeyNameAttribute'는 사용되지 않습니다. 대신 'AssemblyKeyFileAttribute'를 사용하세요.</target>
@@ -114,7 +154,7 @@
       </trans-unit>
       <trans-unit id="elseBranchHasWrongTypeTuple">
         <source>All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">'if' 식의 모든 분기는 첫 번째 분기의 유형으로 암시적으로 변환 가능한 값을 반환해야 합니다. 여기서는 형식이 \n    {1}이고 길이가 {0}인 튜플입니다.    \n이 분기는 형식이 \n    {3}이고 길이가 {2}인 튜플을 반환합니다.    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="etProviderHasDesignerAssemblyDependency">
@@ -142,6 +182,11 @@
         <target state="translated">적용 가능한 계산 식</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureArithmeticInLiterals">
+        <source>Allow arithmetic and logical operations in literals</source>
+        <target state="translated">리터럴에서 산술 및 논리 연산 허용</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureAttributesToRightOfModuleKeyword">
         <source>attributes to the right of the 'module' keyword</source>
         <target state="translated">'module' 키워드 오른쪽에 있는 특성</target>
@@ -154,7 +199,7 @@
       </trans-unit>
       <trans-unit id="featureCSharpExtensionAttributeNotRequired">
         <source>Allow implicit Extension attribute on declaring types, modules</source>
-        <target state="new">Allow implicit Extension attribute on declaring types, modules</target>
+        <target state="translated">유형, 모듈 선언에 암시적 확장 속성 허용</target>
         <note />
       </trans-unit>
       <trans-unit id="featureDefaultInterfaceMemberConsumption">
@@ -179,7 +224,7 @@
       </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
-        <target state="new">Raises errors for non-virtual members overrides</target>
+        <target state="translated">비가상 멤버 재정의에 대한 오류 발생</target>
         <note />
       </trans-unit>
       <trans-unit id="featureErrorOnDeprecatedRequireQualifiedAccess">
@@ -187,6 +232,16 @@
         <target state="translated">RequireQualifiedAccess 특성을 사용하여 사용되지 않는 구문 액세스에 대한 오류 제공</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureErrorReportingOnStaticClasses">
+        <source>Error reporting on static classes</source>
+        <target state="translated">정적 클래스에 대한 오류 보고</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="featureEscapeBracesInFormattableString">
+        <source>Escapes curly braces before calling FormattableStringFactory.Create when interpolated string literal is typed as FormattableString</source>
+        <target state="translated">보간된 문자열 리터럴이 FormattableString으로 형식화된 경우 FormattableStringFactory.Create를 호출하기 전에 중괄호를 이스케이프합니다.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureExpandedMeasurables">
         <source>more types support units of measure</source>
         <target state="translated">더 많은 형식이 측정 단위를 지원함</target>
@@ -214,12 +269,12 @@
       </trans-unit>
       <trans-unit id="featureInitProperties">
         <source>support for consuming init properties</source>
-        <target state="new">support for consuming init properties</target>
+        <target state="translated">init 속성 사용 지원</target>
         <note />
       </trans-unit>
       <trans-unit id="featureInterfacesWithAbstractStaticMembers">
         <source>static abstract interface members</source>
-        <target state="new">static abstract interface members</target>
+        <target state="translated">고정적인 추상 인터페이스 멤버</target>
         <note />
       </trans-unit>
       <trans-unit id="featureInterfacesWithMultipleGenericInstantiation">
@@ -229,7 +284,7 @@
       </trans-unit>
       <trans-unit id="featureLowercaseDUWhenRequireQualifiedAccess">
         <source>Allow lowercase DU when RequireQualifiedAccess attribute</source>
-        <target state="new">Allow lowercase DU when RequireQualifiedAccess attribute</target>
+        <target state="translated">RequireQualifiedAccess 특성이 있는 경우 소문자 DU 허용</target>
         <note />
       </trans-unit>
       <trans-unit id="featureMLCompatRevisions">
@@ -239,7 +294,7 @@
       </trans-unit>
       <trans-unit id="featureMatchNotAllowedForUnionCaseWithNoData">
         <source>Pattern match discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern match discard is not allowed for union case that takes no data.</target>
+        <target state="translated">데이터를 사용하지 않는 공용 구조체 사례에는 패턴 일치 삭제가 허용되지 않습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="featureNameOf">
@@ -299,7 +354,7 @@
       </trans-unit>
       <trans-unit id="featureRequiredProperties">
         <source>support for required properties</source>
-        <target state="new">support for required properties</target>
+        <target state="translated">필수 속성 지원</target>
         <note />
       </trans-unit>
       <trans-unit id="featureResumableStateMachines">
@@ -309,7 +364,7 @@
       </trans-unit>
       <trans-unit id="featureSelfTypeConstraints">
         <source>self type constraints</source>
-        <target state="new">self type constraints</target>
+        <target state="translated">자체 형식 제약 조건</target>
         <note />
       </trans-unit>
       <trans-unit id="featureSingleUnderscorePattern">
@@ -327,6 +382,11 @@
         <target state="translated">활성 패턴에 대한 구조체 표현</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureWarningWhenInliningMethodImplNoInlineMarkedFunction">
+        <source>Raises warnings when 'let inline ... =' is used together with [&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;] attribute. Function is not getting inlined.</source>
+        <target state="translated">'let inline ... ='을(를) [&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;] 특성과 함께 사용하는 경우 경고를 발생합니다. 함수가 인라인되지 않습니다.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureWildCardInForLoop">
         <source>wild card in for loop</source>
         <target state="translated">for 루프의 와일드카드</target>
@@ -339,7 +399,7 @@
       </trans-unit>
       <trans-unit id="followingPatternMatchClauseHasWrongTypeTuple">
         <source>All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">패턴 일치 식의 모든 분기는 첫 번째 분기의 유형으로 암시적으로 변환 가능한 값을 반환해야 합니다. 여기서는 형식이 \n    {1}이고 길이가 {0}인 튜플입니다.    \n이 분기는 형식이 \n    {3}이고 길이가 {2}인 튜플을 반환합니다.    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="forFormatInvalidForInterpolated">
@@ -364,7 +424,7 @@
       </trans-unit>
       <trans-unit id="forPercentAInReflectionFreeCode">
         <source>The '%A' format specifier may not be used in an assembly being compiled with option '--reflectionfree'. This construct implicitly uses reflection.</source>
-        <target state="new">The '%A' format specifier may not be used in an assembly being compiled with option '--reflectionfree'. This construct implicitly uses reflection.</target>
+        <target state="translated">'%A' 형식 지정자는 '--reflectionfree' 옵션으로 컴파일되는 어셈블리에서 사용할 수 없습니다. 이 구문은 암시적으로 리플렉션을 사용합니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="formatDashItem">
@@ -384,7 +444,7 @@
       </trans-unit>
       <trans-unit id="ifExpressionTuple">
         <source>The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">'if' 식은 컨텍스트 유형 요구 사항을 충족하기 위해 형식이\n    {1}    \n이고 길이가 {0}인 튜플을 반환해야 합니다. 해당 식은 현재 형식이     {3}이고 길이가\n    {2}인 튜플을 반환합니다.    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="ilxGenUnknownDebugPoint">
@@ -409,7 +469,7 @@
       </trans-unit>
       <trans-unit id="keywordDescriptionAnd">
         <source>Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</source>
-        <target state="new">Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</target>
+        <target state="translated">상호 재귀적 바인딩과 속성 선언에 사용되며 제네릭 매개 변수의 여러 제약 조건과 함께 사용됩니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="keywordDescriptionConst">
@@ -419,7 +479,7 @@
       </trans-unit>
       <trans-unit id="keywordDescriptionTypeTest">
         <source>Used to check if an object is of the given type in a pattern or binding.</source>
-        <target state="new">Used to check if an object is of the given type in a pattern or binding.</target>
+        <target state="translated">개체가 패턴 또는 바인딩에서 지정된 형식인지 확인하는 데 사용됩니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="lexByteStringMayNotBeInterpolated">
@@ -449,12 +509,12 @@
       </trans-unit>
       <trans-unit id="listElementHasWrongTypeTuple">
         <source>All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">목록의 모든 요소는 첫 번째 요소의 형식으로 암시적으로 변환할 수 있어야 합니다. 여기서는 형식이 \n    {1}이고 길이가 {0}인 튜플입니다.    \n이 요소는 형식이 \n    {3}이고 길이가 {2}인 튜플입니다.    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="matchNotAllowedForUnionCaseWithNoData">
         <source>Pattern discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern discard is not allowed for union case that takes no data.</target>
+        <target state="translated">데이터를 사용하지 않는 공용 구조체 사례에는 패턴 삭제가 허용되지 않습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="mlCompatError">
@@ -529,17 +589,17 @@
       </trans-unit>
       <trans-unit id="optsCompressMetadata">
         <source>Compress interface and optimization data files</source>
-        <target state="new">Compress interface and optimization data files</target>
+        <target state="translated">인터페이스 및 최적화 데이터 파일 압축</target>
         <note />
       </trans-unit>
       <trans-unit id="optsGetLangVersions">
         <source>Display the allowed values for language version.</source>
-        <target state="new">Display the allowed values for language version.</target>
+        <target state="translated">언어 버전에 허용되는 값을 표시합니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsInvalidRefAssembly">
         <source>Invalid use of emitting a reference assembly, do not use '--standalone or --staticlink' with '--refonly or --refout'.</source>
-        <target state="needs-review-translation">참조 어셈블리 내보내기를 잘못 사용했습니다. '--staticlink' 또는 '--refonly' 및 '--refout'을 함께 사용하지 마세요.</target>
+        <target state="translated">참조 어셈블리 내보내기를 잘못 사용했습니다. '--refonly 또는 --refout'과 함께 '--standalone 또는 --staticlink'를 사용하지 마세요.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsInvalidRefOut">
@@ -549,12 +609,12 @@
       </trans-unit>
       <trans-unit id="optsOptimizationData">
         <source>Specify included optimization information, the default is file. Important for distributed libraries.</source>
-        <target state="new">Specify included optimization information, the default is file. Important for distributed libraries.</target>
+        <target state="translated">포함된 최적화 정보를 지정합니다. 기본값은 파일입니다. 분산 라이브러리에 중요합니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsPdbMatchesOutputFileName">
         <source>The pdb output file name cannot match the build output filename use --pdb:filename.pdb</source>
-        <target state="new">The pdb output file name cannot match the build output filename use --pdb:filename.pdb</target>
+        <target state="translated">pdb 출력 파일 이름은 빌드 출력 파일 이름 사용 --pdb:filename.pdb와 일치할 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsRefOnly">
@@ -569,17 +629,17 @@
       </trans-unit>
       <trans-unit id="optsReflectionFree">
         <source>Disable implicit generation of constructs using reflection</source>
-        <target state="new">Disable implicit generation of constructs using reflection</target>
+        <target state="translated">리플렉션을 사용하여 구문의 암시적 생성 사용 안 함</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSetLangVersion">
         <source>Specify language version such as 'latest' or 'preview'.</source>
-        <target state="new">Specify language version such as 'latest' or 'preview'.</target>
+        <target state="translated">'latest' 또는 'preview'와 같이 언어 버전을 지정합니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSignatureData">
         <source>Include F# interface information, the default is file. Essential for distributing libraries.</source>
-        <target state="new">Include F# interface information, the default is file. Essential for distributing libraries.</target>
+        <target state="translated">F# 인터페이스 정보를 포함합니다. 기본값은 파일입니다. 라이브러리를 배포하는 데 필수적입니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSupportedLangVersions">
@@ -589,12 +649,12 @@
       </trans-unit>
       <trans-unit id="optsUnknownOptimizationData">
         <source>Invalid value '{0}' for --optimizationdata, valid value are: none, file, compress.</source>
-        <target state="new">Invalid value '{0}' for --optimizationdata, valid value are: none, file, compress.</target>
+        <target state="translated">--optimizationdata에 대한 '{0}' 값이 잘못되었습니다. 올바른 값은 none, file, compress입니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsUnknownSignatureData">
         <source>Invalid value '{0}' for --interfacedata, valid value are: none, file, compress.</source>
-        <target state="new">Invalid value '{0}' for --interfacedata, valid value are: none, file, compress.</target>
+        <target state="translated">--interfacedata에 대한 '{0}' 값이 잘못되었습니다. 올바른 값은 none, file, compress입니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsUnrecognizedLanguageVersion">
@@ -649,7 +709,7 @@
       </trans-unit>
       <trans-unit id="parsExpectedPatternAfterToken">
         <source>Expected a pattern after this point</source>
-        <target state="new">Expected a pattern after this point</target>
+        <target state="translated">이 지점 뒤에 패턴이 필요합니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="parsExpectingExpressionInTuple">
@@ -659,17 +719,17 @@
       </trans-unit>
       <trans-unit id="parsExpectingPatternInTuple">
         <source>Expecting pattern</source>
-        <target state="new">Expecting pattern</target>
+        <target state="translated">예상되는 패턴</target>
         <note />
       </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
         <source>Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</source>
-        <target state="new">Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</target>
+        <target state="translated">불완전한 문자 리터럴(예: 'Q') 또는 정규화된 형식 호출(예: 'T.Name)</target>
         <note />
       </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr2">
         <source>Incomplete operator expression (example a^b) or qualified type invocation (example: ^T.Name)</source>
-        <target state="new">Incomplete operator expression (example a^b) or qualified type invocation (example: ^T.Name)</target>
+        <target state="translated">불완전한 연산자 식(예: a^b) 또는 정규화된 형식 호출(예: ^T.Name)</target>
         <note />
       </trans-unit>
       <trans-unit id="parsNewExprMemberAccess">
@@ -849,7 +909,7 @@
       </trans-unit>
       <trans-unit id="tcInitOnlyPropertyCannotBeSet1">
         <source>Init-only property '{0}' cannot be set outside the initialization code. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</source>
-        <target state="new">Init-only property '{0}' cannot be set outside the initialization code. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
+        <target state="translated">초기화 코드 외부에서는 '{0}' 초기화 전용 속성을 설정할 수 없습니다. https://aka.ms/fsharp-assigning-values-to-properties-at-initialization을 참조하세요.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcInlineIfLambdaUsedOnNonInlineFunctionOrMethod">
@@ -879,7 +939,7 @@
       </trans-unit>
       <trans-unit id="tcInvalidSelfConstraint">
         <source>Invalid constraint. Valid constraint forms include \"'T :&gt; ISomeInterface\" for interface constraints and \"SomeConstrainingType&lt;'T&gt;\" for self-constraints. See https://aka.ms/fsharp-type-constraints.</source>
-        <target state="new">Invalid constraint. Valid constraint forms include \"'T :&gt; ISomeInterface\" for interface constraints and \"SomeConstrainingType&lt;'T&gt;\" for self-constraints. See https://aka.ms/fsharp-type-constraints.</target>
+        <target state="translated">제약 조건이 잘못되었습니다. 유효한 제약 조건 양식은 인터페이스 제약 조건의 경우 \"'T :&gt; ISomeInterface\", 자체 제약 조건의 경우 \"SomeConstrainingType&lt;'T&gt;\" 등입니다. https://aka.ms/fsharp-type-constraints를 참조하세요.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcInvalidStructReturn">
@@ -924,7 +984,7 @@
       </trans-unit>
       <trans-unit id="tcMissingRequiredMembers">
         <source>The following required properties have to be initalized:{0}</source>
-        <target state="new">The following required properties have to be initalized:{0}</target>
+        <target state="translated">다음 필수 속성을 초기화해야 합니다. {0}</target>
         <note />
       </trans-unit>
       <trans-unit id="tcNoEagerConstraintApplicationAttribute">
@@ -1009,7 +1069,7 @@
       </trans-unit>
       <trans-unit id="tcSetterForInitOnlyPropertyCannotBeCalled1">
         <source>Cannot call '{0}' - a setter for init-only property, please use object initialization instead. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</source>
-        <target state="new">Cannot call '{0}' - a setter for init-only property, please use object initialization instead. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
+        <target state="translated">init 전용 속성의 setter인 '{0}'을(를) 호출할 수 없습니다. 개체 초기화를 대신 사용하세요. https://aka.ms/fsharp-assigning-values-to-properties-at-initialization를 참조하세요.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcSubsumptionImplicitConversionUsed">
@@ -1019,32 +1079,32 @@
       </trans-unit>
       <trans-unit id="tcSynTypeOrInvalidInDeclaration">
         <source>SynType.Or is not permitted in this declaration</source>
-        <target state="new">SynType.Or is not permitted in this declaration</target>
+        <target state="translated">SynType.Or는 이 선언에서 허용되지 않습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitHasMultipleSupportTypes">
         <source>The trait '{0}' invoked by this call has multiple support types. This invocation syntax is not permitted for such traits. See https://aka.ms/fsharp-srtp for guidance.</source>
-        <target state="new">The trait '{0}' invoked by this call has multiple support types. This invocation syntax is not permitted for such traits. See https://aka.ms/fsharp-srtp for guidance.</target>
+        <target state="translated">이 호출에서 호출한 '{0}' 특성에는 여러 지원 유형이 있습니다. 이러한 특성에는 이 호출 구문을 사용할 수 없습니다. 지침은 https://aka.ms/fsharp-srtp를 참조하세요.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitInvocationShouldUseTick">
         <source>Invocation of a static constraint should use \"'T.Ident\" and not \"^T.Ident\", even for statically resolved type parameters.</source>
-        <target state="new">Invocation of a static constraint should use \"'T.Ident\" and not \"^T.Ident\", even for statically resolved type parameters.</target>
+        <target state="translated">고정적인 제약 조건 호출은 정적으로 확인된 형식 매개 변수의 경우에도 \"^T.Ident\"가 아니라 \"'T.Ident\"를 사용해야 합니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitIsNotStatic">
         <source>Trait '{0}' is not static</source>
-        <target state="new">Trait '{0}' is not static</target>
+        <target state="translated">'{0}' 특성은 고정적이지 않습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitIsStatic">
         <source>Trait '{0}' is static</source>
-        <target state="new">Trait '{0}' is static</target>
+        <target state="translated">'{0}' 특성은 고정적입니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitMayNotUseComplexThings">
         <source>A trait may not specify optional, in, out, ParamArray, CallerInfo or Quote arguments</source>
-        <target state="new">A trait may not specify optional, in, out, ParamArray, CallerInfo or Quote arguments</target>
+        <target state="translated">특성은 optional, in, out, ParamArray, CallerInfo, Quote 인수를 지정할 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcUnableToParseInterpolatedString">
@@ -1054,12 +1114,12 @@
       </trans-unit>
       <trans-unit id="tcUsingInterfaceWithStaticAbstractMethodAsType">
         <source>'{0}' is normally used as a type constraint in generic code, e.g. \"'T when ISomeInterface&lt;'T&gt;\" or \"let f (x: #ISomeInterface&lt;_&gt;)\". See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3536\"' or '--nowarn:3536'.</source>
-        <target state="new">'{0}' is normally used as a type constraint in generic code, e.g. \"'T when ISomeInterface&lt;'T&gt;\" or \"let f (x: #ISomeInterface&lt;_&gt;)\". See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3536\"' or '--nowarn:3536'.</target>
+        <target state="translated">'{0}'은(는) 일반적으로 제네릭 코드에서 형식 제약 조건으로 사용됩니다(예: \"'T when ISomeInterface&lt;'T&gt;\" 또는 \"let f (x: #ISomeInterface&lt;_&gt;)\"). 지침은 https://aka.ms/fsharp-iwsams를 참조하세요. '#nowarn \"3536\"' 또는 '--nowarn:3536'을 사용하여 이 경고를 비활성화할 수 있습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcUsingInterfacesWithStaticAbstractMethods">
         <source>Declaring \"interfaces with static abstract methods\" is an advanced feature. See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3535\"' or '--nowarn:3535'.</source>
-        <target state="new">Declaring \"interfaces with static abstract methods\" is an advanced feature. See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3535\"' or '--nowarn:3535'.</target>
+        <target state="translated">\"interfaces with static abstract methods\"를 선언하는 것은 고급 기능입니다. 지침은 https://aka.ms/fsharp-iwsams를 참조하세요. '#nowarn \"3535\"' 또는 '--nowarn:3535'를 사용하여 이 경고를 비활성화할 수 있습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="typrelInterfaceMemberNoMostSpecificImplementation">
@@ -3849,7 +3909,7 @@
       </trans-unit>
       <trans-unit id="tcUnionCaseExpectsTupledArguments">
         <source>This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</source>
-        <target state="new">This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</target>
+        <target state="translated">이 공용 구조체 사례에는 튜플 형식의 {0} 인수가 필요하지만 {1}이(가) 제공되었습니다. 누락된 필드 인수는 다음 중 하나일 수 있습니다.{2}</target>
         <note />
       </trans-unit>
       <trans-unit id="tcFieldIsNotStatic">
@@ -7529,7 +7589,7 @@
       </trans-unit>
       <trans-unit id="tcStructUnionMultiCaseDistinctFields">
         <source>If a multicase union type is a struct, then all union cases must have unique names. For example: 'type A = B of b: int | C of c: int'.</source>
-        <target state="needs-review-translation">공용 구조체 형식이 둘 이상의 case를 포함하고 구조체인 경우 공용 구조체 형식 내의 모든 필드에 고유한 이름을 지정해야 합니다.</target>
+        <target state="translated">다중 사례 공용 구조체 형식이 구조체인 경우 모든 공용 구조체 사례의 이름이 고유해야 합니다. 예: 'type A = B of b: int | C 중 C: 정수'.</target>
         <note />
       </trans-unit>
       <trans-unit id="CallerMemberNameIsOverriden">
diff --git a/src/Compiler/xlf/FSComp.txt.pl.xlf b/src/Compiler/xlf/FSComp.txt.pl.xlf
index 136d0b7f299..764d818dcd4 100644
--- a/src/Compiler/xlf/FSComp.txt.pl.xlf
+++ b/src/Compiler/xlf/FSComp.txt.pl.xlf
@@ -4,7 +4,12 @@
     <body>
       <trans-unit id="arrayElementHasWrongTypeTuple">
         <source>All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Wszystkie elementy tablicy muszą być niejawnie konwertowalne na typ pierwszego elementu, który w tym miejscu jest krotką o długości {0} typu\n    {1}    \nTen element jest krotką o długości {2} typu\n    {3}    \n</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="buildDuplicateFile">
+        <source>The source file '{0}' (at position {1}/{2}) already appeared in the compilation list (at position {3}/{4}). Please verify that it is included only once in the project file.</source>
+        <target state="translated">Plik źródłowy „{0}” (na pozycji {1}/{2}) już pojawił się na liście kompilacji (na pozycji {3}/{4}). Sprawdź, czy jest on uwzględniony tylko raz w pliku projektu.</target>
         <note />
       </trans-unit>
       <trans-unit id="buildInvalidSourceFileExtensionML">
@@ -17,9 +22,29 @@
         <target state="translated">Rozszerzenie pliku "{0}" nie zostało rozpoznane. Pliki źródłowe muszą mieć rozszerzenie .fs, .fsi, .fsx lub .fsscript</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkAbstractMembersDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkAdditionalConstructorOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Additional constructor is not allowed.</source>
+        <target state="translated">Jeśli typ używa obu [&lt;Sealed&gt;] i [&lt; AbstractClass&gt;] atrybutów, oznacza to, że jest statyczny. Konstruktor jest również niedozwolony.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkConstructorWithArgumentsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Constructor with arguments is not allowed.</source>
+        <target state="translated">Jeśli typ używa obu [&lt;Sealed&gt;] i [&lt; AbstractClass&gt;] atrybutów, oznacza to, że jest statyczny. Konstruktor z argumentami jest niedozwolony.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkDuplicatedMethodParameter">
         <source>Duplicate parameter. The parameter '{0}' has been used more that once in this method.</source>
-        <target state="new">Duplicate parameter. The parameter '{0}' has been used more that once in this method.</target>
+        <target state="translated">Zduplikowany parametr. Parametr „{0}” został użyty więcej niż raz w tej metodzie.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkExplicitFieldsDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</target>
         <note />
       </trans-unit>
       <trans-unit id="chkFeatureNotLanguageSupported">
@@ -37,6 +62,11 @@
         <target state="translated">Funkcja „{0}” wymaga biblioteki języka F# dla wersji językowej {1} lub nowszej.</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkImplementingInterfacesOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkInfoRefcellAssign">
         <source>The use of ':=' from the F# library is deprecated. See https://aka.ms/fsharp-refcell-ops. For example, please change 'cell := expr' to 'cell.Value &lt;- expr'.</source>
         <target state="translated">Użycie elementu „:=” z biblioteki języka F# jest przestarzałe. Sprawdź stronę https://aka.ms/fsharp-refcell-ops. Na przykład zmień wyrażenie „cell := expr” na „cell.Value &lt;- expr”.</target>
@@ -57,6 +87,16 @@
         <target state="translated">Użycie elementu „incr” z biblioteki języka F# jest przestarzałe. Sprawdź stronę https://aka.ms/fsharp-refcell-ops. Na przykład zmień wyrażenie „incr cell” na „cell.Value &lt;- cell.Value + 1”.</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkInstanceLetBindingOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkInstanceMemberOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance members are not allowed.</source>
+        <target state="translated">Jeśli typ używa obu [&lt;Sealed&gt;] i [&lt; AbstractClass&gt;] atrybutów, oznacza to, że jest statyczny. Elementy członkowskie wystąpienia są niedozwolone.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="containerDeprecated">
         <source>The 'AssemblyKeyNameAttribute' has been deprecated. Use 'AssemblyKeyFileAttribute' instead.</source>
         <target state="translated">Element „AssemblyKeyNameAttribute” jest przestarzały. Zamiast niego użyj elementu „AssemblyKeyFileAttribute”.</target>
@@ -114,7 +154,7 @@
       </trans-unit>
       <trans-unit id="elseBranchHasWrongTypeTuple">
         <source>All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Wszystkie gałęzie wyrażenia „if” muszą zwracać wartości niejawnie konwertowalne na typ pierwszej gałęzi, która tutaj jest krotką o długości {0} typu\n    {1}    \nTa gałąź zwraca krotkę o długości {2} typu\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="etProviderHasDesignerAssemblyDependency">
@@ -142,6 +182,11 @@
         <target state="translated">praktyczne wyrażenia obliczeniowe</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureArithmeticInLiterals">
+        <source>Allow arithmetic and logical operations in literals</source>
+        <target state="translated">Zezwalaj na operacje arytmetyczne i logiczne w literałach</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureAttributesToRightOfModuleKeyword">
         <source>attributes to the right of the 'module' keyword</source>
         <target state="translated">atrybuty po prawej stronie słowa kluczowego "module"</target>
@@ -154,7 +199,7 @@
       </trans-unit>
       <trans-unit id="featureCSharpExtensionAttributeNotRequired">
         <source>Allow implicit Extension attribute on declaring types, modules</source>
-        <target state="new">Allow implicit Extension attribute on declaring types, modules</target>
+        <target state="translated">Zezwalaj na niejawny atrybut Rozszerzenie dla deklarujących typów, modułów</target>
         <note />
       </trans-unit>
       <trans-unit id="featureDefaultInterfaceMemberConsumption">
@@ -179,7 +224,7 @@
       </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
-        <target state="new">Raises errors for non-virtual members overrides</target>
+        <target state="translated">Zgłasza błędy w przypadku przesłonięć elementów innych niż wirtualne</target>
         <note />
       </trans-unit>
       <trans-unit id="featureErrorOnDeprecatedRequireQualifiedAccess">
@@ -187,6 +232,16 @@
         <target state="translated">wskazywanie błędu w przypadku przestarzałego dostępu do konstrukcji z atrybutem RequireQualifiedAccess</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureErrorReportingOnStaticClasses">
+        <source>Error reporting on static classes</source>
+        <target state="translated">Raportowanie błędów dla klas statycznych</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="featureEscapeBracesInFormattableString">
+        <source>Escapes curly braces before calling FormattableStringFactory.Create when interpolated string literal is typed as FormattableString</source>
+        <target state="translated">Uniknie nawiasów klamrowych przed wywołaniem metody FormattableStringFactory.Create, gdy interpolowany literał ciągu jest wpisywany jako FormattableString</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureExpandedMeasurables">
         <source>more types support units of measure</source>
         <target state="translated">więcej typów obsługuje jednostki miary</target>
@@ -214,12 +269,12 @@
       </trans-unit>
       <trans-unit id="featureInitProperties">
         <source>support for consuming init properties</source>
-        <target state="new">support for consuming init properties</target>
+        <target state="translated">obsługa używania właściwości init</target>
         <note />
       </trans-unit>
       <trans-unit id="featureInterfacesWithAbstractStaticMembers">
         <source>static abstract interface members</source>
-        <target state="new">static abstract interface members</target>
+        <target state="translated">statyczne abstrakcyjne elementy członkowskie interfejsu</target>
         <note />
       </trans-unit>
       <trans-unit id="featureInterfacesWithMultipleGenericInstantiation">
@@ -229,7 +284,7 @@
       </trans-unit>
       <trans-unit id="featureLowercaseDUWhenRequireQualifiedAccess">
         <source>Allow lowercase DU when RequireQualifiedAccess attribute</source>
-        <target state="new">Allow lowercase DU when RequireQualifiedAccess attribute</target>
+        <target state="translated">Zezwalaj na małą literę DU, gdy występuje RequireQualifiedAccess</target>
         <note />
       </trans-unit>
       <trans-unit id="featureMLCompatRevisions">
@@ -239,7 +294,7 @@
       </trans-unit>
       <trans-unit id="featureMatchNotAllowedForUnionCaseWithNoData">
         <source>Pattern match discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern match discard is not allowed for union case that takes no data.</target>
+        <target state="translated">Odrzucenie dopasowania wzorca jest niedozwolone w przypadku unii, która nie pobiera żadnych danych.</target>
         <note />
       </trans-unit>
       <trans-unit id="featureNameOf">
@@ -299,7 +354,7 @@
       </trans-unit>
       <trans-unit id="featureRequiredProperties">
         <source>support for required properties</source>
-        <target state="new">support for required properties</target>
+        <target state="translated">obsługa wymaganych właściwości</target>
         <note />
       </trans-unit>
       <trans-unit id="featureResumableStateMachines">
@@ -309,7 +364,7 @@
       </trans-unit>
       <trans-unit id="featureSelfTypeConstraints">
         <source>self type constraints</source>
-        <target state="new">self type constraints</target>
+        <target state="translated">ograniczenia typu własnego</target>
         <note />
       </trans-unit>
       <trans-unit id="featureSingleUnderscorePattern">
@@ -327,6 +382,11 @@
         <target state="translated">reprezentacja struktury aktywnych wzorców</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureWarningWhenInliningMethodImplNoInlineMarkedFunction">
+        <source>Raises warnings when 'let inline ... =' is used together with [&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;] attribute. Function is not getting inlined.</source>
+        <target state="translated">Zgłasza ostrzeżenia, gdy element „let inline ... =” jest używany razem z atrybutem [&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;]. Funkcja nie jest wstawiana.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureWildCardInForLoop">
         <source>wild card in for loop</source>
         <target state="translated">symbol wieloznaczny w pętli for</target>
@@ -339,7 +399,7 @@
       </trans-unit>
       <trans-unit id="followingPatternMatchClauseHasWrongTypeTuple">
         <source>All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Wszystkie gałęzie wyrażenia dopasowania wzorca muszą zwracać wartości niejawnie konwertowalne na typ pierwszej gałęzi, oto krotka o długości {0} typu\n    {1}    \nTa Gałąź zwraca krotki o długości {2} typu\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="forFormatInvalidForInterpolated">
@@ -364,7 +424,7 @@
       </trans-unit>
       <trans-unit id="forPercentAInReflectionFreeCode">
         <source>The '%A' format specifier may not be used in an assembly being compiled with option '--reflectionfree'. This construct implicitly uses reflection.</source>
-        <target state="new">The '%A' format specifier may not be used in an assembly being compiled with option '--reflectionfree'. This construct implicitly uses reflection.</target>
+        <target state="translated">Specyfikator formatu „%A” nie może być używany w zestawie kompilowanym z opcją „--reflectionfree”. Ta konstrukcja niejawnie używa odbicia.</target>
         <note />
       </trans-unit>
       <trans-unit id="formatDashItem">
@@ -384,7 +444,7 @@
       </trans-unit>
       <trans-unit id="ifExpressionTuple">
         <source>The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Wyrażenie „if” musi zwrócić krotkę o długości {0} typu\n    {1}    \naby spełnić wymagania dotyczące typu kontekstu. Obecnie zwraca krotkę o długości {2} typu\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="ilxGenUnknownDebugPoint">
@@ -409,7 +469,7 @@
       </trans-unit>
       <trans-unit id="keywordDescriptionAnd">
         <source>Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</source>
-        <target state="new">Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</target>
+        <target state="translated">Używane w powiązaniach wzajemnie cyklicznych, deklaracjach właściwości oraz z wieloma ograniczeniami parametrów ogólnych.</target>
         <note />
       </trans-unit>
       <trans-unit id="keywordDescriptionConst">
@@ -419,7 +479,7 @@
       </trans-unit>
       <trans-unit id="keywordDescriptionTypeTest">
         <source>Used to check if an object is of the given type in a pattern or binding.</source>
-        <target state="new">Used to check if an object is of the given type in a pattern or binding.</target>
+        <target state="translated">Służy do sprawdzania, czy obiekt jest danego typu we wzorcu lub powiązaniu.</target>
         <note />
       </trans-unit>
       <trans-unit id="lexByteStringMayNotBeInterpolated">
@@ -449,12 +509,12 @@
       </trans-unit>
       <trans-unit id="listElementHasWrongTypeTuple">
         <source>All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Wszystkie elementy tablicy muszą być niejawnie konwertowalne na typ pierwszego elementu, który w tym miejscu jest krotką o długości {0} typu\n    {1}    \nTen element jest krotką o długości {2} typu\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="matchNotAllowedForUnionCaseWithNoData">
         <source>Pattern discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern discard is not allowed for union case that takes no data.</target>
+        <target state="translated">Odrzucanie wzorca jest niedozwolone w przypadku unii, która nie przyjmuje żadnych danych.</target>
         <note />
       </trans-unit>
       <trans-unit id="mlCompatError">
@@ -529,17 +589,17 @@
       </trans-unit>
       <trans-unit id="optsCompressMetadata">
         <source>Compress interface and optimization data files</source>
-        <target state="new">Compress interface and optimization data files</target>
+        <target state="translated">Kompresuj pliki danych interfejsu i optymalizacji</target>
         <note />
       </trans-unit>
       <trans-unit id="optsGetLangVersions">
         <source>Display the allowed values for language version.</source>
-        <target state="new">Display the allowed values for language version.</target>
+        <target state="translated">Wyświetl dozwolone wartości dla wersji językowej.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsInvalidRefAssembly">
         <source>Invalid use of emitting a reference assembly, do not use '--standalone or --staticlink' with '--refonly or --refout'.</source>
-        <target state="needs-review-translation">Nieprawidłowe użycie emitowania zestawu odwołania, nie używaj razem elementów „--staticlink” ani „--refonly” i „--refout”.</target>
+        <target state="translated">Nieprawidłowe użycie emitowania zestawu odwołania. Nie używaj elementu „--standalone ani --staticlink” z elementem „--refonly lub --refout”.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsInvalidRefOut">
@@ -549,12 +609,12 @@
       </trans-unit>
       <trans-unit id="optsOptimizationData">
         <source>Specify included optimization information, the default is file. Important for distributed libraries.</source>
-        <target state="new">Specify included optimization information, the default is file. Important for distributed libraries.</target>
+        <target state="translated">Określ dołączone informacje o optymalizacji. Wartość domyślna to plik. Ważne dla bibliotek rozproszonych.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsPdbMatchesOutputFileName">
         <source>The pdb output file name cannot match the build output filename use --pdb:filename.pdb</source>
-        <target state="new">The pdb output file name cannot match the build output filename use --pdb:filename.pdb</target>
+        <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="optsRefOnly">
@@ -569,17 +629,17 @@
       </trans-unit>
       <trans-unit id="optsReflectionFree">
         <source>Disable implicit generation of constructs using reflection</source>
-        <target state="new">Disable implicit generation of constructs using reflection</target>
+        <target state="translated">Wyłącz niejawne generowanie konstrukcji przy użyciu odbicia</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSetLangVersion">
         <source>Specify language version such as 'latest' or 'preview'.</source>
-        <target state="new">Specify language version such as 'latest' or 'preview'.</target>
+        <target state="translated">Określ wersję językową, taką jak „najnowsza” lub „wersja zapoznawcza”.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSignatureData">
         <source>Include F# interface information, the default is file. Essential for distributing libraries.</source>
-        <target state="new">Include F# interface information, the default is file. Essential for distributing libraries.</target>
+        <target state="translated">Uwzględnij informacje o interfejsie języka F#. Wartość domyślna to plik. Niezbędne do rozpowszechniania bibliotek.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSupportedLangVersions">
@@ -589,12 +649,12 @@
       </trans-unit>
       <trans-unit id="optsUnknownOptimizationData">
         <source>Invalid value '{0}' for --optimizationdata, valid value are: none, file, compress.</source>
-        <target state="new">Invalid value '{0}' for --optimizationdata, valid value are: none, file, compress.</target>
+        <target state="translated">Nieprawidłowa wartość „{0}” dla parametru --optimizationdata, prawidłowa wartość to: none, file, compress.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsUnknownSignatureData">
         <source>Invalid value '{0}' for --interfacedata, valid value are: none, file, compress.</source>
-        <target state="new">Invalid value '{0}' for --interfacedata, valid value are: none, file, compress.</target>
+        <target state="translated">Nieprawidłowa wartość „{0}” dla parametru --interfacedata, prawidłowa wartość to: none, file, compress.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsUnrecognizedLanguageVersion">
@@ -649,7 +709,7 @@
       </trans-unit>
       <trans-unit id="parsExpectedPatternAfterToken">
         <source>Expected a pattern after this point</source>
-        <target state="new">Expected a pattern after this point</target>
+        <target state="translated">Oczekiwano wzorca po tym punkcie</target>
         <note />
       </trans-unit>
       <trans-unit id="parsExpectingExpressionInTuple">
@@ -659,17 +719,17 @@
       </trans-unit>
       <trans-unit id="parsExpectingPatternInTuple">
         <source>Expecting pattern</source>
-        <target state="new">Expecting pattern</target>
+        <target state="translated">Oczekiwano wzorca</target>
         <note />
       </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
         <source>Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</source>
-        <target state="new">Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</target>
+        <target state="translated">Niekompletny literał znaku (przykład: „Q”) lub wywołanie typu kwalifikowanego (przykład: „T.Name”)</target>
         <note />
       </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr2">
         <source>Incomplete operator expression (example a^b) or qualified type invocation (example: ^T.Name)</source>
-        <target state="new">Incomplete operator expression (example a^b) or qualified type invocation (example: ^T.Name)</target>
+        <target state="translated">Niekompletne wyrażenie operatora (na przykład a^b) lub wywołanie typu kwalifikowanego (przykład: ^T.Name)</target>
         <note />
       </trans-unit>
       <trans-unit id="parsNewExprMemberAccess">
@@ -849,7 +909,7 @@
       </trans-unit>
       <trans-unit id="tcInitOnlyPropertyCannotBeSet1">
         <source>Init-only property '{0}' cannot be set outside the initialization code. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</source>
-        <target state="new">Init-only property '{0}' cannot be set outside the initialization code. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
+        <target state="translated">Właściwość init-only „{0}” nie może być ustawiona poza kodem inicjowania. Zobacz https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
         <note />
       </trans-unit>
       <trans-unit id="tcInlineIfLambdaUsedOnNonInlineFunctionOrMethod">
@@ -879,7 +939,7 @@
       </trans-unit>
       <trans-unit id="tcInvalidSelfConstraint">
         <source>Invalid constraint. Valid constraint forms include \"'T :&gt; ISomeInterface\" for interface constraints and \"SomeConstrainingType&lt;'T&gt;\" for self-constraints. See https://aka.ms/fsharp-type-constraints.</source>
-        <target state="new">Invalid constraint. Valid constraint forms include \"'T :&gt; ISomeInterface\" for interface constraints and \"SomeConstrainingType&lt;'T&gt;\" for self-constraints. See https://aka.ms/fsharp-type-constraints.</target>
+        <target state="translated">Nieprawidłowe ograniczenie. Prawidłowe formularze ograniczeń obejmują \"'T :&gt; ISomeInterface\" for interface constraints and \"SomeConstrainingType&lt;'T&gt;\" dla ograniczeń własnych. Zobacz https://aka.ms/fsharp-type-constraints.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcInvalidStructReturn">
@@ -924,7 +984,7 @@
       </trans-unit>
       <trans-unit id="tcMissingRequiredMembers">
         <source>The following required properties have to be initalized:{0}</source>
-        <target state="new">The following required properties have to be initalized:{0}</target>
+        <target state="translated">Następujące wymagane właściwości muszą zostać zainicjowane:{0}</target>
         <note />
       </trans-unit>
       <trans-unit id="tcNoEagerConstraintApplicationAttribute">
@@ -1009,7 +1069,7 @@
       </trans-unit>
       <trans-unit id="tcSetterForInitOnlyPropertyCannotBeCalled1">
         <source>Cannot call '{0}' - a setter for init-only property, please use object initialization instead. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</source>
-        <target state="new">Cannot call '{0}' - a setter for init-only property, please use object initialization instead. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
+        <target state="translated">Nie można wywołać „{0}” — metody ustawiającej dla właściwości tylko do inicjowania. Zamiast tego użyj inicjowania obiektu. Zobacz https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
         <note />
       </trans-unit>
       <trans-unit id="tcSubsumptionImplicitConversionUsed">
@@ -1019,32 +1079,32 @@
       </trans-unit>
       <trans-unit id="tcSynTypeOrInvalidInDeclaration">
         <source>SynType.Or is not permitted in this declaration</source>
-        <target state="new">SynType.Or is not permitted in this declaration</target>
+        <target state="translated">Element SynType.Or nie jest dozwolony w tej deklaracji</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitHasMultipleSupportTypes">
         <source>The trait '{0}' invoked by this call has multiple support types. This invocation syntax is not permitted for such traits. See https://aka.ms/fsharp-srtp for guidance.</source>
-        <target state="new">The trait '{0}' invoked by this call has multiple support types. This invocation syntax is not permitted for such traits. See https://aka.ms/fsharp-srtp for guidance.</target>
+        <target state="translated">Cecha „{0}” wywołana przez to wywołanie ma wiele typów obsługi. Ta składnia wywołania nie jest dozwolona dla takich cech. Aby uzyskać wskazówki, zobacz https://aka.ms/fsharp-srtp.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitInvocationShouldUseTick">
         <source>Invocation of a static constraint should use \"'T.Ident\" and not \"^T.Ident\", even for statically resolved type parameters.</source>
-        <target state="new">Invocation of a static constraint should use \"'T.Ident\" and not \"^T.Ident\", even for statically resolved type parameters.</target>
+        <target state="translated">Wywołanie ograniczenia statycznego powinno używać elementu \"' T.Ident\" a nie \"^T.Ident\", nawet w przypadku statycznie rozpoznawanych parametrów typu.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitIsNotStatic">
         <source>Trait '{0}' is not static</source>
-        <target state="new">Trait '{0}' is not static</target>
+        <target state="translated">Cecha „{0}” nie jest statyczna</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitIsStatic">
         <source>Trait '{0}' is static</source>
-        <target state="new">Trait '{0}' is static</target>
+        <target state="translated">Cecha „{0}” jest statyczna</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitMayNotUseComplexThings">
         <source>A trait may not specify optional, in, out, ParamArray, CallerInfo or Quote arguments</source>
-        <target state="new">A trait may not specify optional, in, out, ParamArray, CallerInfo or Quote arguments</target>
+        <target state="translated">Cecha nie może określać opcjonalnych argumentów in, out, ParamArray, CallerInfo lub Quote</target>
         <note />
       </trans-unit>
       <trans-unit id="tcUnableToParseInterpolatedString">
@@ -1054,12 +1114,12 @@
       </trans-unit>
       <trans-unit id="tcUsingInterfaceWithStaticAbstractMethodAsType">
         <source>'{0}' is normally used as a type constraint in generic code, e.g. \"'T when ISomeInterface&lt;'T&gt;\" or \"let f (x: #ISomeInterface&lt;_&gt;)\". See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3536\"' or '--nowarn:3536'.</source>
-        <target state="new">'{0}' is normally used as a type constraint in generic code, e.g. \"'T when ISomeInterface&lt;'T&gt;\" or \"let f (x: #ISomeInterface&lt;_&gt;)\". See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3536\"' or '--nowarn:3536'.</target>
+        <target state="translated">Element „{0}” jest zwykle używany jako ograniczenie typu w kodzie ogólnym, np. \"" T, gdy ISomeInterface&lt;' T&gt;\" lub \"let f (x: #ISomeInterface&lt;_&gt;)\". Aby uzyskać wskazówki, zobacz https://aka.ms/fsharp-iwsams. To ostrzeżenie można wyłączyć, używając polecenia „nowarn \"3536\"" lub "--nowarn:3536”.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcUsingInterfacesWithStaticAbstractMethods">
         <source>Declaring \"interfaces with static abstract methods\" is an advanced feature. See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3535\"' or '--nowarn:3535'.</source>
-        <target state="new">Declaring \"interfaces with static abstract methods\" is an advanced feature. See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3535\"' or '--nowarn:3535'.</target>
+        <target state="translated">Deklarowanie \"interfejsów ze statycznymi metodami abstrakcyjnymi\" jest funkcją zaawansowaną. Aby uzyskać wskazówki, zobacz https://aka.ms/fsharp-iwsams. To ostrzeżenie można wyłączyć przy użyciu polecenia „#nowarn \"3535\"" lub "--nowarn:3535”.</target>
         <note />
       </trans-unit>
       <trans-unit id="typrelInterfaceMemberNoMostSpecificImplementation">
@@ -3849,7 +3909,7 @@
       </trans-unit>
       <trans-unit id="tcUnionCaseExpectsTupledArguments">
         <source>This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</source>
-        <target state="new">This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</target>
+        <target state="translated">Ten przypadek unii oczekuje {0} argumentów w formie krotki, ale otrzymano {1}. Brakujące argumenty pola mogą być dowolne z:{2}</target>
         <note />
       </trans-unit>
       <trans-unit id="tcFieldIsNotStatic">
@@ -7529,7 +7589,7 @@
       </trans-unit>
       <trans-unit id="tcStructUnionMultiCaseDistinctFields">
         <source>If a multicase union type is a struct, then all union cases must have unique names. For example: 'type A = B of b: int | C of c: int'.</source>
-        <target state="needs-review-translation">Jeśli typ unii ma więcej niż jeden przypadek i jest strukturą, wszystkim polom w typie unii należy nadać unikatowe nazwy.</target>
+        <target state="translated">Jeśli typ unii wielokaskładnikowej jest strukturą, wszystkie przypadki unii muszą mieć unikatowe nazwy. Na przykład: „typ A = B z b: int | C z c: int”.</target>
         <note />
       </trans-unit>
       <trans-unit id="CallerMemberNameIsOverriden">
diff --git a/src/Compiler/xlf/FSComp.txt.pt-BR.xlf b/src/Compiler/xlf/FSComp.txt.pt-BR.xlf
index 7bd9a3a8003..da8982c32ac 100644
--- a/src/Compiler/xlf/FSComp.txt.pt-BR.xlf
+++ b/src/Compiler/xlf/FSComp.txt.pt-BR.xlf
@@ -4,7 +4,12 @@
     <body>
       <trans-unit id="arrayElementHasWrongTypeTuple">
         <source>All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Todos os elementos de uma matriz devem ser implicitamente conversíveis ao tipo do primeiro elemento, que aqui é uma tupla de comprimento {0} do tipo\n    {1}    \nEste elemento é uma tupla de comprimento {2} do tipo\n    {3}    \n</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="buildDuplicateFile">
+        <source>The source file '{0}' (at position {1}/{2}) already appeared in the compilation list (at position {3}/{4}). Please verify that it is included only once in the project file.</source>
+        <target state="translated">O arquivo fonte '{0}' (na posição {1}/{2} ) já apareceu na lista de compilação (na posição {3}/{4}). Verifique se ele foi incluído apenas uma vez no arquivo do projeto.</target>
         <note />
       </trans-unit>
       <trans-unit id="buildInvalidSourceFileExtensionML">
@@ -17,9 +22,29 @@
         <target state="translated">A extensão do arquivo de '{0}' não foi reconhecida. Os arquivos de origem devem ter a extensão .fs, .fsi, .fsx or .fsscript</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkAbstractMembersDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkAdditionalConstructorOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Additional constructor is not allowed.</source>
+        <target state="translated">Se um tipo usa os atributos [&lt;Sealed&gt;] e [&lt;AbstractClass&gt;], significa que é estático. Construtor adicional não é permitido.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkConstructorWithArgumentsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Constructor with arguments is not allowed.</source>
+        <target state="translated">Se um tipo usa os atributos [&lt;Sealed&gt;] e [&lt;AbstractClass&gt;], significa que é estático. Construtor com argumentos não é permitido.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkDuplicatedMethodParameter">
         <source>Duplicate parameter. The parameter '{0}' has been used more that once in this method.</source>
-        <target state="new">Duplicate parameter. The parameter '{0}' has been used more that once in this method.</target>
+        <target state="translated">Parâmetro duplicado. O parâmetro '{0}' foi usado mais de uma vez neste método.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkExplicitFieldsDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</target>
         <note />
       </trans-unit>
       <trans-unit id="chkFeatureNotLanguageSupported">
@@ -37,6 +62,11 @@
         <target state="translated">O recurso '{0}' exige a biblioteca F# para a versão da linguagem {1} ou posterior.</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkImplementingInterfacesOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkInfoRefcellAssign">
         <source>The use of ':=' from the F# library is deprecated. See https://aka.ms/fsharp-refcell-ops. For example, please change 'cell := expr' to 'cell.Value &lt;- expr'.</source>
         <target state="translated">O uso de ':=' da biblioteca F# foi preterido. Consulte https://aka.ms/fsharp-refcell-ops. Por exemplo, altere 'cell := expr' para 'cell.Value &lt;- expr'.</target>
@@ -57,6 +87,16 @@
         <target state="translated">O uso de 'incr' da biblioteca F# foi preterido. Consulte https://aka.ms/fsharp-refcell-ops. Por exemplo, altere a célula 'incr cell' para 'cell.Value &lt;- cell.Value + 1'.</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkInstanceLetBindingOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkInstanceMemberOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance members are not allowed.</source>
+        <target state="translated">Se um tipo usa os atributos [&lt;Sealed&gt;] e [&lt;AbstractClass&gt;], significa que é estático. Membros da instância não são permitidos.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="containerDeprecated">
         <source>The 'AssemblyKeyNameAttribute' has been deprecated. Use 'AssemblyKeyFileAttribute' instead.</source>
         <target state="translated">O 'AssemblyKeyNameAttribute' foi preterido. Use o 'AssemblyKeyFileAttribute'.</target>
@@ -114,7 +154,7 @@
       </trans-unit>
       <trans-unit id="elseBranchHasWrongTypeTuple">
         <source>All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Todas as ramificações de uma expressão 'if' devem retornar valores implicitamente conversíveis ao tipo da primeira ramificação, que aqui é uma tupla de comprimento {0} do tipo\n    {1}    \nEsta ramificação retorna uma tupla de comprimento {2} do tipo\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="etProviderHasDesignerAssemblyDependency">
@@ -142,6 +182,11 @@
         <target state="translated">expressões de computação aplicáveis</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureArithmeticInLiterals">
+        <source>Allow arithmetic and logical operations in literals</source>
+        <target state="translated">Permitir operações aritméticas e lógicas em literais</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureAttributesToRightOfModuleKeyword">
         <source>attributes to the right of the 'module' keyword</source>
         <target state="translated">atributos à direita da palavra-chave 'módulo'</target>
@@ -154,7 +199,7 @@
       </trans-unit>
       <trans-unit id="featureCSharpExtensionAttributeNotRequired">
         <source>Allow implicit Extension attribute on declaring types, modules</source>
-        <target state="new">Allow implicit Extension attribute on declaring types, modules</target>
+        <target state="translated">Permitir atributo de Extensão implícito em tipos declarativos, módulos</target>
         <note />
       </trans-unit>
       <trans-unit id="featureDefaultInterfaceMemberConsumption">
@@ -179,7 +224,7 @@
       </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
-        <target state="new">Raises errors for non-virtual members overrides</target>
+        <target state="translated">Gera erros para substituições de membros não virtuais</target>
         <note />
       </trans-unit>
       <trans-unit id="featureErrorOnDeprecatedRequireQualifiedAccess">
@@ -187,6 +232,16 @@
         <target state="translated">fornecer erro no acesso preterido do constructo com o atributo RequireQualifiedAccess</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureErrorReportingOnStaticClasses">
+        <source>Error reporting on static classes</source>
+        <target state="translated">Relatório de erros em classes estáticas</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="featureEscapeBracesInFormattableString">
+        <source>Escapes curly braces before calling FormattableStringFactory.Create when interpolated string literal is typed as FormattableString</source>
+        <target state="translated">Sai das chaves antes de chamar FormattableStringFactory.Create quando o literal de cadeia de caracteres é digitado como FormattableString</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureExpandedMeasurables">
         <source>more types support units of measure</source>
         <target state="translated">mais tipos dão suporte para unidades de medida</target>
@@ -214,12 +269,12 @@
       </trans-unit>
       <trans-unit id="featureInitProperties">
         <source>support for consuming init properties</source>
-        <target state="new">support for consuming init properties</target>
+        <target state="translated">suporte para consumir propriedades de inicialização</target>
         <note />
       </trans-unit>
       <trans-unit id="featureInterfacesWithAbstractStaticMembers">
         <source>static abstract interface members</source>
-        <target state="new">static abstract interface members</target>
+        <target state="translated">membros de interface abstrata estática</target>
         <note />
       </trans-unit>
       <trans-unit id="featureInterfacesWithMultipleGenericInstantiation">
@@ -229,7 +284,7 @@
       </trans-unit>
       <trans-unit id="featureLowercaseDUWhenRequireQualifiedAccess">
         <source>Allow lowercase DU when RequireQualifiedAccess attribute</source>
-        <target state="new">Allow lowercase DU when RequireQualifiedAccess attribute</target>
+        <target state="translated">Permitir DU em minúsculas quando o atributo RequireQualifiedAccess</target>
         <note />
       </trans-unit>
       <trans-unit id="featureMLCompatRevisions">
@@ -239,7 +294,7 @@
       </trans-unit>
       <trans-unit id="featureMatchNotAllowedForUnionCaseWithNoData">
         <source>Pattern match discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern match discard is not allowed for union case that takes no data.</target>
+        <target state="translated">O descarte de correspondência de padrão não é permitido para casos união que não aceitam dados.</target>
         <note />
       </trans-unit>
       <trans-unit id="featureNameOf">
@@ -299,7 +354,7 @@
       </trans-unit>
       <trans-unit id="featureRequiredProperties">
         <source>support for required properties</source>
-        <target state="new">support for required properties</target>
+        <target state="translated">suporte para propriedades necessárias</target>
         <note />
       </trans-unit>
       <trans-unit id="featureResumableStateMachines">
@@ -309,7 +364,7 @@
       </trans-unit>
       <trans-unit id="featureSelfTypeConstraints">
         <source>self type constraints</source>
-        <target state="new">self type constraints</target>
+        <target state="translated">restrições de auto-tipo</target>
         <note />
       </trans-unit>
       <trans-unit id="featureSingleUnderscorePattern">
@@ -327,6 +382,11 @@
         <target state="translated">representação estrutural para padrões ativos</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureWarningWhenInliningMethodImplNoInlineMarkedFunction">
+        <source>Raises warnings when 'let inline ... =' is used together with [&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;] attribute. Function is not getting inlined.</source>
+        <target state="translated">Gera avisos quando 'let inline ... =' é usado junto com o atributo [&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;]. A função não está sendo embutida.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureWildCardInForLoop">
         <source>wild card in for loop</source>
         <target state="translated">curinga para loop</target>
@@ -339,7 +399,7 @@
       </trans-unit>
       <trans-unit id="followingPatternMatchClauseHasWrongTypeTuple">
         <source>All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Todas as ramificações de uma expressão de correspondência de padrão devem retornar valores implicitamente conversíveis ao tipo da primeira ramificação, que aqui é uma tupla de comprimento {0} do tipo\n    {1}    \nEsta ramificação retorna uma tupla de comprimento {2} do tipo\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="forFormatInvalidForInterpolated">
@@ -364,7 +424,7 @@
       </trans-unit>
       <trans-unit id="forPercentAInReflectionFreeCode">
         <source>The '%A' format specifier may not be used in an assembly being compiled with option '--reflectionfree'. This construct implicitly uses reflection.</source>
-        <target state="new">The '%A' format specifier may not be used in an assembly being compiled with option '--reflectionfree'. This construct implicitly uses reflection.</target>
+        <target state="translated">O especificador de formato '%A' não pode ser usado em um assembly que está sendo compilado com a opção '--reflectionfree'. Esse constructo usa implicitamente reflexão.</target>
         <note />
       </trans-unit>
       <trans-unit id="formatDashItem">
@@ -384,7 +444,7 @@
       </trans-unit>
       <trans-unit id="ifExpressionTuple">
         <source>The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Se a expressão 'if' precisa retornar uma tupla de comprimento {0} do tipo\n    {1}    \npara atender aos requisitos de tipo de contexto. Atualmente, ele retorna uma tupla de comprimento {2} do tipo\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="ilxGenUnknownDebugPoint">
@@ -409,7 +469,7 @@
       </trans-unit>
       <trans-unit id="keywordDescriptionAnd">
         <source>Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</source>
-        <target state="new">Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</target>
+        <target state="translated">Usado em associações mutualmente recursivas, em declarações de propriedade e em múltiplas restrições em parâmetros genéricos.</target>
         <note />
       </trans-unit>
       <trans-unit id="keywordDescriptionConst">
@@ -419,7 +479,7 @@
       </trans-unit>
       <trans-unit id="keywordDescriptionTypeTest">
         <source>Used to check if an object is of the given type in a pattern or binding.</source>
-        <target state="new">Used to check if an object is of the given type in a pattern or binding.</target>
+        <target state="translated">Usado para verificar se um objeto é do tipo fornecido em um padrão ou associação.</target>
         <note />
       </trans-unit>
       <trans-unit id="lexByteStringMayNotBeInterpolated">
@@ -449,12 +509,12 @@
       </trans-unit>
       <trans-unit id="listElementHasWrongTypeTuple">
         <source>All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Todos os elementos de uma lista devem ser implicitamente conversíveis ao tipo do primeiro elemento, que aqui é uma tupla de comprimento {0} do tipo\n    {1}    \nEste elemento é uma tupla de comprimento {2} do tipo\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="matchNotAllowedForUnionCaseWithNoData">
         <source>Pattern discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern discard is not allowed for union case that takes no data.</target>
+        <target state="translated">O descarte de padrão não é permitido para casos união que não aceitam dados.</target>
         <note />
       </trans-unit>
       <trans-unit id="mlCompatError">
@@ -529,17 +589,17 @@
       </trans-unit>
       <trans-unit id="optsCompressMetadata">
         <source>Compress interface and optimization data files</source>
-        <target state="new">Compress interface and optimization data files</target>
+        <target state="translated">Compactar arquivos de dados de otimização e interface</target>
         <note />
       </trans-unit>
       <trans-unit id="optsGetLangVersions">
         <source>Display the allowed values for language version.</source>
-        <target state="new">Display the allowed values for language version.</target>
+        <target state="translated">Exiba os valores permitidos para a versão do idioma.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsInvalidRefAssembly">
         <source>Invalid use of emitting a reference assembly, do not use '--standalone or --staticlink' with '--refonly or --refout'.</source>
-        <target state="needs-review-translation">Uso inválido de emitir um assembly de referência, não use '--staticlink' ou '--reutilly' e '--refout' juntos.</target>
+        <target state="translated">Uso inválido da emissão de um assembly de referência, não use '--standalone ou --staticlink' com '--refonly ou --refout'.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsInvalidRefOut">
@@ -549,12 +609,12 @@
       </trans-unit>
       <trans-unit id="optsOptimizationData">
         <source>Specify included optimization information, the default is file. Important for distributed libraries.</source>
-        <target state="new">Specify included optimization information, the default is file. Important for distributed libraries.</target>
+        <target state="translated">Especifique as informações de otimização incluídas, o padrão é o file. Importante para bibliotecas distribuídas.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsPdbMatchesOutputFileName">
         <source>The pdb output file name cannot match the build output filename use --pdb:filename.pdb</source>
-        <target state="new">The pdb output file name cannot match the build output filename use --pdb:filename.pdb</target>
+        <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="optsRefOnly">
@@ -569,17 +629,17 @@
       </trans-unit>
       <trans-unit id="optsReflectionFree">
         <source>Disable implicit generation of constructs using reflection</source>
-        <target state="new">Disable implicit generation of constructs using reflection</target>
+        <target state="translated">Desabilitar a geração implícita de constructos usando reflexão</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSetLangVersion">
         <source>Specify language version such as 'latest' or 'preview'.</source>
-        <target state="new">Specify language version such as 'latest' or 'preview'.</target>
+        <target state="translated">Especifique a versão do idioma, como 'última versão' ou 'versão prévia'.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSignatureData">
         <source>Include F# interface information, the default is file. Essential for distributing libraries.</source>
-        <target state="new">Include F# interface information, the default is file. Essential for distributing libraries.</target>
+        <target state="translated">Inclua informações da interface F#, o padrão é file. Essencial para distribuir bibliotecas.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSupportedLangVersions">
@@ -589,12 +649,12 @@
       </trans-unit>
       <trans-unit id="optsUnknownOptimizationData">
         <source>Invalid value '{0}' for --optimizationdata, valid value are: none, file, compress.</source>
-        <target state="new">Invalid value '{0}' for --optimizationdata, valid value are: none, file, compress.</target>
+        <target state="translated">Valor inválido '{0}' para --optimizationdata, o valor válido é: none, file, compact.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsUnknownSignatureData">
         <source>Invalid value '{0}' for --interfacedata, valid value are: none, file, compress.</source>
-        <target state="new">Invalid value '{0}' for --interfacedata, valid value are: none, file, compress.</target>
+        <target state="translated">Valor inválido '{0}' para --interfacedata, o valor válido é: none, file, compact.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsUnrecognizedLanguageVersion">
@@ -649,7 +709,7 @@
       </trans-unit>
       <trans-unit id="parsExpectedPatternAfterToken">
         <source>Expected a pattern after this point</source>
-        <target state="new">Expected a pattern after this point</target>
+        <target state="translated">Um padrão é esperado após este ponto</target>
         <note />
       </trans-unit>
       <trans-unit id="parsExpectingExpressionInTuple">
@@ -659,17 +719,17 @@
       </trans-unit>
       <trans-unit id="parsExpectingPatternInTuple">
         <source>Expecting pattern</source>
-        <target state="new">Expecting pattern</target>
+        <target state="translated">Padrão esperado</target>
         <note />
       </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
         <source>Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</source>
-        <target state="new">Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</target>
+        <target state="translated">Literal de caractere incompleto (exemplo: 'Q') ou invocação de tipo qualificado (exemplo: 'T.Name)</target>
         <note />
       </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr2">
         <source>Incomplete operator expression (example a^b) or qualified type invocation (example: ^T.Name)</source>
-        <target state="new">Incomplete operator expression (example a^b) or qualified type invocation (example: ^T.Name)</target>
+        <target state="translated">Expressão de operador incompleta (exemplo a^b) ou invocação de tipo qualificado (exemplo: ^T.Name)</target>
         <note />
       </trans-unit>
       <trans-unit id="parsNewExprMemberAccess">
@@ -849,7 +909,7 @@
       </trans-unit>
       <trans-unit id="tcInitOnlyPropertyCannotBeSet1">
         <source>Init-only property '{0}' cannot be set outside the initialization code. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</source>
-        <target state="new">Init-only property '{0}' cannot be set outside the initialization code. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
+        <target state="translated">A propriedade somente inicialização '{0}' não pode ser definida fora do código de inicialização. Confira https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
         <note />
       </trans-unit>
       <trans-unit id="tcInlineIfLambdaUsedOnNonInlineFunctionOrMethod">
@@ -879,7 +939,7 @@
       </trans-unit>
       <trans-unit id="tcInvalidSelfConstraint">
         <source>Invalid constraint. Valid constraint forms include \"'T :&gt; ISomeInterface\" for interface constraints and \"SomeConstrainingType&lt;'T&gt;\" for self-constraints. See https://aka.ms/fsharp-type-constraints.</source>
-        <target state="new">Invalid constraint. Valid constraint forms include \"'T :&gt; ISomeInterface\" for interface constraints and \"SomeConstrainingType&lt;'T&gt;\" for self-constraints. See https://aka.ms/fsharp-type-constraints.</target>
+        <target state="translated">Restrição inválida. Os formulários de restrição válidos incluem \"'T :&gt; ISomeInterface\" para restrições de interface e \"SomeConstrainingType&lt;'T&gt;\" para auto-restrições. Confira https://aka.ms/fsharp-type-constraints.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcInvalidStructReturn">
@@ -924,7 +984,7 @@
       </trans-unit>
       <trans-unit id="tcMissingRequiredMembers">
         <source>The following required properties have to be initalized:{0}</source>
-        <target state="new">The following required properties have to be initalized:{0}</target>
+        <target state="translated">As seguintes propriedades necessárias precisam ser inicializadas:{0}</target>
         <note />
       </trans-unit>
       <trans-unit id="tcNoEagerConstraintApplicationAttribute">
@@ -1009,7 +1069,7 @@
       </trans-unit>
       <trans-unit id="tcSetterForInitOnlyPropertyCannotBeCalled1">
         <source>Cannot call '{0}' - a setter for init-only property, please use object initialization instead. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</source>
-        <target state="new">Cannot call '{0}' - a setter for init-only property, please use object initialization instead. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
+        <target state="translated">Não é possível chamar '{0}' – um setter da propriedade somente inicialização, use a inicialização de objeto. Confira https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
         <note />
       </trans-unit>
       <trans-unit id="tcSubsumptionImplicitConversionUsed">
@@ -1019,32 +1079,32 @@
       </trans-unit>
       <trans-unit id="tcSynTypeOrInvalidInDeclaration">
         <source>SynType.Or is not permitted in this declaration</source>
-        <target state="new">SynType.Or is not permitted in this declaration</target>
+        <target state="translated">SynType.Or não é permitido nesta declaração</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitHasMultipleSupportTypes">
         <source>The trait '{0}' invoked by this call has multiple support types. This invocation syntax is not permitted for such traits. See https://aka.ms/fsharp-srtp for guidance.</source>
-        <target state="new">The trait '{0}' invoked by this call has multiple support types. This invocation syntax is not permitted for such traits. See https://aka.ms/fsharp-srtp for guidance.</target>
+        <target state="translated">A característica '{0}' invocada por essa chamada tem vários tipos de suporte. Essa sintaxe de invocação não é permitida para essas características. Confira https://aka.ms/fsharp-srtp para obter as diretrizes.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitInvocationShouldUseTick">
         <source>Invocation of a static constraint should use \"'T.Ident\" and not \"^T.Ident\", even for statically resolved type parameters.</source>
-        <target state="new">Invocation of a static constraint should use \"'T.Ident\" and not \"^T.Ident\", even for statically resolved type parameters.</target>
+        <target state="translated">A invocação de uma restrição estática deve usar \"'T.Ident\" e não \"^T.Ident\", mesmo para parâmetros de tipo resolvidos estaticamente.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitIsNotStatic">
         <source>Trait '{0}' is not static</source>
-        <target state="new">Trait '{0}' is not static</target>
+        <target state="translated">A característica '{0}' não é estática</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitIsStatic">
         <source>Trait '{0}' is static</source>
-        <target state="new">Trait '{0}' is static</target>
+        <target state="translated">A característica '{0}' é estática</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitMayNotUseComplexThings">
         <source>A trait may not specify optional, in, out, ParamArray, CallerInfo or Quote arguments</source>
-        <target state="new">A trait may not specify optional, in, out, ParamArray, CallerInfo or Quote arguments</target>
+        <target state="translated">Uma característica não pode especificar os argumentos optional, in, out, ParamArray, CallerInfo ou Quote</target>
         <note />
       </trans-unit>
       <trans-unit id="tcUnableToParseInterpolatedString">
@@ -1054,12 +1114,12 @@
       </trans-unit>
       <trans-unit id="tcUsingInterfaceWithStaticAbstractMethodAsType">
         <source>'{0}' is normally used as a type constraint in generic code, e.g. \"'T when ISomeInterface&lt;'T&gt;\" or \"let f (x: #ISomeInterface&lt;_&gt;)\". See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3536\"' or '--nowarn:3536'.</source>
-        <target state="new">'{0}' is normally used as a type constraint in generic code, e.g. \"'T when ISomeInterface&lt;'T&gt;\" or \"let f (x: #ISomeInterface&lt;_&gt;)\". See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3536\"' or '--nowarn:3536'.</target>
+        <target state="translated">'{0}' normalmente é usado como uma restrição de tipo em código genérico, por exemplo, \"'T when ISomeInterface&lt;'T&gt;\" ou \"let f (x: #ISomeInterface&lt;_&gt;)\". Confira https://aka.ms/fsharp-iwsams para obter as diretrizes. Você pode desabilitar este aviso usando '#nowarn \"3536\"' ou '--nowarn:3536'.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcUsingInterfacesWithStaticAbstractMethods">
         <source>Declaring \"interfaces with static abstract methods\" is an advanced feature. See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3535\"' or '--nowarn:3535'.</source>
-        <target state="new">Declaring \"interfaces with static abstract methods\" is an advanced feature. See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3535\"' or '--nowarn:3535'.</target>
+        <target state="translated">Declarando \"interfaces com métodos abstratos estáticos\" é um recurso avançado. Consulte https://aka.ms/fsharp-iwsams para obter diretrizes. Você pode desabilitar esse aviso usando '#nowarn \"3535\"' ou '--nowarn:3535'.</target>
         <note />
       </trans-unit>
       <trans-unit id="typrelInterfaceMemberNoMostSpecificImplementation">
@@ -3849,7 +3909,7 @@
       </trans-unit>
       <trans-unit id="tcUnionCaseExpectsTupledArguments">
         <source>This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</source>
-        <target state="new">This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</target>
+        <target state="translated">Este caso união espera {0} argumentos em formato de tupla, mas recebeu {1}. Os argumentos de campo ausente pode ser:{2}</target>
         <note />
       </trans-unit>
       <trans-unit id="tcFieldIsNotStatic">
@@ -7529,7 +7589,7 @@
       </trans-unit>
       <trans-unit id="tcStructUnionMultiCaseDistinctFields">
         <source>If a multicase union type is a struct, then all union cases must have unique names. For example: 'type A = B of b: int | C of c: int'.</source>
-        <target state="needs-review-translation">Se um tipo de união tiver mais de um caso e for struct, então todos os campos dentro do tipo de união deverão ter nomes exclusivos.</target>
+        <target state="translated">Se um tipo de união multicase for um struct, todos os casos união deverão ter nomes exclusivos. Por exemplo: tipo A = B de b: int | C de c: int'.</target>
         <note />
       </trans-unit>
       <trans-unit id="CallerMemberNameIsOverriden">
diff --git a/src/Compiler/xlf/FSComp.txt.ru.xlf b/src/Compiler/xlf/FSComp.txt.ru.xlf
index 9fd17e474e3..29827955000 100644
--- a/src/Compiler/xlf/FSComp.txt.ru.xlf
+++ b/src/Compiler/xlf/FSComp.txt.ru.xlf
@@ -4,7 +4,12 @@
     <body>
       <trans-unit id="arrayElementHasWrongTypeTuple">
         <source>All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Все элементы массива должны поддерживать неявное преобразование в тип первого элемента, который здесь является кортежем длиной {0} типа\n    {1}    \nЭтот элемент является кортежем длиной {2} типа\n    {3}    \n</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="buildDuplicateFile">
+        <source>The source file '{0}' (at position {1}/{2}) already appeared in the compilation list (at position {3}/{4}). Please verify that it is included only once in the project file.</source>
+        <target state="translated">Исходный файл "{0}" (в позиции {1}/{2}) уже присутствует в списке компиляции (в позиции {3}/{4}). Убедитесь, что он включен в файл проекта только один раз.</target>
         <note />
       </trans-unit>
       <trans-unit id="buildInvalidSourceFileExtensionML">
@@ -17,9 +22,29 @@
         <target state="translated">Расширение файла "{0}" не распознано. Исходные файлы должны иметь расширения FS, FSI, FSX или FSSCRIPT</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkAbstractMembersDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkAdditionalConstructorOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Additional constructor is not allowed.</source>
+        <target state="translated">Если тип использует атрибуты [&lt;Sealed&gt;] и [&lt;AbstractClass&gt;], это означает, что он статический. Дополнительный конструктор не разрешен.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkConstructorWithArgumentsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Constructor with arguments is not allowed.</source>
+        <target state="translated">Если тип использует атрибуты [&lt;Sealed&gt;] и [&lt;AbstractClass&gt;], это означает, что он статический. Конструктор с аргументами не разрешен.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkDuplicatedMethodParameter">
         <source>Duplicate parameter. The parameter '{0}' has been used more that once in this method.</source>
-        <target state="new">Duplicate parameter. The parameter '{0}' has been used more that once in this method.</target>
+        <target state="translated">Повторяющийся параметр. Параметр "{0}" использовался в этом методе несколько раз.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkExplicitFieldsDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</target>
         <note />
       </trans-unit>
       <trans-unit id="chkFeatureNotLanguageSupported">
@@ -37,6 +62,11 @@
         <target state="translated">Компоненту "{0}" требуется библиотека F# для языка версии {1} или более поздней.</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkImplementingInterfacesOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkInfoRefcellAssign">
         <source>The use of ':=' from the F# library is deprecated. See https://aka.ms/fsharp-refcell-ops. For example, please change 'cell := expr' to 'cell.Value &lt;- expr'.</source>
         <target state="translated">Использование ":=" из библиотеки F# является нерекомендуемым. См. https://aka.ms/fsharp-refcell-ops. Например, замените "cell := expr" на "cell.Value &lt;- expr".</target>
@@ -57,6 +87,16 @@
         <target state="translated">Использование "incr" из библиотеки F# является нерекомендуемым. См. https://aka.ms/fsharp-refcell-ops. Например, замените "incr cell" на "cell.Value &lt;- cell.Value + 1".</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkInstanceLetBindingOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkInstanceMemberOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance members are not allowed.</source>
+        <target state="translated">Если тип использует атрибуты [&lt;Sealed&gt;] и [&lt;AbstractClass&gt;], это означает, что он статический. Элементы экземпляра не разрешены.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="containerDeprecated">
         <source>The 'AssemblyKeyNameAttribute' has been deprecated. Use 'AssemblyKeyFileAttribute' instead.</source>
         <target state="translated">Атрибут "AssemblyKeyNameAttribute" является устаревшим. Используйте вместо него атрибут "AssemblyKeyFileAttribute".</target>
@@ -114,7 +154,7 @@
       </trans-unit>
       <trans-unit id="elseBranchHasWrongTypeTuple">
         <source>All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Все ветви выражения "if" должны возвращать значения, поддерживающие неявное преобразование в тип первой ветви, которым здесь является кортеж длиной {0} типа\n    {1}    \nЭта ветвь возвращает кортеж длиной {2} типа\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="etProviderHasDesignerAssemblyDependency">
@@ -142,6 +182,11 @@
         <target state="translated">применимые вычислительные выражения</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureArithmeticInLiterals">
+        <source>Allow arithmetic and logical operations in literals</source>
+        <target state="translated">Разрешить арифметические и логические операции в литералах</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureAttributesToRightOfModuleKeyword">
         <source>attributes to the right of the 'module' keyword</source>
         <target state="translated">атрибуты справа от ключевого слова "module"</target>
@@ -154,7 +199,7 @@
       </trans-unit>
       <trans-unit id="featureCSharpExtensionAttributeNotRequired">
         <source>Allow implicit Extension attribute on declaring types, modules</source>
-        <target state="new">Allow implicit Extension attribute on declaring types, modules</target>
+        <target state="translated">Разрешить атрибут неявного расширения для объявляющих типов, модулей</target>
         <note />
       </trans-unit>
       <trans-unit id="featureDefaultInterfaceMemberConsumption">
@@ -179,7 +224,7 @@
       </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
-        <target state="new">Raises errors for non-virtual members overrides</target>
+        <target state="translated">Вызывает ошибки при переопределениях невиртуальных элементов</target>
         <note />
       </trans-unit>
       <trans-unit id="featureErrorOnDeprecatedRequireQualifiedAccess">
@@ -187,6 +232,16 @@
         <target state="translated">выдать ошибку при устаревшем доступе к конструкции с атрибутом RequireQualifiedAccess</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureErrorReportingOnStaticClasses">
+        <source>Error reporting on static classes</source>
+        <target state="translated">Отчеты об ошибках для статических классов</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="featureEscapeBracesInFormattableString">
+        <source>Escapes curly braces before calling FormattableStringFactory.Create when interpolated string literal is typed as FormattableString</source>
+        <target state="translated">Экранирует фигурные скобки перед вызовом FormattableStringFactory.Create, когда интерполированный строковый литерал введен как FormattableString</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureExpandedMeasurables">
         <source>more types support units of measure</source>
         <target state="translated">другие типы поддерживают единицы измерения</target>
@@ -214,12 +269,12 @@
       </trans-unit>
       <trans-unit id="featureInitProperties">
         <source>support for consuming init properties</source>
-        <target state="new">support for consuming init properties</target>
+        <target state="translated">поддержка использования свойств инициализации</target>
         <note />
       </trans-unit>
       <trans-unit id="featureInterfacesWithAbstractStaticMembers">
         <source>static abstract interface members</source>
-        <target state="new">static abstract interface members</target>
+        <target state="translated">статические абстрактные элементы интерфейса</target>
         <note />
       </trans-unit>
       <trans-unit id="featureInterfacesWithMultipleGenericInstantiation">
@@ -229,7 +284,7 @@
       </trans-unit>
       <trans-unit id="featureLowercaseDUWhenRequireQualifiedAccess">
         <source>Allow lowercase DU when RequireQualifiedAccess attribute</source>
-        <target state="new">Allow lowercase DU when RequireQualifiedAccess attribute</target>
+        <target state="translated">Разрешить du в нижнем регистре, если атрибут RequireQualifiedAccess</target>
         <note />
       </trans-unit>
       <trans-unit id="featureMLCompatRevisions">
@@ -239,7 +294,7 @@
       </trans-unit>
       <trans-unit id="featureMatchNotAllowedForUnionCaseWithNoData">
         <source>Pattern match discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern match discard is not allowed for union case that takes no data.</target>
+        <target state="translated">Отмена сопоставления с шаблоном не разрешена для случая объединения, не принимающего данные.</target>
         <note />
       </trans-unit>
       <trans-unit id="featureNameOf">
@@ -299,7 +354,7 @@
       </trans-unit>
       <trans-unit id="featureRequiredProperties">
         <source>support for required properties</source>
-        <target state="new">support for required properties</target>
+        <target state="translated">поддержка обязательных свойств</target>
         <note />
       </trans-unit>
       <trans-unit id="featureResumableStateMachines">
@@ -309,7 +364,7 @@
       </trans-unit>
       <trans-unit id="featureSelfTypeConstraints">
         <source>self type constraints</source>
-        <target state="new">self type constraints</target>
+        <target state="translated">ограничения самостоятельного типа</target>
         <note />
       </trans-unit>
       <trans-unit id="featureSingleUnderscorePattern">
@@ -327,6 +382,11 @@
         <target state="translated">представление структуры для активных шаблонов</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureWarningWhenInliningMethodImplNoInlineMarkedFunction">
+        <source>Raises warnings when 'let inline ... =' is used together with [&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;] attribute. Function is not getting inlined.</source>
+        <target state="translated">Выдает предупреждения, когда используется параметр "let inline ... =" вместе с атрибутом [&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;]. Функция не встраивается.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureWildCardInForLoop">
         <source>wild card in for loop</source>
         <target state="translated">подстановочный знак в цикле for</target>
@@ -339,7 +399,7 @@
       </trans-unit>
       <trans-unit id="followingPatternMatchClauseHasWrongTypeTuple">
         <source>All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Все ветви выражения сопоставления с шаблоном должны возвращать значения, поддерживающие неявное преобразование в тип первой ветви, которым здесь является кортеж длиной {0} типа\n    {1}    \nЭта ветвь возвращает кортеж длиной {2} типа\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="forFormatInvalidForInterpolated">
@@ -364,7 +424,7 @@
       </trans-unit>
       <trans-unit id="forPercentAInReflectionFreeCode">
         <source>The '%A' format specifier may not be used in an assembly being compiled with option '--reflectionfree'. This construct implicitly uses reflection.</source>
-        <target state="new">The '%A' format specifier may not be used in an assembly being compiled with option '--reflectionfree'. This construct implicitly uses reflection.</target>
+        <target state="translated">Определитель формата "%A" нельзя использовать в сборке, компилируемой с параметром "--reflectionfree". Эта конструкция неявно использует отражение.</target>
         <note />
       </trans-unit>
       <trans-unit id="formatDashItem">
@@ -384,7 +444,7 @@
       </trans-unit>
       <trans-unit id="ifExpressionTuple">
         <source>The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Выражение "if" должно возвращать кортеж длиной {0} типа\n    {1}    \nдля соответствия требованиям к типу контекста. В настоящее время возвращается кортеж длиной {2} типа\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="ilxGenUnknownDebugPoint">
@@ -409,7 +469,7 @@
       </trans-unit>
       <trans-unit id="keywordDescriptionAnd">
         <source>Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</source>
-        <target state="new">Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</target>
+        <target state="translated">Используется во взаимно рекурсивных привязках, объявлениях свойств и с несколькими ограничениями для универсальных параметров.</target>
         <note />
       </trans-unit>
       <trans-unit id="keywordDescriptionConst">
@@ -419,7 +479,7 @@
       </trans-unit>
       <trans-unit id="keywordDescriptionTypeTest">
         <source>Used to check if an object is of the given type in a pattern or binding.</source>
-        <target state="new">Used to check if an object is of the given type in a pattern or binding.</target>
+        <target state="translated">Используется для проверки принадлежности объекта заданному типу в шаблоне или привязке.</target>
         <note />
       </trans-unit>
       <trans-unit id="lexByteStringMayNotBeInterpolated">
@@ -449,12 +509,12 @@
       </trans-unit>
       <trans-unit id="listElementHasWrongTypeTuple">
         <source>All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Все элементы списка должны поддерживать неявное преобразование в тип первого элемента, который здесь является кортежем длиной {0} типа\n    {1}    \nЭтот элемент является кортежем длиной {2} типа\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="matchNotAllowedForUnionCaseWithNoData">
         <source>Pattern discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern discard is not allowed for union case that takes no data.</target>
+        <target state="translated">Отмена шаблона не разрешена для случая объединения, не принимающего данные.</target>
         <note />
       </trans-unit>
       <trans-unit id="mlCompatError">
@@ -529,17 +589,17 @@
       </trans-unit>
       <trans-unit id="optsCompressMetadata">
         <source>Compress interface and optimization data files</source>
-        <target state="new">Compress interface and optimization data files</target>
+        <target state="translated">Сжатие файлов данных интерфейса и оптимизации</target>
         <note />
       </trans-unit>
       <trans-unit id="optsGetLangVersions">
         <source>Display the allowed values for language version.</source>
-        <target state="new">Display the allowed values for language version.</target>
+        <target state="translated">Отображение допустимых значений для версии языка.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsInvalidRefAssembly">
         <source>Invalid use of emitting a reference assembly, do not use '--standalone or --staticlink' with '--refonly or --refout'.</source>
-        <target state="needs-review-translation">Недопустимое использование при создании базовой сборки. Не используйте "--staticlink" или "--refonly" и "--refout" вместе.</target>
+        <target state="translated">Недопустимое использование при создании базовой сборки. Не используйте "--standalone or --staticlink" с "--refonly or --refout".</target>
         <note />
       </trans-unit>
       <trans-unit id="optsInvalidRefOut">
@@ -549,12 +609,12 @@
       </trans-unit>
       <trans-unit id="optsOptimizationData">
         <source>Specify included optimization information, the default is file. Important for distributed libraries.</source>
-        <target state="new">Specify included optimization information, the default is file. Important for distributed libraries.</target>
+        <target state="translated">Укажите включенные сведения об оптимизации, по умолчанию это файл. Необходимо для распределенных библиотек.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsPdbMatchesOutputFileName">
         <source>The pdb output file name cannot match the build output filename use --pdb:filename.pdb</source>
-        <target state="new">The pdb output file name cannot match the build output filename use --pdb:filename.pdb</target>
+        <target state="translated">Имя выходного файла pdb не может совпадать с именем выходного файла сборки. Используйте --pdb:filename.pdb</target>
         <note />
       </trans-unit>
       <trans-unit id="optsRefOnly">
@@ -569,17 +629,17 @@
       </trans-unit>
       <trans-unit id="optsReflectionFree">
         <source>Disable implicit generation of constructs using reflection</source>
-        <target state="new">Disable implicit generation of constructs using reflection</target>
+        <target state="translated">Отключить неявное создание конструкций с помощью отражения</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSetLangVersion">
         <source>Specify language version such as 'latest' or 'preview'.</source>
-        <target state="new">Specify language version such as 'latest' or 'preview'.</target>
+        <target state="translated">Укажите версию языка, например "новейшая" или "предварительная версия".</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSignatureData">
         <source>Include F# interface information, the default is file. Essential for distributing libraries.</source>
-        <target state="new">Include F# interface information, the default is file. Essential for distributing libraries.</target>
+        <target state="translated">Включить сведения об интерфейсе F#, по умолчанию используется файл. Необходимо для распространения библиотек.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSupportedLangVersions">
@@ -589,12 +649,12 @@
       </trans-unit>
       <trans-unit id="optsUnknownOptimizationData">
         <source>Invalid value '{0}' for --optimizationdata, valid value are: none, file, compress.</source>
-        <target state="new">Invalid value '{0}' for --optimizationdata, valid value are: none, file, compress.</target>
+        <target state="translated">Недопустимое значение "{0}" для --optimizationdata. Допустимые значения: none, file, compress.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsUnknownSignatureData">
         <source>Invalid value '{0}' for --interfacedata, valid value are: none, file, compress.</source>
-        <target state="new">Invalid value '{0}' for --interfacedata, valid value are: none, file, compress.</target>
+        <target state="translated">Недопустимое значение "{0}" для --interfacedata. Допустимые значения: none, file, compress.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsUnrecognizedLanguageVersion">
@@ -649,7 +709,7 @@
       </trans-unit>
       <trans-unit id="parsExpectedPatternAfterToken">
         <source>Expected a pattern after this point</source>
-        <target state="new">Expected a pattern after this point</target>
+        <target state="translated">После этой точки ожидался шаблон</target>
         <note />
       </trans-unit>
       <trans-unit id="parsExpectingExpressionInTuple">
@@ -659,17 +719,17 @@
       </trans-unit>
       <trans-unit id="parsExpectingPatternInTuple">
         <source>Expecting pattern</source>
-        <target state="new">Expecting pattern</target>
+        <target state="translated">Ожидается шаблон</target>
         <note />
       </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
         <source>Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</source>
-        <target state="new">Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</target>
+        <target state="translated">Неполный символьный литерал (например: "Q") или вызов квалифицированного типа (например: "T.Name)</target>
         <note />
       </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr2">
         <source>Incomplete operator expression (example a^b) or qualified type invocation (example: ^T.Name)</source>
-        <target state="new">Incomplete operator expression (example a^b) or qualified type invocation (example: ^T.Name)</target>
+        <target state="translated">Неполное выражение оператора (например, a^b) или вызов квалифицированного типа (например, ^T.Name)</target>
         <note />
       </trans-unit>
       <trans-unit id="parsNewExprMemberAccess">
@@ -849,7 +909,7 @@
       </trans-unit>
       <trans-unit id="tcInitOnlyPropertyCannotBeSet1">
         <source>Init-only property '{0}' cannot be set outside the initialization code. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</source>
-        <target state="new">Init-only property '{0}' cannot be set outside the initialization code. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
+        <target state="translated">Свойство только для инициализации "{0}" невозможно установить за пределами кода инициализации. См. https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
         <note />
       </trans-unit>
       <trans-unit id="tcInlineIfLambdaUsedOnNonInlineFunctionOrMethod">
@@ -879,7 +939,7 @@
       </trans-unit>
       <trans-unit id="tcInvalidSelfConstraint">
         <source>Invalid constraint. Valid constraint forms include \"'T :&gt; ISomeInterface\" for interface constraints and \"SomeConstrainingType&lt;'T&gt;\" for self-constraints. See https://aka.ms/fsharp-type-constraints.</source>
-        <target state="new">Invalid constraint. Valid constraint forms include \"'T :&gt; ISomeInterface\" for interface constraints and \"SomeConstrainingType&lt;'T&gt;\" for self-constraints. See https://aka.ms/fsharp-type-constraints.</target>
+        <target state="translated">Недопустимое ограничение. Допустимые формы ограничения включают \"'T:&gt; ISomeInterface\" для ограничений интерфейса и \"SomeConstrainingType&lt;'T&gt;\" для собственных ограничений. См. https://aka.ms/fsharp-type-constraints.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcInvalidStructReturn">
@@ -924,7 +984,7 @@
       </trans-unit>
       <trans-unit id="tcMissingRequiredMembers">
         <source>The following required properties have to be initalized:{0}</source>
-        <target state="new">The following required properties have to be initalized:{0}</target>
+        <target state="translated">Необходимо инициализировать следующие обязательные свойства:{0}</target>
         <note />
       </trans-unit>
       <trans-unit id="tcNoEagerConstraintApplicationAttribute">
@@ -1009,7 +1069,7 @@
       </trans-unit>
       <trans-unit id="tcSetterForInitOnlyPropertyCannotBeCalled1">
         <source>Cannot call '{0}' - a setter for init-only property, please use object initialization instead. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</source>
-        <target state="new">Cannot call '{0}' - a setter for init-only property, please use object initialization instead. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
+        <target state="translated">Не удается вызвать '{0}' — установщик для свойства только для инициализации, вместо этого используйте инициализацию объекта. См. https://aka.ms/fsharp-assigning-values-to-properties-at-initialization.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcSubsumptionImplicitConversionUsed">
@@ -1019,32 +1079,32 @@
       </trans-unit>
       <trans-unit id="tcSynTypeOrInvalidInDeclaration">
         <source>SynType.Or is not permitted in this declaration</source>
-        <target state="new">SynType.Or is not permitted in this declaration</target>
+        <target state="translated">SynType.Or не допускается в этом объявлении</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitHasMultipleSupportTypes">
         <source>The trait '{0}' invoked by this call has multiple support types. This invocation syntax is not permitted for such traits. See https://aka.ms/fsharp-srtp for guidance.</source>
-        <target state="new">The trait '{0}' invoked by this call has multiple support types. This invocation syntax is not permitted for such traits. See https://aka.ms/fsharp-srtp for guidance.</target>
+        <target state="translated">Признак "{0}", вызываемый этим звонком, имеет несколько типов поддержки. Этот синтаксис вызова не разрешен для таких признаков. См. руководство на https://aka.ms/fsharp-srtp.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitInvocationShouldUseTick">
         <source>Invocation of a static constraint should use \"'T.Ident\" and not \"^T.Ident\", even for statically resolved type parameters.</source>
-        <target state="new">Invocation of a static constraint should use \"'T.Ident\" and not \"^T.Ident\", even for statically resolved type parameters.</target>
+        <target state="translated">Вызов статического ограничения должен использовать \"'T.Ident\", а не \"^T.Ident\", даже для статически разрешенных параметров типа.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitIsNotStatic">
         <source>Trait '{0}' is not static</source>
-        <target state="new">Trait '{0}' is not static</target>
+        <target state="translated">Признак "{0}" не является статическим</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitIsStatic">
         <source>Trait '{0}' is static</source>
-        <target state="new">Trait '{0}' is static</target>
+        <target state="translated">Признак "{0}" является статическим</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitMayNotUseComplexThings">
         <source>A trait may not specify optional, in, out, ParamArray, CallerInfo or Quote arguments</source>
-        <target state="new">A trait may not specify optional, in, out, ParamArray, CallerInfo or Quote arguments</target>
+        <target state="translated">Признак не может указывать необязательные аргументы in, out, ParamArray, CallerInfo или Quote</target>
         <note />
       </trans-unit>
       <trans-unit id="tcUnableToParseInterpolatedString">
@@ -1054,12 +1114,12 @@
       </trans-unit>
       <trans-unit id="tcUsingInterfaceWithStaticAbstractMethodAsType">
         <source>'{0}' is normally used as a type constraint in generic code, e.g. \"'T when ISomeInterface&lt;'T&gt;\" or \"let f (x: #ISomeInterface&lt;_&gt;)\". See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3536\"' or '--nowarn:3536'.</source>
-        <target state="new">'{0}' is normally used as a type constraint in generic code, e.g. \"'T when ISomeInterface&lt;'T&gt;\" or \"let f (x: #ISomeInterface&lt;_&gt;)\". See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3536\"' or '--nowarn:3536'.</target>
+        <target state="translated">"{0}" обычно используется в качестве ограничения типа в универсальном коде, например \"'T when ISomeInterface&lt;"T&gt;\" или \"let f (x: #ISomeInterface&lt;_&gt;)\". См. руководство на https://aka.ms/fsharp-iwsams. Это предупреждение можно отключить с помощью "#nowarn \"3536\"" или "--nowarn:3536".</target>
         <note />
       </trans-unit>
       <trans-unit id="tcUsingInterfacesWithStaticAbstractMethods">
         <source>Declaring \"interfaces with static abstract methods\" is an advanced feature. See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3535\"' or '--nowarn:3535'.</source>
-        <target state="new">Declaring \"interfaces with static abstract methods\" is an advanced feature. See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3535\"' or '--nowarn:3535'.</target>
+        <target state="translated">Объявление \"интерфейсов со статическими абстрактными методами\" является расширенной функцией. См. руководство на https://aka.ms/fsharp-iwsams. Это предупреждение можно отключить с помощью используя "#nowarn \"3535\"" or "--nowarn:3535".</target>
         <note />
       </trans-unit>
       <trans-unit id="typrelInterfaceMemberNoMostSpecificImplementation">
@@ -3849,7 +3909,7 @@
       </trans-unit>
       <trans-unit id="tcUnionCaseExpectsTupledArguments">
         <source>This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</source>
-        <target state="new">This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</target>
+        <target state="translated">Этот вариант объединения ожидает аргументы {0} в форме кортежа, но было предоставлено: {1}. Отсутствующие аргументы поля могут быть любыми из следующих: {2}</target>
         <note />
       </trans-unit>
       <trans-unit id="tcFieldIsNotStatic">
@@ -7529,7 +7589,7 @@
       </trans-unit>
       <trans-unit id="tcStructUnionMultiCaseDistinctFields">
         <source>If a multicase union type is a struct, then all union cases must have unique names. For example: 'type A = B of b: int | C of c: int'.</source>
-        <target state="needs-review-translation">Если тип объединения имеет более одного варианта и является структурой, всем полям в типе объединения необходимо присвоить уникальные имена.</target>
+        <target state="translated">Если тип объединения с несколькими регистрами является структурой, все случаи объединения должны иметь уникальные имена. Например: "type A = B of b: int | C of c: int".</target>
         <note />
       </trans-unit>
       <trans-unit id="CallerMemberNameIsOverriden">
diff --git a/src/Compiler/xlf/FSComp.txt.tr.xlf b/src/Compiler/xlf/FSComp.txt.tr.xlf
index 467e88ffe74..3f3bb5dee68 100644
--- a/src/Compiler/xlf/FSComp.txt.tr.xlf
+++ b/src/Compiler/xlf/FSComp.txt.tr.xlf
@@ -4,7 +4,12 @@
     <body>
       <trans-unit id="arrayElementHasWrongTypeTuple">
         <source>All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Bir dizinin tüm öğeleri örtük olarak ilk öğenin türüne dönüştürülebilir olmalıdır. Burada ilk öğe {0} uzunluğunda türü\n {1} \nolan bir demet. Bu öğe ise {2} uzunluğunda türü\n {3} \nolan bir demet.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="buildDuplicateFile">
+        <source>The source file '{0}' (at position {1}/{2}) already appeared in the compilation list (at position {3}/{4}). Please verify that it is included only once in the project file.</source>
+        <target state="translated">Kaynak dosya '{0}' ({1}/{2} konumunda) derleme listesinde ({3}/{4} konumunda) zaten göründü. Lütfen proje dosyasına yalnızca bir kez eklendiğinden emin olun.</target>
         <note />
       </trans-unit>
       <trans-unit id="buildInvalidSourceFileExtensionML">
@@ -17,9 +22,29 @@
         <target state="translated">'{0}' kaynak dosyasının dosya uzantısı tanınmadı. Kaynak dosyaların uzantısı .fs, .fsi, .fsx veya .fsscript olmalıdır.</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkAbstractMembersDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkAdditionalConstructorOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Additional constructor is not allowed.</source>
+        <target state="translated">Bir tür, hem [&lt;Sealed&gt;] hem de [&lt; AbstractClass&gt;] özniteliklerini kullanıyorsa bu statik olduğu anlamına gelir. Ek oluşturucuya izin verilmez.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkConstructorWithArgumentsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Constructor with arguments is not allowed.</source>
+        <target state="translated">Bir tür, hem [&lt;Sealed&gt;] hem de [&lt; AbstractClass&gt;] özniteliklerini kullanıyorsa bu statik olduğu anlamına gelir.Bağımsız değişkenlere sahip oluşturucuya izin verilmez.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkDuplicatedMethodParameter">
         <source>Duplicate parameter. The parameter '{0}' has been used more that once in this method.</source>
-        <target state="new">Duplicate parameter. The parameter '{0}' has been used more that once in this method.</target>
+        <target state="translated">Yinelenen parametre. '{0}' parametresi bu metotta bir kereden fazla kullanıldı.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkExplicitFieldsDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</target>
         <note />
       </trans-unit>
       <trans-unit id="chkFeatureNotLanguageSupported">
@@ -37,6 +62,11 @@
         <target state="translated">'{0}' özelliği için F# kitaplığının {1} veya üstü dil sürümü gerekir.</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkImplementingInterfacesOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkInfoRefcellAssign">
         <source>The use of ':=' from the F# library is deprecated. See https://aka.ms/fsharp-refcell-ops. For example, please change 'cell := expr' to 'cell.Value &lt;- expr'.</source>
         <target state="translated">F# kitaplığından gelen ':=' kullanımı kullanım dışı. https://aka.ms/fsharp-refcell-ops’a bakın. Örneğin, lütfen 'cell := expr' ifadesini 'cell.Value &lt;- expr' olarak değiştirin.</target>
@@ -57,6 +87,16 @@
         <target state="translated">F# kitaplığından gelen 'incr' kullanımı kullanım dışı. https://aka.ms/fsharp-refcell-ops’a bakın. Örneğin, lütfen 'incr cell' ifadesini 'cell.Value &lt;- cell.Value + 1' olarak değiştirin.</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkInstanceLetBindingOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkInstanceMemberOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance members are not allowed.</source>
+        <target state="translated">Bir tür, hem [&lt;Sealed&gt;] hem de [&lt; AbstractClass&gt;] özniteliklerini kullanıyorsa bu statik olduğu anlamına gelir. Örnek üyelerine izin verilmez.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="containerDeprecated">
         <source>The 'AssemblyKeyNameAttribute' has been deprecated. Use 'AssemblyKeyFileAttribute' instead.</source>
         <target state="translated">'AssemblyKeyNameAttribute' kullanım dışı bırakıldı. Bunun yerine 'AssemblyKeyFileAttribute' kullanın.</target>
@@ -114,7 +154,7 @@
       </trans-unit>
       <trans-unit id="elseBranchHasWrongTypeTuple">
         <source>All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Bir 'if' ifadesinin tüm dalları, örtük olarak ilk dalın türüne dönüştürülebilir değerler döndürmelidir. Burada ilk dal {0} uzunluğunda türü\n    {1} olan bir demet    \nBu dal {2} uzunluğunda türü\n    {3}    \nolan bir demet döndürüyor</target>
         <note />
       </trans-unit>
       <trans-unit id="etProviderHasDesignerAssemblyDependency">
@@ -142,6 +182,11 @@
         <target state="translated">uygulama hesaplama ifadeleri</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureArithmeticInLiterals">
+        <source>Allow arithmetic and logical operations in literals</source>
+        <target state="translated">Sabit değerlerle aritmetik ve mantıksal işlemlere izin ver</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureAttributesToRightOfModuleKeyword">
         <source>attributes to the right of the 'module' keyword</source>
         <target state="translated">'modül' anahtar sözcüğünün sağındaki öznitelikler</target>
@@ -154,7 +199,7 @@
       </trans-unit>
       <trans-unit id="featureCSharpExtensionAttributeNotRequired">
         <source>Allow implicit Extension attribute on declaring types, modules</source>
-        <target state="new">Allow implicit Extension attribute on declaring types, modules</target>
+        <target state="translated">Türler, modüller bildirirken örtük Extension özniteliğine izin ver</target>
         <note />
       </trans-unit>
       <trans-unit id="featureDefaultInterfaceMemberConsumption">
@@ -179,7 +224,7 @@
       </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
-        <target state="new">Raises errors for non-virtual members overrides</target>
+        <target state="translated">Sanal olmayan üyelerde geçersiz kılmalar için hatalar oluştur</target>
         <note />
       </trans-unit>
       <trans-unit id="featureErrorOnDeprecatedRequireQualifiedAccess">
@@ -187,6 +232,16 @@
         <target state="translated">RequireQualifiedAccess özniteliğine sahip yapının kullanım dışı erişiminde hata</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureErrorReportingOnStaticClasses">
+        <source>Error reporting on static classes</source>
+        <target state="translated">Statik sınıflarda hata bildirimi</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="featureEscapeBracesInFormattableString">
+        <source>Escapes curly braces before calling FormattableStringFactory.Create when interpolated string literal is typed as FormattableString</source>
+        <target state="translated">İçe eklenmiş dize sabit değerinin türü FormattableString olduğunda FormattableStringFactory.Create çağrılmadan önce küme ayraçlarını atlar</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureExpandedMeasurables">
         <source>more types support units of measure</source>
         <target state="translated">tür daha ölçü birimlerini destekler</target>
@@ -214,12 +269,12 @@
       </trans-unit>
       <trans-unit id="featureInitProperties">
         <source>support for consuming init properties</source>
-        <target state="new">support for consuming init properties</target>
+        <target state="translated">başlatma özelliklerini kullanma desteği</target>
         <note />
       </trans-unit>
       <trans-unit id="featureInterfacesWithAbstractStaticMembers">
         <source>static abstract interface members</source>
-        <target state="new">static abstract interface members</target>
+        <target state="translated">statik soyut arabirim üyeleri</target>
         <note />
       </trans-unit>
       <trans-unit id="featureInterfacesWithMultipleGenericInstantiation">
@@ -229,7 +284,7 @@
       </trans-unit>
       <trans-unit id="featureLowercaseDUWhenRequireQualifiedAccess">
         <source>Allow lowercase DU when RequireQualifiedAccess attribute</source>
-        <target state="new">Allow lowercase DU when RequireQualifiedAccess attribute</target>
+        <target state="translated">RequireQualifiedAccess özniteliğinde küçük harf DU'ya izin ver</target>
         <note />
       </trans-unit>
       <trans-unit id="featureMLCompatRevisions">
@@ -239,7 +294,7 @@
       </trans-unit>
       <trans-unit id="featureMatchNotAllowedForUnionCaseWithNoData">
         <source>Pattern match discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern match discard is not allowed for union case that takes no data.</target>
+        <target state="translated">Veri almayan birleşim durumu için desen eşleştirme atma kullanılamaz.</target>
         <note />
       </trans-unit>
       <trans-unit id="featureNameOf">
@@ -299,7 +354,7 @@
       </trans-unit>
       <trans-unit id="featureRequiredProperties">
         <source>support for required properties</source>
-        <target state="new">support for required properties</target>
+        <target state="translated">gerekli özellikler için destek</target>
         <note />
       </trans-unit>
       <trans-unit id="featureResumableStateMachines">
@@ -309,7 +364,7 @@
       </trans-unit>
       <trans-unit id="featureSelfTypeConstraints">
         <source>self type constraints</source>
-        <target state="new">self type constraints</target>
+        <target state="translated">kendi kendine tür kısıtlamaları</target>
         <note />
       </trans-unit>
       <trans-unit id="featureSingleUnderscorePattern">
@@ -327,6 +382,11 @@
         <target state="translated">etkin desenler için yapı gösterimi</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureWarningWhenInliningMethodImplNoInlineMarkedFunction">
+        <source>Raises warnings when 'let inline ... =' is used together with [&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;] attribute. Function is not getting inlined.</source>
+        <target state="translated">[&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;] özniteliği ile birlikte 'let inline ... =' kullanıldığında uyarı verir. İşlev satır içine alınmıyor.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureWildCardInForLoop">
         <source>wild card in for loop</source>
         <target state="translated">for döngüsünde joker karakter</target>
@@ -339,7 +399,7 @@
       </trans-unit>
       <trans-unit id="followingPatternMatchClauseHasWrongTypeTuple">
         <source>All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Bir desen eşleştirme ifadesinin tüm dalları, örtük olarak ilk dalın türüne dönüştürülebilir değerler döndürmelidir. Burada ilk dal {0} uzunluğunda türü\n    {1} olan bir demet    \nBu dal {2} uzunluğunda türü\n    {3}    \nolan bir demet döndürüyor</target>
         <note />
       </trans-unit>
       <trans-unit id="forFormatInvalidForInterpolated">
@@ -364,7 +424,7 @@
       </trans-unit>
       <trans-unit id="forPercentAInReflectionFreeCode">
         <source>The '%A' format specifier may not be used in an assembly being compiled with option '--reflectionfree'. This construct implicitly uses reflection.</source>
-        <target state="new">The '%A' format specifier may not be used in an assembly being compiled with option '--reflectionfree'. This construct implicitly uses reflection.</target>
+        <target state="translated">'%A' biçim belirticisi, '--reflectionfree' seçeneğiyle derlenen bir derlemede kullanılamaz. Bu yapı örtük olarak yansımayı kullanır.</target>
         <note />
       </trans-unit>
       <trans-unit id="formatDashItem">
@@ -384,7 +444,7 @@
       </trans-unit>
       <trans-unit id="ifExpressionTuple">
         <source>The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Bağlam türü gereksinimlerini karşılaması için 'if' ifadesinin {0} uzunluğunda türü\n    {1}    \nolan bir demet döndürmesi gerekiyor. Şu anda {2} uzunluğunda türü\n    {3}    \nolan bir demet döndürüyor</target>
         <note />
       </trans-unit>
       <trans-unit id="ilxGenUnknownDebugPoint">
@@ -409,7 +469,7 @@
       </trans-unit>
       <trans-unit id="keywordDescriptionAnd">
         <source>Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</source>
-        <target state="new">Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</target>
+        <target state="translated">Karşılıklı yinelemeli bağlamalarda, özellik bildirimlerinde ve genel parametreler üzerinde birden çok kısıtlamayla kullanılır.</target>
         <note />
       </trans-unit>
       <trans-unit id="keywordDescriptionConst">
@@ -419,7 +479,7 @@
       </trans-unit>
       <trans-unit id="keywordDescriptionTypeTest">
         <source>Used to check if an object is of the given type in a pattern or binding.</source>
-        <target state="new">Used to check if an object is of the given type in a pattern or binding.</target>
+        <target state="translated">Bir nesnenin desende veya bağlamada verilen türde olup olmadığını kontrol etmek için kullanılır.</target>
         <note />
       </trans-unit>
       <trans-unit id="lexByteStringMayNotBeInterpolated">
@@ -449,12 +509,12 @@
       </trans-unit>
       <trans-unit id="listElementHasWrongTypeTuple">
         <source>All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">Bir listenin tüm öğeleri örtük olarak ilk öğenin türüne dönüştürülebilir olmalıdır. Burada ilk öğe {0} uzunluğunda türü\n {1} \nolan bir demet. Bu öğe ise {2} uzunluğunda türü\n {3} \nolan bir demet.</target>
         <note />
       </trans-unit>
       <trans-unit id="matchNotAllowedForUnionCaseWithNoData">
         <source>Pattern discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern discard is not allowed for union case that takes no data.</target>
+        <target state="translated">Veri almayan birleşim durumu için desen atma kullanılamaz.</target>
         <note />
       </trans-unit>
       <trans-unit id="mlCompatError">
@@ -529,17 +589,17 @@
       </trans-unit>
       <trans-unit id="optsCompressMetadata">
         <source>Compress interface and optimization data files</source>
-        <target state="new">Compress interface and optimization data files</target>
+        <target state="translated">Arabirim ve iyileştirme veri dosyalarını sıkıştır</target>
         <note />
       </trans-unit>
       <trans-unit id="optsGetLangVersions">
         <source>Display the allowed values for language version.</source>
-        <target state="new">Display the allowed values for language version.</target>
+        <target state="translated">Dil sürümü için izin verilen değerleri görüntüleyin.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsInvalidRefAssembly">
         <source>Invalid use of emitting a reference assembly, do not use '--standalone or --staticlink' with '--refonly or --refout'.</source>
-        <target state="needs-review-translation">Başvuru bütünleştirilmiş kodunun oluşturulması için geçersiz kullanım: '--staticlink' veya '--refonly' ile '--refout' birlikte kullanılmaz.</target>
+        <target state="translated">Başvuru bütünleştirilmiş kodu oluşturmanın geçersiz kullanımı; '--standalone’ veya ‘--staticlink' seçeneğini '--refonly’ veya ‘--refout' ile birlikte kullanmayın.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsInvalidRefOut">
@@ -549,12 +609,12 @@
       </trans-unit>
       <trans-unit id="optsOptimizationData">
         <source>Specify included optimization information, the default is file. Important for distributed libraries.</source>
-        <target state="new">Specify included optimization information, the default is file. Important for distributed libraries.</target>
+        <target state="translated">Dahil edilen iyileştirme bilgilerini belirtin; varsayılan değer dosyadır. Dağıtılmış kitaplıklar için önemlidir.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsPdbMatchesOutputFileName">
         <source>The pdb output file name cannot match the build output filename use --pdb:filename.pdb</source>
-        <target state="new">The pdb output file name cannot match the build output filename use --pdb:filename.pdb</target>
+        <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="optsRefOnly">
@@ -569,17 +629,17 @@
       </trans-unit>
       <trans-unit id="optsReflectionFree">
         <source>Disable implicit generation of constructs using reflection</source>
-        <target state="new">Disable implicit generation of constructs using reflection</target>
+        <target state="translated">Yansıma kullanarak yapıların örtük oluşturulmasını devre dışı bırak</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSetLangVersion">
         <source>Specify language version such as 'latest' or 'preview'.</source>
-        <target state="new">Specify language version such as 'latest' or 'preview'.</target>
+        <target state="translated">'latest' veya 'preview' gibi dil sürümünü belirtin.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSignatureData">
         <source>Include F# interface information, the default is file. Essential for distributing libraries.</source>
-        <target state="new">Include F# interface information, the default is file. Essential for distributing libraries.</target>
+        <target state="translated">F# arabirim bilgilerini dahil edin; varsayılan değer dosyadır. Kitaplıkları dağıtmak için gereklidir.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSupportedLangVersions">
@@ -589,12 +649,12 @@
       </trans-unit>
       <trans-unit id="optsUnknownOptimizationData">
         <source>Invalid value '{0}' for --optimizationdata, valid value are: none, file, compress.</source>
-        <target state="new">Invalid value '{0}' for --optimizationdata, valid value are: none, file, compress.</target>
+        <target state="translated">--optimizationdata için geçersiz '{0}' değeri, geçerli değerler: none, file, compress.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsUnknownSignatureData">
         <source>Invalid value '{0}' for --interfacedata, valid value are: none, file, compress.</source>
-        <target state="new">Invalid value '{0}' for --interfacedata, valid value are: none, file, compress.</target>
+        <target state="translated">--interfacedata için geçersiz '{0}' değeri, geçerli değerler: none, file, compress.</target>
         <note />
       </trans-unit>
       <trans-unit id="optsUnrecognizedLanguageVersion">
@@ -649,7 +709,7 @@
       </trans-unit>
       <trans-unit id="parsExpectedPatternAfterToken">
         <source>Expected a pattern after this point</source>
-        <target state="new">Expected a pattern after this point</target>
+        <target state="translated">Bu noktadan sonra bir desen bekleniyordu</target>
         <note />
       </trans-unit>
       <trans-unit id="parsExpectingExpressionInTuple">
@@ -659,17 +719,17 @@
       </trans-unit>
       <trans-unit id="parsExpectingPatternInTuple">
         <source>Expecting pattern</source>
-        <target state="new">Expecting pattern</target>
+        <target state="translated">Desen bekleniyor</target>
         <note />
       </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
         <source>Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</source>
-        <target state="new">Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</target>
+        <target state="translated">Eksik karakter değişmez değeri (örnek: 'Q') veya tam tür çağrısı (örnek: 'T.Name)</target>
         <note />
       </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr2">
         <source>Incomplete operator expression (example a^b) or qualified type invocation (example: ^T.Name)</source>
-        <target state="new">Incomplete operator expression (example a^b) or qualified type invocation (example: ^T.Name)</target>
+        <target state="translated">Eksik işleç ifadesi (örnek a^b) veya tam tür çağrısı (örnek: ^T.Name)</target>
         <note />
       </trans-unit>
       <trans-unit id="parsNewExprMemberAccess">
@@ -849,7 +909,7 @@
       </trans-unit>
       <trans-unit id="tcInitOnlyPropertyCannotBeSet1">
         <source>Init-only property '{0}' cannot be set outside the initialization code. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</source>
-        <target state="new">Init-only property '{0}' cannot be set outside the initialization code. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
+        <target state="translated">'{0}' yalnızca başlatma özelliği başlatma kodunun dışında ayarlanamaz. Bkz. https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
         <note />
       </trans-unit>
       <trans-unit id="tcInlineIfLambdaUsedOnNonInlineFunctionOrMethod">
@@ -879,7 +939,7 @@
       </trans-unit>
       <trans-unit id="tcInvalidSelfConstraint">
         <source>Invalid constraint. Valid constraint forms include \"'T :&gt; ISomeInterface\" for interface constraints and \"SomeConstrainingType&lt;'T&gt;\" for self-constraints. See https://aka.ms/fsharp-type-constraints.</source>
-        <target state="new">Invalid constraint. Valid constraint forms include \"'T :&gt; ISomeInterface\" for interface constraints and \"SomeConstrainingType&lt;'T&gt;\" for self-constraints. See https://aka.ms/fsharp-type-constraints.</target>
+        <target state="translated">Geçersiz kısıtlama. Geçerli kısıtlama formları arabirim kısıtlamaları için \"'T :&gt; ISomeInterface\" ve kendi kendine kısıtlamalar için \"SomeConstrainingType&lt;'T&gt;\" içerir. Bkz. https://aka.ms/fsharp-type-constraints.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcInvalidStructReturn">
@@ -924,7 +984,7 @@
       </trans-unit>
       <trans-unit id="tcMissingRequiredMembers">
         <source>The following required properties have to be initalized:{0}</source>
-        <target state="new">The following required properties have to be initalized:{0}</target>
+        <target state="translated">Aşağıdaki gerekli özelliklerin başlatılması gerekiyor:{0}</target>
         <note />
       </trans-unit>
       <trans-unit id="tcNoEagerConstraintApplicationAttribute">
@@ -1009,7 +1069,7 @@
       </trans-unit>
       <trans-unit id="tcSetterForInitOnlyPropertyCannotBeCalled1">
         <source>Cannot call '{0}' - a setter for init-only property, please use object initialization instead. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</source>
-        <target state="new">Cannot call '{0}' - a setter for init-only property, please use object initialization instead. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
+        <target state="translated">Yalnızca başlatma özelliği için ayarlayıcı olan '{0}' çağrılamaz, lütfen bunun yerine nesne başlatmayı kullanın. bkz. https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
         <note />
       </trans-unit>
       <trans-unit id="tcSubsumptionImplicitConversionUsed">
@@ -1019,32 +1079,32 @@
       </trans-unit>
       <trans-unit id="tcSynTypeOrInvalidInDeclaration">
         <source>SynType.Or is not permitted in this declaration</source>
-        <target state="new">SynType.Or is not permitted in this declaration</target>
+        <target state="translated">Bu bildirimde SynType.Or'a izin verilmiyor</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitHasMultipleSupportTypes">
         <source>The trait '{0}' invoked by this call has multiple support types. This invocation syntax is not permitted for such traits. See https://aka.ms/fsharp-srtp for guidance.</source>
-        <target state="new">The trait '{0}' invoked by this call has multiple support types. This invocation syntax is not permitted for such traits. See https://aka.ms/fsharp-srtp for guidance.</target>
+        <target state="translated">Bu çağrı tarafından çağrılan '{0}' özelliği birden çok destek türüne sahiptir. Bu tür nitelikler için bu çağrı söz dizimine izin verilmez. Rehber için bkz. https://aka.ms/fsharp-srtp.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitInvocationShouldUseTick">
         <source>Invocation of a static constraint should use \"'T.Ident\" and not \"^T.Ident\", even for statically resolved type parameters.</source>
-        <target state="new">Invocation of a static constraint should use \"'T.Ident\" and not \"^T.Ident\", even for statically resolved type parameters.</target>
+        <target state="translated">Statik kısıtlamanın çağrılması statik olarak çözümlenmiş tür parametreleri için bile \"^T.Ident\" değil, \"'T.Ident\" kullanmalıdır.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitIsNotStatic">
         <source>Trait '{0}' is not static</source>
-        <target state="new">Trait '{0}' is not static</target>
+        <target state="translated">'{0}' niteliği statik değildir</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitIsStatic">
         <source>Trait '{0}' is static</source>
-        <target state="new">Trait '{0}' is static</target>
+        <target state="translated">'{0}' niteliği statiktir</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitMayNotUseComplexThings">
         <source>A trait may not specify optional, in, out, ParamArray, CallerInfo or Quote arguments</source>
-        <target state="new">A trait may not specify optional, in, out, ParamArray, CallerInfo or Quote arguments</target>
+        <target state="translated">Bir nitelik optional, in, out, ParamArray, CallerInfo veya Quote bağımsız değişkenlerini belirtemiyor</target>
         <note />
       </trans-unit>
       <trans-unit id="tcUnableToParseInterpolatedString">
@@ -1054,12 +1114,12 @@
       </trans-unit>
       <trans-unit id="tcUsingInterfaceWithStaticAbstractMethodAsType">
         <source>'{0}' is normally used as a type constraint in generic code, e.g. \"'T when ISomeInterface&lt;'T&gt;\" or \"let f (x: #ISomeInterface&lt;_&gt;)\". See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3536\"' or '--nowarn:3536'.</source>
-        <target state="new">'{0}' is normally used as a type constraint in generic code, e.g. \"'T when ISomeInterface&lt;'T&gt;\" or \"let f (x: #ISomeInterface&lt;_&gt;)\". See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3536\"' or '--nowarn:3536'.</target>
+        <target state="translated">'{0}' normalde genel kodda tür kısıtlaması olarak kullanılır, ör. \"'T when ISomeInterface&lt;'T&gt;\" veya \"let f (x: #ISomeInterface&lt;_&gt;)\". Rehber için bkz. https://aka.ms/fsharp-iwsams. '#nowarn \"3536\"' veya '--nowarn:3536' kullanarak bu uyarıyı devre dışı bırakabilirsiniz.</target>
         <note />
       </trans-unit>
       <trans-unit id="tcUsingInterfacesWithStaticAbstractMethods">
         <source>Declaring \"interfaces with static abstract methods\" is an advanced feature. See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3535\"' or '--nowarn:3535'.</source>
-        <target state="new">Declaring \"interfaces with static abstract methods\" is an advanced feature. See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3535\"' or '--nowarn:3535'.</target>
+        <target state="translated">\"interfaces with static abstract methods\" bildirimi gelişmiş bir özelliktir. Rehber için bkz. https://aka.ms/fsharp-iwsams. '#nowarn \"3535\"' veya '--nowarn:3535'. kullanarak bu uyarıyı devre dışı bırakabilirsiniz.</target>
         <note />
       </trans-unit>
       <trans-unit id="typrelInterfaceMemberNoMostSpecificImplementation">
@@ -3849,7 +3909,7 @@
       </trans-unit>
       <trans-unit id="tcUnionCaseExpectsTupledArguments">
         <source>This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</source>
-        <target state="new">This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</target>
+        <target state="translated">Bu birleşim durumu demet halinde {0} bağımsız değişken bekliyordu ancak {1} verildi. Eksik alan bağımsız değişkenleri şunlardan biri olabilir:{2}</target>
         <note />
       </trans-unit>
       <trans-unit id="tcFieldIsNotStatic">
@@ -7529,7 +7589,7 @@
       </trans-unit>
       <trans-unit id="tcStructUnionMultiCaseDistinctFields">
         <source>If a multicase union type is a struct, then all union cases must have unique names. For example: 'type A = B of b: int | C of c: int'.</source>
-        <target state="needs-review-translation">Bir birleşim türü büyük ve küçük harfler içeriyorsa ve bir yapıysa, birleşim türü içindeki tüm alanlara benzersiz adlar verilmelidir.</target>
+        <target state="translated">Çok durumlu bir birleşim türü bir yapıysa, tüm birleşim durumlarının adları benzersiz olmalıdır. Örneğin: 'type A = B of b: int | C of c: int'.</target>
         <note />
       </trans-unit>
       <trans-unit id="CallerMemberNameIsOverriden">
diff --git a/src/Compiler/xlf/FSComp.txt.zh-Hans.xlf b/src/Compiler/xlf/FSComp.txt.zh-Hans.xlf
index de4213c22d5..3601169ca3a 100644
--- a/src/Compiler/xlf/FSComp.txt.zh-Hans.xlf
+++ b/src/Compiler/xlf/FSComp.txt.zh-Hans.xlf
@@ -4,7 +4,12 @@
     <body>
       <trans-unit id="arrayElementHasWrongTypeTuple">
         <source>All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">数组的所有元素必须可隐式转换为第一个元素的类型，这是一个长度为 {0} 的类型的元组\n    {1}    \n此元素是长度为 {2} 类型的元组\n    {3}    \n</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="buildDuplicateFile">
+        <source>The source file '{0}' (at position {1}/{2}) already appeared in the compilation list (at position {3}/{4}). Please verify that it is included only once in the project file.</source>
+        <target state="translated">源文件“{0}”(位于位置 {1}/{2})已出现在编译列表(位于位置 {3}/{4})中。请确认该文件仅包含在项目文件中一次。</target>
         <note />
       </trans-unit>
       <trans-unit id="buildInvalidSourceFileExtensionML">
@@ -17,9 +22,29 @@
         <target state="translated">无法识别“{0}”的文件扩展名。源文件必须具有扩展名 .fs、.fsi、.fsx 或 .fsscript</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkAbstractMembersDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkAdditionalConstructorOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Additional constructor is not allowed.</source>
+        <target state="translated">如果类型同时使用 [&lt;Sealed&gt;] 和 [&lt;AbstractClass&gt;] 属性，则表示它是静态的。不允许使用其他构造函数。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkConstructorWithArgumentsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Constructor with arguments is not allowed.</source>
+        <target state="translated">如果类型同时使用 [&lt;Sealed&gt;] 和 [&lt;AbstractClass&gt;] 属性，则表示它是静态的。不允许使用带参数的构造函数。</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkDuplicatedMethodParameter">
         <source>Duplicate parameter. The parameter '{0}' has been used more that once in this method.</source>
-        <target state="new">Duplicate parameter. The parameter '{0}' has been used more that once in this method.</target>
+        <target state="translated">参数重复。此方法中多次使用了参数“{0}”。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkExplicitFieldsDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</target>
         <note />
       </trans-unit>
       <trans-unit id="chkFeatureNotLanguageSupported">
@@ -37,6 +62,11 @@
         <target state="translated">功能“{0}”需要 {1} 或更高语言版本的 F# 库。</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkImplementingInterfacesOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkInfoRefcellAssign">
         <source>The use of ':=' from the F# library is deprecated. See https://aka.ms/fsharp-refcell-ops. For example, please change 'cell := expr' to 'cell.Value &lt;- expr'.</source>
         <target state="translated">已弃用 F# 库中的“:=”。请参阅 https://aka.ms/fsharp-refcell-ops。 例如，请将“cell := expr”更改为“cell.Value &lt;- expr”。</target>
@@ -57,6 +87,16 @@
         <target state="translated">已弃用 F# 库中的“incr”。请参阅 https://aka.ms/fsharp-refcell-ops。 例如，请将“incr cell”更改为“cell.Value &lt;- cell.Value + 1”。</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkInstanceLetBindingOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkInstanceMemberOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance members are not allowed.</source>
+        <target state="translated">如果类型同时使用 [&lt;Sealed&gt;] 和 [&lt;AbstractClass&gt;] 属性，则表示它是静态的。不允许使用实例成员。</target>
+        <note />
+      </trans-unit>
       <trans-unit id="containerDeprecated">
         <source>The 'AssemblyKeyNameAttribute' has been deprecated. Use 'AssemblyKeyFileAttribute' instead.</source>
         <target state="translated">"AssemblyKeyNameAttribute" 已被弃用。请改为使用 "AssemblyKeyFileAttribute"。</target>
@@ -114,7 +154,7 @@
       </trans-unit>
       <trans-unit id="elseBranchHasWrongTypeTuple">
         <source>All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">“if” 表达式的所有分支必须返回可隐式转换为第一个分支类型的值，这是一个长度为 {0} 的类型的元组\n    {1}    \n此分支会返回长度为 {2} 的类型的元组\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="etProviderHasDesignerAssemblyDependency">
@@ -142,6 +182,11 @@
         <target state="translated">适用的计算表达式</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureArithmeticInLiterals">
+        <source>Allow arithmetic and logical operations in literals</source>
+        <target state="translated">允许在文本中进行算术和逻辑运算</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureAttributesToRightOfModuleKeyword">
         <source>attributes to the right of the 'module' keyword</source>
         <target state="translated">"module" 关键字右侧的属性</target>
@@ -154,7 +199,7 @@
       </trans-unit>
       <trans-unit id="featureCSharpExtensionAttributeNotRequired">
         <source>Allow implicit Extension attribute on declaring types, modules</source>
-        <target state="new">Allow implicit Extension attribute on declaring types, modules</target>
+        <target state="translated">允许对声明类型、模块使用隐式扩展属性</target>
         <note />
       </trans-unit>
       <trans-unit id="featureDefaultInterfaceMemberConsumption">
@@ -179,7 +224,7 @@
       </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
-        <target state="new">Raises errors for non-virtual members overrides</target>
+        <target state="translated">引发非虚拟成员替代的错误</target>
         <note />
       </trans-unit>
       <trans-unit id="featureErrorOnDeprecatedRequireQualifiedAccess">
@@ -187,6 +232,16 @@
         <target state="translated">对具有 RequireQualifiedAccess 属性的构造进行弃用的访问时出错</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureErrorReportingOnStaticClasses">
+        <source>Error reporting on static classes</source>
+        <target state="translated">有关静态类的错误报告</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="featureEscapeBracesInFormattableString">
+        <source>Escapes curly braces before calling FormattableStringFactory.Create when interpolated string literal is typed as FormattableString</source>
+        <target state="translated">当内插字符串文本键入为 FormattableString 时，在调用 FormattableStringFactory.Create 之前转义大括号</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureExpandedMeasurables">
         <source>more types support units of measure</source>
         <target state="translated">更多类型支持度量单位</target>
@@ -214,12 +269,12 @@
       </trans-unit>
       <trans-unit id="featureInitProperties">
         <source>support for consuming init properties</source>
-        <target state="new">support for consuming init properties</target>
+        <target state="translated">支持使用 init 属性</target>
         <note />
       </trans-unit>
       <trans-unit id="featureInterfacesWithAbstractStaticMembers">
         <source>static abstract interface members</source>
-        <target state="new">static abstract interface members</target>
+        <target state="translated">静态抽象接口成员</target>
         <note />
       </trans-unit>
       <trans-unit id="featureInterfacesWithMultipleGenericInstantiation">
@@ -229,7 +284,7 @@
       </trans-unit>
       <trans-unit id="featureLowercaseDUWhenRequireQualifiedAccess">
         <source>Allow lowercase DU when RequireQualifiedAccess attribute</source>
-        <target state="new">Allow lowercase DU when RequireQualifiedAccess attribute</target>
+        <target state="translated">当 RequireQualifiedAccess 属性时允许小写 DU</target>
         <note />
       </trans-unit>
       <trans-unit id="featureMLCompatRevisions">
@@ -239,7 +294,7 @@
       </trans-unit>
       <trans-unit id="featureMatchNotAllowedForUnionCaseWithNoData">
         <source>Pattern match discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern match discard is not allowed for union case that takes no data.</target>
+        <target state="translated">不允许将模式匹配丢弃用于不采用数据的联合事例。</target>
         <note />
       </trans-unit>
       <trans-unit id="featureNameOf">
@@ -299,7 +354,7 @@
       </trans-unit>
       <trans-unit id="featureRequiredProperties">
         <source>support for required properties</source>
-        <target state="new">support for required properties</target>
+        <target state="translated">对所需属性的支持</target>
         <note />
       </trans-unit>
       <trans-unit id="featureResumableStateMachines">
@@ -309,7 +364,7 @@
       </trans-unit>
       <trans-unit id="featureSelfTypeConstraints">
         <source>self type constraints</source>
-        <target state="new">self type constraints</target>
+        <target state="translated">自类型约束</target>
         <note />
       </trans-unit>
       <trans-unit id="featureSingleUnderscorePattern">
@@ -327,6 +382,11 @@
         <target state="translated">活动模式的结构表示形式</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureWarningWhenInliningMethodImplNoInlineMarkedFunction">
+        <source>Raises warnings when 'let inline ... =' is used together with [&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;] attribute. Function is not getting inlined.</source>
+        <target state="translated">当 "let inline ... =" 与 [&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;] 属性一起使用时引发警告。函数未内联。</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureWildCardInForLoop">
         <source>wild card in for loop</source>
         <target state="translated">for 循环中的通配符</target>
@@ -339,7 +399,7 @@
       </trans-unit>
       <trans-unit id="followingPatternMatchClauseHasWrongTypeTuple">
         <source>All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">模式匹配表达式的所有分支必须返回可隐式转换为第一个分支类型的值，这是一个长度为 {0} 的类型的元组\n    {1}    \n此分支会返回长度为 {2} 的类型的元组\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="forFormatInvalidForInterpolated">
@@ -364,7 +424,7 @@
       </trans-unit>
       <trans-unit id="forPercentAInReflectionFreeCode">
         <source>The '%A' format specifier may not be used in an assembly being compiled with option '--reflectionfree'. This construct implicitly uses reflection.</source>
-        <target state="new">The '%A' format specifier may not be used in an assembly being compiled with option '--reflectionfree'. This construct implicitly uses reflection.</target>
+        <target state="translated">"%A" 格式说明符不能在用选项 "--reflectionfree" 进行编译的程序集中使用。此构造隐式使用反射。</target>
         <note />
       </trans-unit>
       <trans-unit id="formatDashItem">
@@ -384,7 +444,7 @@
       </trans-unit>
       <trans-unit id="ifExpressionTuple">
         <source>The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">“if” 表达式需要返回长度为 {0} 的类型的元组\n    {1}    \n以满足上下文类型要求。它当前返回了长度为 {2} 的类型的元组\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="ilxGenUnknownDebugPoint">
@@ -409,7 +469,7 @@
       </trans-unit>
       <trans-unit id="keywordDescriptionAnd">
         <source>Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</source>
-        <target state="new">Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</target>
+        <target state="translated">用于互相递归绑定、属性声明，并用于对泛型参数的多个约束。</target>
         <note />
       </trans-unit>
       <trans-unit id="keywordDescriptionConst">
@@ -419,7 +479,7 @@
       </trans-unit>
       <trans-unit id="keywordDescriptionTypeTest">
         <source>Used to check if an object is of the given type in a pattern or binding.</source>
-        <target state="new">Used to check if an object is of the given type in a pattern or binding.</target>
+        <target state="translated">用于检查对象是否属于模式或绑定中的给定类型。</target>
         <note />
       </trans-unit>
       <trans-unit id="lexByteStringMayNotBeInterpolated">
@@ -449,12 +509,12 @@
       </trans-unit>
       <trans-unit id="listElementHasWrongTypeTuple">
         <source>All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">列表的所有元素必须可隐式转换为第一个元素的类型，这是一个长度为 {0} 的类型的元组\n    {1}    \n此元素是长度为 {2} 类型的元组\n    {3}    \n</target>
         <note />
       </trans-unit>
       <trans-unit id="matchNotAllowedForUnionCaseWithNoData">
         <source>Pattern discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern discard is not allowed for union case that takes no data.</target>
+        <target state="translated">不允许将模式丢弃用于不采用数据的联合事例。</target>
         <note />
       </trans-unit>
       <trans-unit id="mlCompatError">
@@ -529,17 +589,17 @@
       </trans-unit>
       <trans-unit id="optsCompressMetadata">
         <source>Compress interface and optimization data files</source>
-        <target state="new">Compress interface and optimization data files</target>
+        <target state="translated">压缩接口和优化数据文件</target>
         <note />
       </trans-unit>
       <trans-unit id="optsGetLangVersions">
         <source>Display the allowed values for language version.</source>
-        <target state="new">Display the allowed values for language version.</target>
+        <target state="translated">显示语言版本的允许值。</target>
         <note />
       </trans-unit>
       <trans-unit id="optsInvalidRefAssembly">
         <source>Invalid use of emitting a reference assembly, do not use '--standalone or --staticlink' with '--refonly or --refout'.</source>
-        <target state="needs-review-translation">发出引用程序集的使用无效，请勿同时使用“--staticlink”或“--refonly”和“--refout”。</target>
+        <target state="translated">发出引用程序集的使用无效，请勿将 '--standalone 或 --staticlink' 与 '--refonly 或 --refout' 一起使用。</target>
         <note />
       </trans-unit>
       <trans-unit id="optsInvalidRefOut">
@@ -549,12 +609,12 @@
       </trans-unit>
       <trans-unit id="optsOptimizationData">
         <source>Specify included optimization information, the default is file. Important for distributed libraries.</source>
-        <target state="new">Specify included optimization information, the default is file. Important for distributed libraries.</target>
+        <target state="translated">指定包含的优化信息，默认值为文件。对于分发库非常重要。</target>
         <note />
       </trans-unit>
       <trans-unit id="optsPdbMatchesOutputFileName">
         <source>The pdb output file name cannot match the build output filename use --pdb:filename.pdb</source>
-        <target state="new">The pdb output file name cannot match the build output filename use --pdb:filename.pdb</target>
+        <target state="translated">pdb 输出文件名不能与生成输出文件名 use --pdb: filename.pdb 匹配</target>
         <note />
       </trans-unit>
       <trans-unit id="optsRefOnly">
@@ -569,17 +629,17 @@
       </trans-unit>
       <trans-unit id="optsReflectionFree">
         <source>Disable implicit generation of constructs using reflection</source>
-        <target state="new">Disable implicit generation of constructs using reflection</target>
+        <target state="translated">使用反射禁用隐式构造生成</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSetLangVersion">
         <source>Specify language version such as 'latest' or 'preview'.</source>
-        <target state="new">Specify language version such as 'latest' or 'preview'.</target>
+        <target state="translated">指定语言版本，如 "latest" 或 "preview"。</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSignatureData">
         <source>Include F# interface information, the default is file. Essential for distributing libraries.</source>
-        <target state="new">Include F# interface information, the default is file. Essential for distributing libraries.</target>
+        <target state="translated">包括 F# 接口信息，默认值为文件。对于分发库必不可少。</target>
         <note />
       </trans-unit>
       <trans-unit id="optsSupportedLangVersions">
@@ -589,12 +649,12 @@
       </trans-unit>
       <trans-unit id="optsUnknownOptimizationData">
         <source>Invalid value '{0}' for --optimizationdata, valid value are: none, file, compress.</source>
-        <target state="new">Invalid value '{0}' for --optimizationdata, valid value are: none, file, compress.</target>
+        <target state="translated">--optimizationdata 的值 "{0}" 无效，有效值为: none、file、compress。</target>
         <note />
       </trans-unit>
       <trans-unit id="optsUnknownSignatureData">
         <source>Invalid value '{0}' for --interfacedata, valid value are: none, file, compress.</source>
-        <target state="new">Invalid value '{0}' for --interfacedata, valid value are: none, file, compress.</target>
+        <target state="translated">--interfacedata 的值 "{0}" 无效，有效值为: none、file、compress。</target>
         <note />
       </trans-unit>
       <trans-unit id="optsUnrecognizedLanguageVersion">
@@ -649,7 +709,7 @@
       </trans-unit>
       <trans-unit id="parsExpectedPatternAfterToken">
         <source>Expected a pattern after this point</source>
-        <target state="new">Expected a pattern after this point</target>
+        <target state="translated">此点之后应有一个模式</target>
         <note />
       </trans-unit>
       <trans-unit id="parsExpectingExpressionInTuple">
@@ -659,17 +719,17 @@
       </trans-unit>
       <trans-unit id="parsExpectingPatternInTuple">
         <source>Expecting pattern</source>
-        <target state="new">Expecting pattern</target>
+        <target state="translated">预期模式</target>
         <note />
       </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
         <source>Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</source>
-        <target state="new">Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name)</target>
+        <target state="translated">字符文本不完整(示例: "Q")或限定类型调用(示例: "T.Name")</target>
         <note />
       </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr2">
         <source>Incomplete operator expression (example a^b) or qualified type invocation (example: ^T.Name)</source>
-        <target state="new">Incomplete operator expression (example a^b) or qualified type invocation (example: ^T.Name)</target>
+        <target state="translated">运算符表达式不完整(示例: a^b)或限定类型调用(示例: ^T.Name)</target>
         <note />
       </trans-unit>
       <trans-unit id="parsNewExprMemberAccess">
@@ -849,7 +909,7 @@
       </trans-unit>
       <trans-unit id="tcInitOnlyPropertyCannotBeSet1">
         <source>Init-only property '{0}' cannot be set outside the initialization code. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</source>
-        <target state="new">Init-only property '{0}' cannot be set outside the initialization code. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
+        <target state="translated">不能在初始化代码外部设置仅限 init 的属性 "{0}"。请参阅 https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
         <note />
       </trans-unit>
       <trans-unit id="tcInlineIfLambdaUsedOnNonInlineFunctionOrMethod">
@@ -879,7 +939,7 @@
       </trans-unit>
       <trans-unit id="tcInvalidSelfConstraint">
         <source>Invalid constraint. Valid constraint forms include \"'T :&gt; ISomeInterface\" for interface constraints and \"SomeConstrainingType&lt;'T&gt;\" for self-constraints. See https://aka.ms/fsharp-type-constraints.</source>
-        <target state="new">Invalid constraint. Valid constraint forms include \"'T :&gt; ISomeInterface\" for interface constraints and \"SomeConstrainingType&lt;'T&gt;\" for self-constraints. See https://aka.ms/fsharp-type-constraints.</target>
+        <target state="translated">约束无效。有效的约束形式包括 \"'T :&gt; ISomeInterface\" (接口约束)和 \"SomeConstrainingType&lt;'T&gt;\" (自我约束)。请参阅 https://aka.ms/fsharp-type-constraints。</target>
         <note />
       </trans-unit>
       <trans-unit id="tcInvalidStructReturn">
@@ -924,7 +984,7 @@
       </trans-unit>
       <trans-unit id="tcMissingRequiredMembers">
         <source>The following required properties have to be initalized:{0}</source>
-        <target state="new">The following required properties have to be initalized:{0}</target>
+        <target state="translated">必须初始化以下必需属性: {0}</target>
         <note />
       </trans-unit>
       <trans-unit id="tcNoEagerConstraintApplicationAttribute">
@@ -1009,7 +1069,7 @@
       </trans-unit>
       <trans-unit id="tcSetterForInitOnlyPropertyCannotBeCalled1">
         <source>Cannot call '{0}' - a setter for init-only property, please use object initialization instead. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</source>
-        <target state="new">Cannot call '{0}' - a setter for init-only property, please use object initialization instead. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
+        <target state="translated">无法调用 "{0}"，它是仅限 init 属性的资源库，请改用对象初始化。请参阅 https://aka.ms/fsharp-assigning-values-to-properties-at-initialization</target>
         <note />
       </trans-unit>
       <trans-unit id="tcSubsumptionImplicitConversionUsed">
@@ -1019,32 +1079,32 @@
       </trans-unit>
       <trans-unit id="tcSynTypeOrInvalidInDeclaration">
         <source>SynType.Or is not permitted in this declaration</source>
-        <target state="new">SynType.Or is not permitted in this declaration</target>
+        <target state="translated">此声明中不允许使用 SynType.Or</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitHasMultipleSupportTypes">
         <source>The trait '{0}' invoked by this call has multiple support types. This invocation syntax is not permitted for such traits. See https://aka.ms/fsharp-srtp for guidance.</source>
-        <target state="new">The trait '{0}' invoked by this call has multiple support types. This invocation syntax is not permitted for such traits. See https://aka.ms/fsharp-srtp for guidance.</target>
+        <target state="translated">此调用过程调用的特征 "{0}" 具有多种支持类型。此类特征不允许使用此调用语法。有关指南，请参阅 https://aka.ms/fsharp-srtp。</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitInvocationShouldUseTick">
         <source>Invocation of a static constraint should use \"'T.Ident\" and not \"^T.Ident\", even for statically resolved type parameters.</source>
-        <target state="new">Invocation of a static constraint should use \"'T.Ident\" and not \"^T.Ident\", even for statically resolved type parameters.</target>
+        <target state="translated">调用静态约束应使用 \"'T.Ident\" 而不是 \"^T.Ident\"，即使对于静态解析的类型参数也是如此。</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitIsNotStatic">
         <source>Trait '{0}' is not static</source>
-        <target state="new">Trait '{0}' is not static</target>
+        <target state="translated">特征 "{0}" 不是静态的</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitIsStatic">
         <source>Trait '{0}' is static</source>
-        <target state="new">Trait '{0}' is static</target>
+        <target state="translated">特征 "{0}" 是静态的</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitMayNotUseComplexThings">
         <source>A trait may not specify optional, in, out, ParamArray, CallerInfo or Quote arguments</source>
-        <target state="new">A trait may not specify optional, in, out, ParamArray, CallerInfo or Quote arguments</target>
+        <target state="translated">特征不能指定 option、in、out、ParamArray、CallerInfo 或 Quote 参数</target>
         <note />
       </trans-unit>
       <trans-unit id="tcUnableToParseInterpolatedString">
@@ -1054,12 +1114,12 @@
       </trans-unit>
       <trans-unit id="tcUsingInterfaceWithStaticAbstractMethodAsType">
         <source>'{0}' is normally used as a type constraint in generic code, e.g. \"'T when ISomeInterface&lt;'T&gt;\" or \"let f (x: #ISomeInterface&lt;_&gt;)\". See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3536\"' or '--nowarn:3536'.</source>
-        <target state="new">'{0}' is normally used as a type constraint in generic code, e.g. \"'T when ISomeInterface&lt;'T&gt;\" or \"let f (x: #ISomeInterface&lt;_&gt;)\". See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3536\"' or '--nowarn:3536'.</target>
+        <target state="translated">"{0}" 通常用作泛型代码中的类型约束，例如 \"'T when ISomeInterface&lt;'T&gt;\" or \"let f (x: #ISomeInterface&lt;_&gt;)\"。有关指南，请参阅 https://aka.ms/fsharp-iwsams。可以使用 '#nowarn \"3536\"' 或 '--nowarn:3536' 禁用此警告。</target>
         <note />
       </trans-unit>
       <trans-unit id="tcUsingInterfacesWithStaticAbstractMethods">
         <source>Declaring \"interfaces with static abstract methods\" is an advanced feature. See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3535\"' or '--nowarn:3535'.</source>
-        <target state="new">Declaring \"interfaces with static abstract methods\" is an advanced feature. See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3535\"' or '--nowarn:3535'.</target>
+        <target state="translated">声明“使用静态抽象方法的接口”是一项高级功能。有关指南，请参阅 https://aka.ms/fsharp-iwsams。可以使用 "#nowarn \"3535\"' 或 '--nowarn:3535' 禁用此警告。</target>
         <note />
       </trans-unit>
       <trans-unit id="typrelInterfaceMemberNoMostSpecificImplementation">
@@ -3849,7 +3909,7 @@
       </trans-unit>
       <trans-unit id="tcUnionCaseExpectsTupledArguments">
         <source>This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</source>
-        <target state="new">This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</target>
+        <target state="translated">此联合事例需要元组形式的 {0} 个参数，但提供了 {1} 个。缺少的字段参数可以是 {2} 的任何参数</target>
         <note />
       </trans-unit>
       <trans-unit id="tcFieldIsNotStatic">
@@ -7529,7 +7589,7 @@
       </trans-unit>
       <trans-unit id="tcStructUnionMultiCaseDistinctFields">
         <source>If a multicase union type is a struct, then all union cases must have unique names. For example: 'type A = B of b: int | C of c: int'.</source>
-        <target state="needs-review-translation">如果联合类型有多个用例且为结构，则必须赋予此联合类型中的所有字段唯一的名称。</target>
+        <target state="translated">如果多事例联合类型是结构，则所有联合事例都必须具有唯一的名称。例如: “type A = B of b: int | C of c: int”。</target>
         <note />
       </trans-unit>
       <trans-unit id="CallerMemberNameIsOverriden">
diff --git a/src/Compiler/xlf/FSComp.txt.zh-Hant.xlf b/src/Compiler/xlf/FSComp.txt.zh-Hant.xlf
index d104380d615..b767cad8784 100644
--- a/src/Compiler/xlf/FSComp.txt.zh-Hant.xlf
+++ b/src/Compiler/xlf/FSComp.txt.zh-Hant.xlf
@@ -4,7 +4,12 @@
     <body>
       <trans-unit id="arrayElementHasWrongTypeTuple">
         <source>All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">陣列的所有元素必須以隱含方式轉換成第一個元素的類型，這是類型為\n    {1}    \n的元組長度 {0}此元素是類型為\n    {3}    \n的元組長度{2}</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="buildDuplicateFile">
+        <source>The source file '{0}' (at position {1}/{2}) already appeared in the compilation list (at position {3}/{4}). Please verify that it is included only once in the project file.</source>
+        <target state="translated">來源檔案 '{0}' ( 位於位置 {1}/{2}) 已出現在編譯清單 ( 位於位置 {3}/{4})。請確認它在專案檔中只包含一次。</target>
         <note />
       </trans-unit>
       <trans-unit id="buildInvalidSourceFileExtensionML">
@@ -17,9 +22,29 @@
         <target state="translated">無法辨識 '{0}' 的副檔名。來源檔案的副檔名必須是 .fs、.fsi、.fsx 或 .fsscript。</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkAbstractMembersDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Abstract member declarations are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkAdditionalConstructorOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Additional constructor is not allowed.</source>
+        <target state="translated">如果類型同時使用 [&lt;Sealed&gt;] 和 [&lt;AbstractClass&gt;] 屬性，表示其為靜態。不允許其他建構函式。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkConstructorWithArgumentsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Constructor with arguments is not allowed.</source>
+        <target state="translated">如果類型同時使用 [&lt;Sealed&gt;] 和 [&lt;AbstractClass&gt;] 屬性，表示其為靜態。不允許具有引數的建構函式。</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkDuplicatedMethodParameter">
         <source>Duplicate parameter. The parameter '{0}' has been used more that once in this method.</source>
-        <target state="new">Duplicate parameter. The parameter '{0}' has been used more that once in this method.</target>
+        <target state="translated">重複的參數。參數 '{0}' 在此方法中使用多次。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkExplicitFieldsDeclarationsOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Explicit field declarations are not allowed.</target>
         <note />
       </trans-unit>
       <trans-unit id="chkFeatureNotLanguageSupported">
@@ -37,6 +62,11 @@
         <target state="translated">功能 '{0}' 需要語言版本 {1} 或更高的 F# 程式庫。</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkImplementingInterfacesOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Implementing interfaces is not allowed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="chkInfoRefcellAssign">
         <source>The use of ':=' from the F# library is deprecated. See https://aka.ms/fsharp-refcell-ops. For example, please change 'cell := expr' to 'cell.Value &lt;- expr'.</source>
         <target state="translated">透過 F# 程式庫使用 ':=' 的方式已淘汰。請參閱 https://aka.ms/fsharp-refcell-ops。舉例來說，請將 'cell := expr' 變更為 'cell.Value &lt;- expr'。</target>
@@ -57,6 +87,16 @@
         <target state="translated">透過 F# 程式庫使用 'incr' 的方式已淘汰。請參閱 https://aka.ms/fsharp-refcell-ops。舉例來說，請將 'incr cell' 變更為 'cell.Value &lt;- cell.Value + 1'。</target>
         <note />
       </trans-unit>
+      <trans-unit id="chkInstanceLetBindingOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</source>
+        <target state="new">If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance let bindings are not allowed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="chkInstanceMemberOnStaticClasses">
+        <source>If a type uses both [&lt;Sealed&gt;] and [&lt;AbstractClass&gt;] attributes, it means it is static. Instance members are not allowed.</source>
+        <target state="translated">如果類型同時使用 [&lt;Sealed&gt;] 和 [&lt;AbstractClass&gt;] 屬性，表示其為靜態。不允許執行個體成員。</target>
+        <note />
+      </trans-unit>
       <trans-unit id="containerDeprecated">
         <source>The 'AssemblyKeyNameAttribute' has been deprecated. Use 'AssemblyKeyFileAttribute' instead.</source>
         <target state="translated">'AssemblyKeyNameAttribute' 已淘汰。請改用 'AssemblyKeyFileAttribute'。</target>
@@ -114,7 +154,7 @@
       </trans-unit>
       <trans-unit id="elseBranchHasWrongTypeTuple">
         <source>All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">'if' 運算式的所有分支都傳回可隱含轉換為第一個分支的類型的值，這是類型為\n    {1}    \n的元組長度 {0}此分支傳回的是類型為\n    {3}    \n的元組長度 {2}</target>
         <note />
       </trans-unit>
       <trans-unit id="etProviderHasDesignerAssemblyDependency">
@@ -142,6 +182,11 @@
         <target state="translated">適用的計算運算式</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureArithmeticInLiterals">
+        <source>Allow arithmetic and logical operations in literals</source>
+        <target state="translated">允許常值中的算術和邏輯運算</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureAttributesToRightOfModuleKeyword">
         <source>attributes to the right of the 'module' keyword</source>
         <target state="translated">'module' 關鍵字右邊的屬性</target>
@@ -154,7 +199,7 @@
       </trans-unit>
       <trans-unit id="featureCSharpExtensionAttributeNotRequired">
         <source>Allow implicit Extension attribute on declaring types, modules</source>
-        <target state="new">Allow implicit Extension attribute on declaring types, modules</target>
+        <target state="translated">允許宣告類型、模組上的隱含擴充屬性</target>
         <note />
       </trans-unit>
       <trans-unit id="featureDefaultInterfaceMemberConsumption">
@@ -179,7 +224,7 @@
       </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
-        <target state="new">Raises errors for non-virtual members overrides</target>
+        <target state="translated">引發非虛擬成員覆寫的錯誤</target>
         <note />
       </trans-unit>
       <trans-unit id="featureErrorOnDeprecatedRequireQualifiedAccess">
@@ -187,6 +232,16 @@
         <target state="translated">對具有 RequireQualifiedAccess 屬性的建構的已取代存取發出錯誤</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureErrorReportingOnStaticClasses">
+        <source>Error reporting on static classes</source>
+        <target state="translated">報告靜態類別時發生錯誤</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="featureEscapeBracesInFormattableString">
+        <source>Escapes curly braces before calling FormattableStringFactory.Create when interpolated string literal is typed as FormattableString</source>
+        <target state="translated">當差補字串常值輸入為 FormattableString 時，在呼叫 FormattableStringFactory.Create 之前先逸出大括弧</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureExpandedMeasurables">
         <source>more types support units of measure</source>
         <target state="translated">更多支援測量單位的類型</target>
@@ -239,7 +294,7 @@
       </trans-unit>
       <trans-unit id="featureMatchNotAllowedForUnionCaseWithNoData">
         <source>Pattern match discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern match discard is not allowed for union case that takes no data.</target>
+        <target state="translated">不接受資料的聯集案例不允許模式比對捨棄。</target>
         <note />
       </trans-unit>
       <trans-unit id="featureNameOf">
@@ -327,6 +382,11 @@
         <target state="translated">現用模式的結構表示法</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureWarningWhenInliningMethodImplNoInlineMarkedFunction">
+        <source>Raises warnings when 'let inline ... =' is used together with [&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;] attribute. Function is not getting inlined.</source>
+        <target state="translated">當 'let inline ... =' 與 [&lt;MethodImpl(MethodImplOptions.NoInlining)&gt;] 屬性一起使用時引發警告。函數未內嵌。</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureWildCardInForLoop">
         <source>wild card in for loop</source>
         <target state="translated">for 迴圈中的萬用字元</target>
@@ -339,7 +399,7 @@
       </trans-unit>
       <trans-unit id="followingPatternMatchClauseHasWrongTypeTuple">
         <source>All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n    {1}    \nThis branch returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">模式比對運算式的所有分支都傳回可隱含轉換為第一個分支的類型的值，這是類型為\n    {1}    \n的元組長度 {0}此分支傳回的是類型為\n    {3}    \n的元組長度 {2}</target>
         <note />
       </trans-unit>
       <trans-unit id="forFormatInvalidForInterpolated">
@@ -384,7 +444,7 @@
       </trans-unit>
       <trans-unit id="ifExpressionTuple">
         <source>The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">The 'if' expression needs to return a tuple of length {0} of type\n    {1}    \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">'if' 運算式必須傳回類型為\n    {1}    \n的元組長度{0}，才能滿足內容類型需求。目前傳回的是類型為\n    {3}    \n的元組長度 {2}</target>
         <note />
       </trans-unit>
       <trans-unit id="ilxGenUnknownDebugPoint">
@@ -409,7 +469,7 @@
       </trans-unit>
       <trans-unit id="keywordDescriptionAnd">
         <source>Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</source>
-        <target state="new">Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.</target>
+        <target state="translated">用於互相遞迴的繫結、屬性宣告，以及搭配泛型參數的多個條件約束。</target>
         <note />
       </trans-unit>
       <trans-unit id="keywordDescriptionConst">
@@ -449,12 +509,12 @@
       </trans-unit>
       <trans-unit id="listElementHasWrongTypeTuple">
         <source>All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</source>
-        <target state="new">All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n    {1}    \nThis element is a tuple of length {2} of type\n    {3}    \n</target>
+        <target state="translated">清單的所有元素必須以隱含方式轉換成第一個元素的類型，這是類型為\n    {1}    \n的元組長度 {0}此元素是類型為\n    {3}    \n的元組長度 {2}</target>
         <note />
       </trans-unit>
       <trans-unit id="matchNotAllowedForUnionCaseWithNoData">
         <source>Pattern discard is not allowed for union case that takes no data.</source>
-        <target state="new">Pattern discard is not allowed for union case that takes no data.</target>
+        <target state="translated">不接受資料的聯集案例不允許模式捨棄。</target>
         <note />
       </trans-unit>
       <trans-unit id="mlCompatError">
@@ -539,7 +599,7 @@
       </trans-unit>
       <trans-unit id="optsInvalidRefAssembly">
         <source>Invalid use of emitting a reference assembly, do not use '--standalone or --staticlink' with '--refonly or --refout'.</source>
-        <target state="needs-review-translation">發出參考組件的使用無效，請勿同時使用 '--staticlink' 或 '--refonly' 和 '--refout'。</target>
+        <target state="translated">發出參考組件的使用無效，請勿同時使用 '--standalone 或 '--refonly' 和 '--refout'。</target>
         <note />
       </trans-unit>
       <trans-unit id="optsInvalidRefOut">
@@ -649,7 +709,7 @@
       </trans-unit>
       <trans-unit id="parsExpectedPatternAfterToken">
         <source>Expected a pattern after this point</source>
-        <target state="new">Expected a pattern after this point</target>
+        <target state="translated">在這個點之後必須有模式</target>
         <note />
       </trans-unit>
       <trans-unit id="parsExpectingExpressionInTuple">
@@ -659,7 +719,7 @@
       </trans-unit>
       <trans-unit id="parsExpectingPatternInTuple">
         <source>Expecting pattern</source>
-        <target state="new">Expecting pattern</target>
+        <target state="translated">必須是模式</target>
         <note />
       </trans-unit>
       <trans-unit id="parsIncompleteTyparExpr1">
@@ -1019,7 +1079,7 @@
       </trans-unit>
       <trans-unit id="tcSynTypeOrInvalidInDeclaration">
         <source>SynType.Or is not permitted in this declaration</source>
-        <target state="new">SynType.Or is not permitted in this declaration</target>
+        <target state="translated">此宣告中不允許 SynType.Or</target>
         <note />
       </trans-unit>
       <trans-unit id="tcTraitHasMultipleSupportTypes">
@@ -3849,7 +3909,7 @@
       </trans-unit>
       <trans-unit id="tcUnionCaseExpectsTupledArguments">
         <source>This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</source>
-        <target state="new">This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2}</target>
+        <target state="translated">此聯集案例需要元組格式的 {0} 引數，但提供的是 {1}。遺漏的欄位引數可能是下列任一: {2}</target>
         <note />
       </trans-unit>
       <trans-unit id="tcFieldIsNotStatic">
@@ -7529,7 +7589,7 @@
       </trans-unit>
       <trans-unit id="tcStructUnionMultiCaseDistinctFields">
         <source>If a multicase union type is a struct, then all union cases must have unique names. For example: 'type A = B of b: int | C of c: int'.</source>
-        <target state="needs-review-translation">如果等位型別有一個以上的案例並且為結構，等位型別內所有欄位的名稱就都不得重複。</target>
+        <target state="translated">如果多案例聯集類型是結構，則所有聯集案例都必須有唯一的名稱。例如: 'type A = B of b: int | C of c: int'。</target>
         <note />
       </trans-unit>
       <trans-unit id="CallerMemberNameIsOverriden">
diff --git a/src/Compiler/xlf/FSStrings.cs.xlf b/src/Compiler/xlf/FSStrings.cs.xlf
index cfa554f8d23..7ebb3c64f7c 100644
--- a/src/Compiler/xlf/FSStrings.cs.xlf
+++ b/src/Compiler/xlf/FSStrings.cs.xlf
@@ -4,7 +4,7 @@
     <body>
       <trans-unit id="ErrorFromAddingTypeEquationTuples">
         <source>Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</source>
-        <target state="new">Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</target>
+        <target state="translated">Neshoda typů Očekává se řazená kolekce členů o délce {0} typu\n    {1}    \nale odevzdala se řazená kolekce členů o délce {2} typu\n    {3}{4}\n</target>
         <note />
       </trans-unit>
       <trans-unit id="HashLoadedSourceHasIssues0">
@@ -14,7 +14,7 @@
       </trans-unit>
       <trans-unit id="NotUpperCaseConstructorWithoutRQA">
         <source>Lowercase discriminated union cases are only allowed when using RequireQualifiedAccess attribute</source>
-        <target state="new">Lowercase discriminated union cases are only allowed when using RequireQualifiedAccess attribute</target>
+        <target state="translated">Případy sjednocení s malými písmeny jsou povolené jenom při použití atributu RequireQualifiedAccess.</target>
         <note />
       </trans-unit>
       <trans-unit id="Parser.TOKEN.DOT.DOT.HAT">
@@ -1564,7 +1564,7 @@
       </trans-unit>
       <trans-unit id="IntfImplInIntrinsicAugmentation">
         <source>Interface implementations should normally be given on the initial declaration of a type. Interface implementations in augmentations may lead to accessing static bindings before they are initialized, though only if the interface implementation is invoked during initialization of the static data, and in turn access the static data. You may remove this warning using #nowarn "69" if you have checked this is not the case.</source>
-        <target state="needs-review-translation">Implementace rozhraní v rozšířeních jsou už zastaralé. Implementace rozhraní by se měly provádět při počáteční deklaraci typu.</target>
+        <target state="translated">Implementace rozhraní by obvykle měly být zadány pro počáteční deklaraci typu. Implementace rozhraní v rozšířeních mohou vést k přístupu ke statickým vazbám před jejich inicializací, ale pouze v případě, že je implementace rozhraní vyvolána během inicializace statických dat a následně umožní přístup ke statickým datům. Toto upozornění můžete odebrat pomocí #nowarn „69“, pokud jste ověřili, že tomu tak není.</target>
         <note />
       </trans-unit>
       <trans-unit id="IntfImplInExtrinsicAugmentation">
diff --git a/src/Compiler/xlf/FSStrings.de.xlf b/src/Compiler/xlf/FSStrings.de.xlf
index 777bac9468b..69473239ef4 100644
--- a/src/Compiler/xlf/FSStrings.de.xlf
+++ b/src/Compiler/xlf/FSStrings.de.xlf
@@ -4,7 +4,7 @@
     <body>
       <trans-unit id="ErrorFromAddingTypeEquationTuples">
         <source>Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</source>
-        <target state="new">Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</target>
+        <target state="translated">Typenkonflikt. Es wurde ein Tupel der Länge {0} des Typs\n    {1}    \nerwartet, aber ein Tupel der Länge {2} des Typs\n    {3}{4}\n angegeben.</target>
         <note />
       </trans-unit>
       <trans-unit id="HashLoadedSourceHasIssues0">
@@ -14,7 +14,7 @@
       </trans-unit>
       <trans-unit id="NotUpperCaseConstructorWithoutRQA">
         <source>Lowercase discriminated union cases are only allowed when using RequireQualifiedAccess attribute</source>
-        <target state="new">Lowercase discriminated union cases are only allowed when using RequireQualifiedAccess attribute</target>
+        <target state="translated">Diskriminierte Union-Fälle in Kleinbuchstaben sind nur zulässig, wenn das RequireQualifiedAccess-Attribut verwendet wird.</target>
         <note />
       </trans-unit>
       <trans-unit id="Parser.TOKEN.DOT.DOT.HAT">
@@ -1564,7 +1564,7 @@
       </trans-unit>
       <trans-unit id="IntfImplInIntrinsicAugmentation">
         <source>Interface implementations should normally be given on the initial declaration of a type. Interface implementations in augmentations may lead to accessing static bindings before they are initialized, though only if the interface implementation is invoked during initialization of the static data, and in turn access the static data. You may remove this warning using #nowarn "69" if you have checked this is not the case.</source>
-        <target state="needs-review-translation">Schnittstellenimplementierungen in Augmentationen sind jetzt veraltet. Schnittstellenimplementierungen sollten in der ersten Deklaration eines Typs angegeben werden.</target>
+        <target state="translated">Die Implementierung von Schnittstellen sollte normalerweise in der ersten Deklaration eines Typs angegeben werden. Schnittstellenimplementierungen in Augmentationen können dazu führen, dass vor der Initialisierung auf statische Bindungen zugegriffen wird. Die gilt allerdings nur, wenn die Schnittstellenimplementierung während der Initialisierung der statischen Daten aufgerufen wird, und wiederum auf die statischen Daten zugreift. Sie können diese Warnung mit #nowarn "69" entfernen, wenn Sie überprüft haben, dass dies nicht der Fall ist.</target>
         <note />
       </trans-unit>
       <trans-unit id="IntfImplInExtrinsicAugmentation">
diff --git a/src/Compiler/xlf/FSStrings.es.xlf b/src/Compiler/xlf/FSStrings.es.xlf
index 443fc6459d2..2b06bc30aa3 100644
--- a/src/Compiler/xlf/FSStrings.es.xlf
+++ b/src/Compiler/xlf/FSStrings.es.xlf
@@ -4,7 +4,7 @@
     <body>
       <trans-unit id="ErrorFromAddingTypeEquationTuples">
         <source>Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</source>
-        <target state="new">Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</target>
+        <target state="translated">Error de coincidencia de tipos. Se espera una tupla de longitud {0} de tipo\n    {1}    \nperero se ha proporcionado una tupla de longitud {2} de tipo\n    {3}{4}\n</target>
         <note />
       </trans-unit>
       <trans-unit id="HashLoadedSourceHasIssues0">
@@ -14,7 +14,7 @@
       </trans-unit>
       <trans-unit id="NotUpperCaseConstructorWithoutRQA">
         <source>Lowercase discriminated union cases are only allowed when using RequireQualifiedAccess attribute</source>
-        <target state="new">Lowercase discriminated union cases are only allowed when using RequireQualifiedAccess attribute</target>
+        <target state="translated">Los casos de unión discriminada en minúsculas solo se permiten cuando se usa el atributo RequireQualifiedAccess</target>
         <note />
       </trans-unit>
       <trans-unit id="Parser.TOKEN.DOT.DOT.HAT">
@@ -1564,7 +1564,7 @@
       </trans-unit>
       <trans-unit id="IntfImplInIntrinsicAugmentation">
         <source>Interface implementations should normally be given on the initial declaration of a type. Interface implementations in augmentations may lead to accessing static bindings before they are initialized, though only if the interface implementation is invoked during initialization of the static data, and in turn access the static data. You may remove this warning using #nowarn "69" if you have checked this is not the case.</source>
-        <target state="needs-review-translation">Las implementaciones de interfaz en aumentos están en desuso. Las implementaciones de interfaz deben proporcionarse en la declaración inicial de un tipo.</target>
+        <target state="translated">Normalmente, las implementaciones de interfaz deben proporcionarse en la declaración inicial de un tipo. Las implementaciones de interfaz en aumentos pueden dar lugar al acceso a enlaces estáticos antes de inicializarse, aunque solo si la implementación de interfaz se invoca durante la inicialización de los datos estáticos y, a su vez, obtiene acceso a los datos estáticos. Puede quitar esta advertencia con #nowarn "69" si ha comprobado que este no es el caso.</target>
         <note />
       </trans-unit>
       <trans-unit id="IntfImplInExtrinsicAugmentation">
diff --git a/src/Compiler/xlf/FSStrings.fr.xlf b/src/Compiler/xlf/FSStrings.fr.xlf
index f6050605937..cce4c1059b0 100644
--- a/src/Compiler/xlf/FSStrings.fr.xlf
+++ b/src/Compiler/xlf/FSStrings.fr.xlf
@@ -4,7 +4,7 @@
     <body>
       <trans-unit id="ErrorFromAddingTypeEquationTuples">
         <source>Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</source>
-        <target state="new">Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</target>
+        <target state="translated">Incompatibilité de type. Tuple de longueur attendu {0} de type\n {1} \nmais tuple de longueur {2} de type\n    {3}{4}\n</target>
         <note />
       </trans-unit>
       <trans-unit id="HashLoadedSourceHasIssues0">
@@ -14,7 +14,7 @@
       </trans-unit>
       <trans-unit id="NotUpperCaseConstructorWithoutRQA">
         <source>Lowercase discriminated union cases are only allowed when using RequireQualifiedAccess attribute</source>
-        <target state="new">Lowercase discriminated union cases are only allowed when using RequireQualifiedAccess attribute</target>
+        <target state="translated">Les cas d’union discriminée en minuscules sont uniquement autorisés lors de l’utilisation de l’attribut RequireQualifiedAccess.</target>
         <note />
       </trans-unit>
       <trans-unit id="Parser.TOKEN.DOT.DOT.HAT">
@@ -1564,7 +1564,7 @@
       </trans-unit>
       <trans-unit id="IntfImplInIntrinsicAugmentation">
         <source>Interface implementations should normally be given on the initial declaration of a type. Interface implementations in augmentations may lead to accessing static bindings before they are initialized, though only if the interface implementation is invoked during initialization of the static data, and in turn access the static data. You may remove this warning using #nowarn "69" if you have checked this is not the case.</source>
-        <target state="needs-review-translation">Les implémentations d'interfaces dans les augmentations sont désormais déconseillées. Les implémentations d'interfaces doivent être fournies dans la déclaration initiale d'un type.</target>
+        <target state="translated">Les implémentations d’interfaces doivent normalement être fournies lors de la déclaration initiale d’un type. Les implémentations d’interface dans les augmentations peuvent entraîner l’accès à des liaisons statiques avant leur initialisation, mais seulement si l’implémentation de l’interface est invoquée pendant l’initialisation des données statiques, et accède à son tour aux données statiques. Vous pouvez supprimer cet avertissement en utilisant #nowarn « 69 » si vous avez vérifié que ce n’est pas le cas.</target>
         <note />
       </trans-unit>
       <trans-unit id="IntfImplInExtrinsicAugmentation">
diff --git a/src/Compiler/xlf/FSStrings.it.xlf b/src/Compiler/xlf/FSStrings.it.xlf
index 30b69ecd61a..f2f77ac5fee 100644
--- a/src/Compiler/xlf/FSStrings.it.xlf
+++ b/src/Compiler/xlf/FSStrings.it.xlf
@@ -4,7 +4,7 @@
     <body>
       <trans-unit id="ErrorFromAddingTypeEquationTuples">
         <source>Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</source>
-        <target state="new">Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</target>
+        <target state="translated">Tipo non corrispondente. È prevista una tupla di lunghezza {0} di tipo\n   {1}    \n, ma è stata specificata una tupla di lunghezza {2} di tipo\n    {3}{4}\n</target>
         <note />
       </trans-unit>
       <trans-unit id="HashLoadedSourceHasIssues0">
@@ -14,7 +14,7 @@
       </trans-unit>
       <trans-unit id="NotUpperCaseConstructorWithoutRQA">
         <source>Lowercase discriminated union cases are only allowed when using RequireQualifiedAccess attribute</source>
-        <target state="new">Lowercase discriminated union cases are only allowed when using RequireQualifiedAccess attribute</target>
+        <target state="translated">I casi di unione discriminati minuscoli sono consentiti solo quando si usa l'attributo RequireQualifiedAccess</target>
         <note />
       </trans-unit>
       <trans-unit id="Parser.TOKEN.DOT.DOT.HAT">
@@ -1564,7 +1564,7 @@
       </trans-unit>
       <trans-unit id="IntfImplInIntrinsicAugmentation">
         <source>Interface implementations should normally be given on the initial declaration of a type. Interface implementations in augmentations may lead to accessing static bindings before they are initialized, though only if the interface implementation is invoked during initialization of the static data, and in turn access the static data. You may remove this warning using #nowarn "69" if you have checked this is not the case.</source>
-        <target state="needs-review-translation">Le implementazioni di interfaccia negli aumenti sono ora deprecate. Le implementazioni di interfaccia devono essere specificate nella dichiarazione iniziale di un tipo.</target>
+        <target state="translated">In genere, le implementazioni di interfaccia devono essere specificate nella dichiarazione iniziale di un tipo. Le implementazioni di interfaccia negli aumenti possono portare all'accesso ai binding statici prima dell'inizializzazione, anche se l'implementazione dell'interfaccia viene richiamata durante l'inizializzazione dei dati statici e a sua volta accede ai dati statici. È possibile rimuovere questo avviso utilizzando #nowarn "69" se è stato verificato che il caso specifico non lo richiede.</target>
         <note />
       </trans-unit>
       <trans-unit id="IntfImplInExtrinsicAugmentation">
diff --git a/src/Compiler/xlf/FSStrings.ja.xlf b/src/Compiler/xlf/FSStrings.ja.xlf
index dc93c489205..23d92dd03d1 100644
--- a/src/Compiler/xlf/FSStrings.ja.xlf
+++ b/src/Compiler/xlf/FSStrings.ja.xlf
@@ -4,7 +4,7 @@
     <body>
       <trans-unit id="ErrorFromAddingTypeEquationTuples">
         <source>Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</source>
-        <target state="new">Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</target>
+        <target state="translated">型が一致しません。型の長さ {0} のタプルが必要です\n    {1}    \nただし、型の長さ {2} のタプルが指定された場合\n    {3}{4}\n</target>
         <note />
       </trans-unit>
       <trans-unit id="HashLoadedSourceHasIssues0">
@@ -1564,7 +1564,7 @@
       </trans-unit>
       <trans-unit id="IntfImplInIntrinsicAugmentation">
         <source>Interface implementations should normally be given on the initial declaration of a type. Interface implementations in augmentations may lead to accessing static bindings before they are initialized, though only if the interface implementation is invoked during initialization of the static data, and in turn access the static data. You may remove this warning using #nowarn "69" if you have checked this is not the case.</source>
-        <target state="needs-review-translation">拡張内のインターフェイスの実装は使用されなくなりました。インターフェイスの実装は、型の最初の宣言で指定してください。</target>
+        <target state="translated">インターフェイスの実装には、通常、最初に型を指定する必要があります。拡張のインターフェイス実装は、初期化前に静的バインディングにアクセスする可能性があります。ただし、静的データの初期化中にインターフェイスの実装が呼び出され、静的データにアクセスする場合のみです。この警告は、#nowarn "69" を使用して削除できます。この点をすでにチェックしている場合は該当しません。</target>
         <note />
       </trans-unit>
       <trans-unit id="IntfImplInExtrinsicAugmentation">
diff --git a/src/Compiler/xlf/FSStrings.ko.xlf b/src/Compiler/xlf/FSStrings.ko.xlf
index bafe727c644..c16c466ebc4 100644
--- a/src/Compiler/xlf/FSStrings.ko.xlf
+++ b/src/Compiler/xlf/FSStrings.ko.xlf
@@ -4,7 +4,7 @@
     <body>
       <trans-unit id="ErrorFromAddingTypeEquationTuples">
         <source>Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</source>
-        <target state="new">Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</target>
+        <target state="translated">유형 불일치. 형식이 \n    {1}이고 길이가 {0}인 튜플이 필요합니다.    \n그러나 형식이 \n    {3}이고 길이가 {2}인 튜플이 제공되었습니다.{4}\n</target>
         <note />
       </trans-unit>
       <trans-unit id="HashLoadedSourceHasIssues0">
@@ -14,7 +14,7 @@
       </trans-unit>
       <trans-unit id="NotUpperCaseConstructorWithoutRQA">
         <source>Lowercase discriminated union cases are only allowed when using RequireQualifiedAccess attribute</source>
-        <target state="new">Lowercase discriminated union cases are only allowed when using RequireQualifiedAccess attribute</target>
+        <target state="translated">소문자로 구분된 공용 구조체 케이스는 RequireQualifiedAccess 특성을 사용하는 경우에만 허용됩니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="Parser.TOKEN.DOT.DOT.HAT">
@@ -1564,7 +1564,7 @@
       </trans-unit>
       <trans-unit id="IntfImplInIntrinsicAugmentation">
         <source>Interface implementations should normally be given on the initial declaration of a type. Interface implementations in augmentations may lead to accessing static bindings before they are initialized, though only if the interface implementation is invoked during initialization of the static data, and in turn access the static data. You may remove this warning using #nowarn "69" if you have checked this is not the case.</source>
-        <target state="needs-review-translation">확대의 인터페이스 구현은 이제 사용되지 않습니다. 인터페이스 구현은 초기 형식 선언 시 지정해야 합니다.</target>
+        <target state="translated">인터페이스 구현은 일반적으로 유형의 초기 선언에 제공되어야 합니다. 확대의 인터페이스 구현은 초기화되기 전에 정적 바인딩에 액세스할 수 있지만 정적 데이터의 초기화 중에 인터페이스 구현이 호출되어 정적 데이터에 액세스하는 경우에만 가능합니다. 사실이 아님을 확인한 경우 #nowarn "69"를 사용하여 이 경고를 제거할 수 있습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="IntfImplInExtrinsicAugmentation">
diff --git a/src/Compiler/xlf/FSStrings.pl.xlf b/src/Compiler/xlf/FSStrings.pl.xlf
index 3040e343b9d..385be4e2a2a 100644
--- a/src/Compiler/xlf/FSStrings.pl.xlf
+++ b/src/Compiler/xlf/FSStrings.pl.xlf
@@ -4,7 +4,7 @@
     <body>
       <trans-unit id="ErrorFromAddingTypeEquationTuples">
         <source>Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</source>
-        <target state="new">Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</target>
+        <target state="translated">Niezgodność. Oczekiwano krotki o długości {0} typu\n    {1}    \nale otrzymano krotkę o długości {2} typu\n    {3}{4}\n</target>
         <note />
       </trans-unit>
       <trans-unit id="HashLoadedSourceHasIssues0">
@@ -14,7 +14,7 @@
       </trans-unit>
       <trans-unit id="NotUpperCaseConstructorWithoutRQA">
         <source>Lowercase discriminated union cases are only allowed when using RequireQualifiedAccess attribute</source>
-        <target state="new">Lowercase discriminated union cases are only allowed when using RequireQualifiedAccess attribute</target>
+        <target state="translated">Przypadki unii z dyskryminatorem z małymi literami są dozwolone tylko w przypadku używania atrybutu RequireQualifiedAccess</target>
         <note />
       </trans-unit>
       <trans-unit id="Parser.TOKEN.DOT.DOT.HAT">
@@ -1564,7 +1564,7 @@
       </trans-unit>
       <trans-unit id="IntfImplInIntrinsicAugmentation">
         <source>Interface implementations should normally be given on the initial declaration of a type. Interface implementations in augmentations may lead to accessing static bindings before they are initialized, though only if the interface implementation is invoked during initialization of the static data, and in turn access the static data. You may remove this warning using #nowarn "69" if you have checked this is not the case.</source>
-        <target state="needs-review-translation">Implementacje interfejsów w powiększeniach są teraz przestarzałe. Implementacje interfejsów powinny występować w początkowej deklaracji typu.</target>
+        <target state="translated">Implementacje interfejsu powinny być zwykle podane w początkowej deklaracji typu. Implementacje interfejsu w rozszerzeniach mogą prowadzić do uzyskania dostępu do powiązań statycznych przed ich zainicjowaniem, chociaż tylko wtedy, gdy implementacja interfejsu jest wywoływana podczas inicjowania danych statycznych i z kolei uzyskuje dostęp do danych statycznych. To ostrzeżenie można usunąć przy użyciu #nowarn "69" jeśli zaznaczono, że tak nie jest.</target>
         <note />
       </trans-unit>
       <trans-unit id="IntfImplInExtrinsicAugmentation">
diff --git a/src/Compiler/xlf/FSStrings.pt-BR.xlf b/src/Compiler/xlf/FSStrings.pt-BR.xlf
index d17084376b1..8fa1e1ee33d 100644
--- a/src/Compiler/xlf/FSStrings.pt-BR.xlf
+++ b/src/Compiler/xlf/FSStrings.pt-BR.xlf
@@ -4,7 +4,7 @@
     <body>
       <trans-unit id="ErrorFromAddingTypeEquationTuples">
         <source>Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</source>
-        <target state="new">Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</target>
+        <target state="translated">Tipo incompatível. Esperando uma tupla de comprimento {0} do tipo\n    {1}    \nmas recebeu uma tupla de comprimento {2} do tipo\n    {3}{4}\n</target>
         <note />
       </trans-unit>
       <trans-unit id="HashLoadedSourceHasIssues0">
@@ -14,7 +14,7 @@
       </trans-unit>
       <trans-unit id="NotUpperCaseConstructorWithoutRQA">
         <source>Lowercase discriminated union cases are only allowed when using RequireQualifiedAccess attribute</source>
-        <target state="new">Lowercase discriminated union cases are only allowed when using RequireQualifiedAccess attribute</target>
+        <target state="translated">Os casos de união discriminados em letras minúsculas só são permitidos ao usar o atributo RequireQualifiedAccess</target>
         <note />
       </trans-unit>
       <trans-unit id="Parser.TOKEN.DOT.DOT.HAT">
@@ -1564,7 +1564,7 @@
       </trans-unit>
       <trans-unit id="IntfImplInIntrinsicAugmentation">
         <source>Interface implementations should normally be given on the initial declaration of a type. Interface implementations in augmentations may lead to accessing static bindings before they are initialized, though only if the interface implementation is invoked during initialization of the static data, and in turn access the static data. You may remove this warning using #nowarn "69" if you have checked this is not the case.</source>
-        <target state="needs-review-translation">Implementações de interface em aumentos agora são preteridas. Implementações de interface devem ser dadas nas declarações de tipo iniciais.</target>
+        <target state="translated">As implementações de interface normalmente devem ser fornecidas na declaração inicial de um tipo. As implementações de interface em aumentos podem levar ao acesso a associações estáticas antes de serem inicializadas, embora somente se a implementação de interface for chamada durante a inicialização dos dados estáticos e, por sua vez, o acesso aos dados estáticos. Você pode remover este aviso usando #nowarn "69" se tiver verificado que não é o caso.</target>
         <note />
       </trans-unit>
       <trans-unit id="IntfImplInExtrinsicAugmentation">
diff --git a/src/Compiler/xlf/FSStrings.ru.xlf b/src/Compiler/xlf/FSStrings.ru.xlf
index 3ff9aaf3df5..27b87f0c6b0 100644
--- a/src/Compiler/xlf/FSStrings.ru.xlf
+++ b/src/Compiler/xlf/FSStrings.ru.xlf
@@ -4,7 +4,7 @@
     <body>
       <trans-unit id="ErrorFromAddingTypeEquationTuples">
         <source>Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</source>
-        <target state="new">Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</target>
+        <target state="translated">Несоответствие типов. Ожидается кортеж длиной {0} типа\n    {1},    \nно предоставлен кортеж длиной {2} типа\n    {3}{4}\n</target>
         <note />
       </trans-unit>
       <trans-unit id="HashLoadedSourceHasIssues0">
@@ -14,7 +14,7 @@
       </trans-unit>
       <trans-unit id="NotUpperCaseConstructorWithoutRQA">
         <source>Lowercase discriminated union cases are only allowed when using RequireQualifiedAccess attribute</source>
-        <target state="new">Lowercase discriminated union cases are only allowed when using RequireQualifiedAccess attribute</target>
+        <target state="translated">Размеченные в нижнем регистре случаи объединения разрешены только при использовании атрибута RequireQualifiedAccess</target>
         <note />
       </trans-unit>
       <trans-unit id="Parser.TOKEN.DOT.DOT.HAT">
@@ -1564,7 +1564,7 @@
       </trans-unit>
       <trans-unit id="IntfImplInIntrinsicAugmentation">
         <source>Interface implementations should normally be given on the initial declaration of a type. Interface implementations in augmentations may lead to accessing static bindings before they are initialized, though only if the interface implementation is invoked during initialization of the static data, and in turn access the static data. You may remove this warning using #nowarn "69" if you have checked this is not the case.</source>
-        <target state="needs-review-translation">Реализации интерфейсов в приращениях теперь являются не рекомендуемыми к использованию. Реализации интерфейсов должны быть даны при первичном объявлении типа.</target>
+        <target state="translated">Реализации интерфейса обычно следует указывать при первоначальном объявлении типа. Реализации интерфейса в приращениях могут привести к доступу к статическим привязкам до их инициализации, но только в том случае, если реализация интерфейса вызвана во время инициализации статических данных. Это, в свою очередь, приведет к доступу к статическим данным. Это предупреждение можно удалить с помощью #nowarn "69", если вы убедились, что это не так.</target>
         <note />
       </trans-unit>
       <trans-unit id="IntfImplInExtrinsicAugmentation">
diff --git a/src/Compiler/xlf/FSStrings.tr.xlf b/src/Compiler/xlf/FSStrings.tr.xlf
index 4037386bdb6..fe1b018c46e 100644
--- a/src/Compiler/xlf/FSStrings.tr.xlf
+++ b/src/Compiler/xlf/FSStrings.tr.xlf
@@ -4,7 +4,7 @@
     <body>
       <trans-unit id="ErrorFromAddingTypeEquationTuples">
         <source>Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</source>
-        <target state="new">Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</target>
+        <target state="translated">Tür uyuşmazlığı. {0} uzunluğunda türü\n {1} \nolan bir demet bekleniyordu ancak {2} uzunluğunda türü\n    {3}{4}\nolan bir demet verildi</target>
         <note />
       </trans-unit>
       <trans-unit id="HashLoadedSourceHasIssues0">
@@ -14,7 +14,7 @@
       </trans-unit>
       <trans-unit id="NotUpperCaseConstructorWithoutRQA">
         <source>Lowercase discriminated union cases are only allowed when using RequireQualifiedAccess attribute</source>
-        <target state="new">Lowercase discriminated union cases are only allowed when using RequireQualifiedAccess attribute</target>
+        <target state="translated">Küçük harf ayrımlı birleşim durumlarına yalnızca RequireQualifiedAccess özniteliği kullanılırken izin verilir</target>
         <note />
       </trans-unit>
       <trans-unit id="Parser.TOKEN.DOT.DOT.HAT">
@@ -1564,7 +1564,7 @@
       </trans-unit>
       <trans-unit id="IntfImplInIntrinsicAugmentation">
         <source>Interface implementations should normally be given on the initial declaration of a type. Interface implementations in augmentations may lead to accessing static bindings before they are initialized, though only if the interface implementation is invoked during initialization of the static data, and in turn access the static data. You may remove this warning using #nowarn "69" if you have checked this is not the case.</source>
-        <target state="needs-review-translation">Genişletmelerdeki arabirim uygulamaları artık kullanım dışı bırakıldı. Arabirim uygulamaları bir türün ilk bildiriminde verilmelidir.</target>
+        <target state="translated">Arabirim uygulamaları normalde bir türün ilk bildiriminde verilmelidir. Genişletmelerdeki arabirim uygulamaları, başlatılmadan önce statik bağlamalara erişilmesine neden olabilirse de bu yalnızca arabirim uygulaması statik verilerin başlatılması sırasında çağrılmışsa ve buna bağlı olarak statik verilere erişiyorsa olur. Bunun söz konusu olmadığından eminseniz #nowarn "69" seçeneğini kullanarak bu uyarıyı kaldırabilirsiniz.</target>
         <note />
       </trans-unit>
       <trans-unit id="IntfImplInExtrinsicAugmentation">
diff --git a/src/Compiler/xlf/FSStrings.zh-Hans.xlf b/src/Compiler/xlf/FSStrings.zh-Hans.xlf
index 9cd326e3dd7..89cac4d4d7a 100644
--- a/src/Compiler/xlf/FSStrings.zh-Hans.xlf
+++ b/src/Compiler/xlf/FSStrings.zh-Hans.xlf
@@ -4,7 +4,7 @@
     <body>
       <trans-unit id="ErrorFromAddingTypeEquationTuples">
         <source>Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</source>
-        <target state="new">Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</target>
+        <target state="translated">类型不匹配。应为长度为 {0} 的类型的元组\n    {1}    \n但提供了长度为 {2} 的类型的元组\n    {3}{4}\n</target>
         <note />
       </trans-unit>
       <trans-unit id="HashLoadedSourceHasIssues0">
@@ -14,7 +14,7 @@
       </trans-unit>
       <trans-unit id="NotUpperCaseConstructorWithoutRQA">
         <source>Lowercase discriminated union cases are only allowed when using RequireQualifiedAccess attribute</source>
-        <target state="new">Lowercase discriminated union cases are only allowed when using RequireQualifiedAccess attribute</target>
+        <target state="translated">仅当使用 RequireQualifiedAccess 属性时才允许区分小写的联合事例</target>
         <note />
       </trans-unit>
       <trans-unit id="Parser.TOKEN.DOT.DOT.HAT">
@@ -1564,7 +1564,7 @@
       </trans-unit>
       <trans-unit id="IntfImplInIntrinsicAugmentation">
         <source>Interface implementations should normally be given on the initial declaration of a type. Interface implementations in augmentations may lead to accessing static bindings before they are initialized, though only if the interface implementation is invoked during initialization of the static data, and in turn access the static data. You may remove this warning using #nowarn "69" if you have checked this is not the case.</source>
-        <target state="needs-review-translation">扩大中的接口实现现已弃用。应在类型的初始声明中提供接口实现。</target>
+        <target state="translated">通常应在类型的初始声明中提供接口实现。扩充中的接口实现可能会导致在初始化静态绑定之前访问静态绑定，尽管只有在静态数据初始化期间调用了接口实现，并进而访问静态数据时才会发生这种情况。如果已经核实并非如此，则可以使用 #nowarn "69" 移除此警告。</target>
         <note />
       </trans-unit>
       <trans-unit id="IntfImplInExtrinsicAugmentation">
diff --git a/src/Compiler/xlf/FSStrings.zh-Hant.xlf b/src/Compiler/xlf/FSStrings.zh-Hant.xlf
index 30cdcc66af5..18f0ea682d6 100644
--- a/src/Compiler/xlf/FSStrings.zh-Hant.xlf
+++ b/src/Compiler/xlf/FSStrings.zh-Hant.xlf
@@ -4,7 +4,7 @@
     <body>
       <trans-unit id="ErrorFromAddingTypeEquationTuples">
         <source>Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</source>
-        <target state="new">Type mismatch. Expecting a tuple of length {0} of type\n    {1}    \nbut given a tuple of length {2} of type\n    {3}    {4}\n</target>
+        <target state="translated">類型不符。必須是類型為\n    {1}    \n 的元組長度 {0}，但提供的是類型為\n    {3}{4}\n 的元組長度 {2}</target>
         <note />
       </trans-unit>
       <trans-unit id="HashLoadedSourceHasIssues0">
@@ -1564,7 +1564,7 @@
       </trans-unit>
       <trans-unit id="IntfImplInIntrinsicAugmentation">
         <source>Interface implementations should normally be given on the initial declaration of a type. Interface implementations in augmentations may lead to accessing static bindings before they are initialized, though only if the interface implementation is invoked during initialization of the static data, and in turn access the static data. You may remove this warning using #nowarn "69" if you have checked this is not the case.</source>
-        <target state="needs-review-translation">增強指定中的介面實作現在已被取代。應該在類型的初始宣告上指定介面實作。</target>
+        <target state="translated">通常應該在類型的初始宣告上指定介面實作。擴增中的介面實作可能會在初始化之前存取靜態繫結，但只有在初始化靜態資料時叫用介面實作，並依序存取靜態資料。如果您未檢查過這種情況，可以使用 #nowarn 「69」 移除此警告。</target>
         <note />
       </trans-unit>
       <trans-unit id="IntfImplInExtrinsicAugmentation">
diff --git a/src/FSharp.Core/ILLink.LinkAttributes.xml b/src/FSharp.Core/ILLink.LinkAttributes.xml
index 3e70f972b8a..e4493298d41 100644
--- a/src/FSharp.Core/ILLink.LinkAttributes.xml
+++ b/src/FSharp.Core/ILLink.LinkAttributes.xml
@@ -83,6 +83,9 @@
     <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>
@@ -164,4 +167,4 @@
       <attribute internal="RemoveAttributeInstances" />
     </type>
   </assembly>
-</linker>
\ No newline at end of file
+</linker>
diff --git a/src/FSharp.Core/Linq.fs b/src/FSharp.Core/Linq.fs
index 6b62eccb93e..040ccebfa91 100644
--- a/src/FSharp.Core/Linq.fs
+++ b/src/FSharp.Core/Linq.fs
@@ -36,7 +36,6 @@ module LeafExpressionConverter =
         {   varEnv : Map<Var, Expression> }
     let asExpr x = (x :> Expression)
 
-    let bindingFlags = BindingFlags.Public ||| BindingFlags.NonPublic
     let instanceBindingFlags = BindingFlags.Instance ||| BindingFlags.Public ||| BindingFlags.NonPublic ||| BindingFlags.DeclaredOnly
 
     let isNamedType(typ:Type) = not (typ.IsArray || typ.IsByRef || typ.IsPointer)
@@ -55,9 +54,6 @@ module LeafExpressionConverter =
         let tyargs = typ.GetGenericArguments()
         tyargs.[0], tyargs.[1]
 
-    let GetGenericMethodDefinition (methInfo:MethodInfo) =
-        if methInfo.IsGenericMethod then methInfo.GetGenericMethodDefinition() else methInfo
-
     let StringConcat =
        methodhandleof (fun (x:obj, y:obj) -> String.Concat (x, y))
        |> System.Reflection.MethodInfo.GetMethodFromHandle
@@ -72,9 +68,6 @@ module LeafExpressionConverter =
 
     let showAll =
         BindingFlags.Public ||| BindingFlags.NonPublic
-
-    let NullableConstructor =
-        typedefof<Nullable<int>>.GetConstructors().[0]
     
     let getNonNullableType typ = match Nullable.GetUnderlyingType typ with null -> typ | t -> t
 
diff --git a/src/FSharp.Core/array2.fs b/src/FSharp.Core/array2.fs
index 1820a66cee1..0b04b0b1ca0 100644
--- a/src/FSharp.Core/array2.fs
+++ b/src/FSharp.Core/array2.fs
@@ -52,12 +52,7 @@ module Array2D =
     [<CompiledName("ZeroCreateBased")>]
     let zeroCreateBased (base1:int) (base2:int) (length1:int) (length2:int) = 
         if base1 = 0 && base2 = 0 then 
-#if NETSTANDARD
-            zeroCreate length1 length2
-#else                
-            // Note: this overload is available on Compact Framework and Silverlight, but not Portable
-            (System.Array.CreateInstance(typeof<'T>, [|length1;length2|]) :?> 'T[,])
-#endif                
+            zeroCreate length1 length2               
         else
             (Array.CreateInstance(typeof<'T>, [|length1;length2|], [|base1;base2|]) :?> 'T[,])
 
diff --git a/src/FSharp.Core/eventmodule.fs b/src/FSharp.Core/eventmodule.fs
index fc3c2eabd64..00ab9d069b2 100644
--- a/src/FSharp.Core/eventmodule.fs
+++ b/src/FSharp.Core/eventmodule.fs
@@ -8,10 +8,6 @@ open Microsoft.FSharp.Control
 [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
 [<RequireQualifiedAccess>]
 module Event =
-    [<CompiledName("Create")>]
-    let create<'T> () =
-        let ev = new Event<'T>()
-        ev.Trigger, ev.Publish
 
     [<CompiledName("Map")>]
     let map mapping (sourceEvent: IEvent<'Delegate, 'T>) =
diff --git a/src/FSharp.Core/fslib-extra-pervasives.fs b/src/FSharp.Core/fslib-extra-pervasives.fs
index 01fd7018b11..234b4fdb8fe 100644
--- a/src/FSharp.Core/fslib-extra-pervasives.fs
+++ b/src/FSharp.Core/fslib-extra-pervasives.fs
@@ -51,10 +51,7 @@ module ExtraTopLevelOperators =
             makeSafeKey: 'Key -> 'SafeKey,
             getKey: 'SafeKey -> 'Key
         ) =
-#if NETSTANDARD
-        static let emptyEnumerator =
-            (Array.empty<KeyValuePair<'Key, 'T>> :> seq<_>).GetEnumerator()
-#endif
+
         member _.Count = t.Count
 
         // Give a read-only view of the dictionary
@@ -169,47 +166,8 @@ module ExtraTopLevelOperators =
             member _.GetEnumerator() =
                 // We use an array comprehension here instead of seq {} as otherwise we get incorrect
                 // IEnumerator.Reset() and IEnumerator.Current semantics.
-                // Coreclr has a bug with SZGenericEnumerators --- implement a correct enumerator.  On desktop use the desktop implementation because it's ngened.
-#if !NETSTANDARD
                 let kvps = [| for (KeyValue (k, v)) in t -> KeyValuePair(getKey k, v) |] :> seq<_>
                 kvps.GetEnumerator()
-#else
-                let endIndex = t.Count
-
-                if endIndex = 0 then
-                    emptyEnumerator
-                else
-                    let kvps = [| for (KeyValue (k, v)) in t -> KeyValuePair(getKey k, v) |]
-                    let mutable index = -1
-
-                    let current () =
-                        if index < 0 then
-                            raise <| InvalidOperationException(SR.GetString(SR.enumerationNotStarted))
-
-                        if index >= endIndex then
-                            raise <| InvalidOperationException(SR.GetString(SR.enumerationAlreadyFinished))
-
-                        kvps.[index]
-
-                    { new IEnumerator<_> with
-                        member _.Current = current ()
-                      interface System.Collections.IEnumerator with
-                          member _.Current = box (current ())
-
-                          member _.MoveNext() =
-                              if index < endIndex then
-                                  index <- index + 1
-                                  index < endIndex
-                              else
-                                  false
-
-                          member _.Reset() =
-                              index <- -1
-                      interface System.IDisposable with
-                          member _.Dispose() =
-                              ()
-                    }
-#endif
 
         interface System.Collections.IEnumerable with
             member _.GetEnumerator() =
@@ -325,10 +283,6 @@ module ExtraTopLevelOperators =
     let eprintfn format =
         Printf.eprintfn format
 
-    [<CompiledName("FailWith")>]
-    let failwith s =
-        raise (Failure s)
-
     [<CompiledName("DefaultAsyncBuilder")>]
     let async = AsyncBuilder()
 
diff --git a/src/FSharp.Core/map.fs b/src/FSharp.Core/map.fs
index 9fad005450e..2535dff7522 100644
--- a/src/FSharp.Core/map.fs
+++ b/src/FSharp.Core/map.fs
@@ -882,6 +882,41 @@ type Map<[<EqualityConditionalOn>] 'Key, [<EqualityConditionalOn; ComparisonCond
     override this.GetHashCode() =
         this.ComputeHashCode()
 
+    interface IStructuralEquatable with
+        member this.Equals(that, comparer) =
+            match that with
+            | :? Map<'Key, 'Value> as that ->
+                use e1 = (this :> seq<_>).GetEnumerator()
+                use e2 = (that :> seq<_>).GetEnumerator()
+
+                let rec loop () =
+                    let m1 = e1.MoveNext()
+                    let m2 = e2.MoveNext()
+
+                    (m1 = m2)
+                    && (not m1
+                        || (let e1c = e1.Current
+                            let e2c = e2.Current
+
+                            (comparer.Equals(e1c.Key, e2c.Key)
+                             && comparer.Equals(e1c.Value, e2c.Value)
+                             && loop ())))
+
+                loop ()
+            | _ -> false
+
+        member this.GetHashCode(comparer) =
+            let combineHash x y =
+                (x <<< 1) + y + 631
+
+            let mutable res = 0
+
+            for (KeyValue (x, y)) in this do
+                res <- combineHash res (comparer.GetHashCode x)
+                res <- combineHash res (comparer.GetHashCode y)
+
+            res
+
     interface IEnumerable<KeyValuePair<'Key, 'Value>> with
         member _.GetEnumerator() =
             MapTree.mkIEnumerator tree
diff --git a/src/FSharp.Core/map.fsi b/src/FSharp.Core/map.fsi
index b560950ffbd..abf960909a2 100644
--- a/src/FSharp.Core/map.fsi
+++ b/src/FSharp.Core/map.fsi
@@ -210,6 +210,7 @@ type Map<[<EqualityConditionalOn>] 'Key, [<EqualityConditionalOn; ComparisonCond
     interface ICollection<KeyValuePair<'Key, 'Value>>
     interface IEnumerable<KeyValuePair<'Key, 'Value>>
     interface System.IComparable
+    interface System.Collections.IStructuralEquatable
     interface System.Collections.IEnumerable
     interface IReadOnlyCollection<KeyValuePair<'Key, 'Value>>
     interface IReadOnlyDictionary<'Key, 'Value>
diff --git a/src/FSharp.Core/observable.fsi b/src/FSharp.Core/observable.fsi
index bc371965090..b415b7c3086 100644
--- a/src/FSharp.Core/observable.fsi
+++ b/src/FSharp.Core/observable.fsi
@@ -135,7 +135,6 @@ module Observable =
     /// let observableNumbers = Observable.ToObservable numbers
     ///
     /// let isEvenNumber = fun number -> number % 2 = 0
-    /// let initialState = 2
     ///
     /// let leftPartition, rightPartition =
     ///     Observable.partition isEvenNumber observableNumbers
diff --git a/src/FSharp.Core/prim-types.fs b/src/FSharp.Core/prim-types.fs
index 604abae7688..6f01684de09 100644
--- a/src/FSharp.Core/prim-types.fs
+++ b/src/FSharp.Core/prim-types.fs
@@ -1601,11 +1601,6 @@ namespace Microsoft.FSharp.Core
                   when 'T : string  = System.String.Equals((# "" x : string #),(# "" y : string #))                  
                   when 'T : decimal = System.Decimal.op_Equality((# "" x:decimal #), (# "" y:decimal #))
                   when 'T : DateTime = DateTime.Equals((# "" x : DateTime #), (# "" y : DateTime #))
-                  
-
-            let inline GenericInequalityFast (x:'T) (y:'T) = (not(GenericEqualityFast x y) : bool)
-            let inline GenericInequalityERFast (x:'T) (y:'T) = (not(GenericEqualityERFast x y) : bool)
-
 
             //-------------------------------------------------------------------------
             // LanguagePrimitives.HashCompare: HASHING.  
@@ -3912,6 +3907,16 @@ namespace Microsoft.FSharp.Collections
     type List<'T> = 
        | ([])  :                  'T list
        | ( :: )  : Head: 'T * Tail: 'T list -> 'T list
+       member private this.CustomHashCode(c:IEqualityComparer) =        
+            let rec loop l acc position =
+                match l with
+                | [] -> acc           
+                | h::t ->
+                    let hashOfH = GenericHashWithComparer c h
+                    let acc = LanguagePrimitives.HashCompare.HashCombine position acc hashOfH
+                    loop t acc (position+1)
+
+            loop this 0 0
        interface IEnumerable<'T>
        interface IEnumerable
        interface IReadOnlyCollection<'T>
diff --git a/src/FSharp.Core/quotations.fs b/src/FSharp.Core/quotations.fs
index 20f2e8ca06b..0115811553a 100644
--- a/src/FSharp.Core/quotations.fs
+++ b/src/FSharp.Core/quotations.fs
@@ -489,15 +489,9 @@ module Patterns =
     let EA (t, attribs) =
         new Expr(t, attribs)
 
-    let ES ts =
-        List.map E ts
-
     let (|E|) (e: Expr) =
         e.Tree
 
-    let (|ES|) (es: Expr list) =
-        es |> List.map (fun e -> e.Tree)
-
     let (|FrontAndBack|_|) es =
         let rec loop acc xs =
             match xs with
@@ -515,9 +509,6 @@ module Patterns =
     let removeVoid a =
         if a = voidTy then unitTy else a
 
-    let addVoid a =
-        if a = unitTy then voidTy else a
-
     let mkFunTy a b =
         let (a, b) = removeVoid a, removeVoid b
         funTyC.MakeGenericType([| a; b |])
@@ -964,9 +955,6 @@ module Patterns =
     let mkFE3 op (x, y, z) =
         E(CombTerm(op, [ (x :> Expr); (y :> Expr); (z :> Expr) ]))
 
-    let mkOp v () =
-        v
-
     //--------------------------------------------------------------------------
     // Type-checked constructors for building Raw quotations
     //--------------------------------------------------------------------------
@@ -994,10 +982,6 @@ module Patterns =
             args
     // todo: shouldn't this be "strong" type check? sometimes?
 
-    let checkAssignableFrom ty1 ty2 =
-        if not (assignableFrom ty1 ty2) then
-            invalidArg "ty2" (SR.GetString(SR.QincorrectType))
-
     let checkObj (membInfo: MemberInfo) (obj: Expr) =
         // The MemberInfo may be a property associated with a union
         // find the actual related union type
@@ -1029,14 +1013,6 @@ module Patterns =
         | [| a; _ |] -> checkTypesSR vty a "f" (SR.GetString(SR.QtmmFunctionArgTypeMismatch))
         | _ -> invalidArg "f" (SR.GetString(SR.QinvalidFuncType))
 
-    // Returns option (by name) of a NewUnionCase type
-    let getUnionCaseFields ty str =
-        let cases = FSharpType.GetUnionCases(ty, publicOrPrivateBindingFlags)
-
-        match cases |> Array.tryFind (fun ucase -> ucase.Name = str) with
-        | Some case -> case.GetFields()
-        | _ -> invalidArg "ty" (String.Format(SR.GetString(SR.notAUnionType), ty.FullName))
-
     let checkBind (v: Var, e) =
         let ety = typeOf e
         checkTypesSR v.Type ety "let" (SR.GetString(SR.QtmmVarTypeNotMatchRHS))
@@ -1057,9 +1033,6 @@ module Patterns =
     let mkValueWithDefn (v, ty, defn) =
         mkFE1 (WithValueOp(v, ty)) defn
 
-    let mkValueG (v: 'T) =
-        mkValue (box v, typeof<'T>)
-
     let mkLiftedValueOpG (v, ty: System.Type) =
         let obj =
             if ty.IsEnum then
@@ -1099,9 +1072,6 @@ module Patterns =
     let mkCoerce (ty, x) =
         mkFE1 (CoerceOp ty) x
 
-    let mkNull (ty) =
-        mkFE0 (ValueOp(null, ty, None))
-
     let mkApplication v =
         checkAppliedLambda v
         mkFE2 AppOp v
@@ -1619,40 +1589,6 @@ module Patterns =
     let inst (tyargs: Type list) (i: Instantiable<'T>) =
         i (fun idx -> tyargs.[idx]) // Note, O n looks, but #tyargs is always small
 
-    let bindPropBySearchIfCandidateIsNull (ty: Type) propName retType argTypes candidate =
-        match candidate with
-        | null ->
-            let props =
-                ty.GetProperties staticOrInstanceBindingFlags
-                |> Array.filter (fun pi ->
-                    let paramTypes = getTypesFromParamInfos (pi.GetIndexParameters())
-
-                    pi.Name = propName
-                    && pi.PropertyType = retType
-                    && Array.length argTypes = paramTypes.Length
-                    && Array.forall2 (=) argTypes paramTypes)
-
-            match props with
-            | [| pi |] -> pi
-            | _ -> null
-        | pi -> pi
-
-    let bindCtorBySearchIfCandidateIsNull (ty: Type) argTypes candidate =
-        match candidate with
-        | null ->
-            let ctors =
-                ty.GetConstructors instanceBindingFlags
-                |> Array.filter (fun ci ->
-                    let paramTypes = getTypesFromParamInfos (ci.GetParameters())
-
-                    Array.length argTypes = paramTypes.Length
-                    && Array.forall2 (=) argTypes paramTypes)
-
-            match ctors with
-            | [| ctor |] -> ctor
-            | _ -> null
-        | ctor -> ctor
-
     let bindProp (genericType, propName, retType, argTypes, tyargs) =
         // We search in the instantiated type, rather than searching the generic type.
         let typ = mkNamedType (genericType, tyargs)
@@ -2347,21 +2283,6 @@ module Patterns =
     and freeInExpr e =
         freeInExprAcc Set.empty Set.empty e
 
-    // utility for folding
-    let foldWhile f st (ie: seq<'T>) =
-        use e = ie.GetEnumerator()
-        let mutable res = Some st
-
-        while (res.IsSome && e.MoveNext()) do
-            res <-
-                f
-                    (match res with
-                     | Some a -> a
-                     | _ -> failwith "internal error")
-                    e.Current
-
-        res
-
     [<NoEquality; NoComparison>]
     exception Clash of Var
 
diff --git a/src/FSharp.Core/reflect.fs b/src/FSharp.Core/reflect.fs
index e9522f68c99..6e0977e6edd 100644
--- a/src/FSharp.Core/reflect.fs
+++ b/src/FSharp.Core/reflect.fs
@@ -758,70 +758,12 @@ module internal Impl =
             tyargs
 
     let orderTupleProperties (props: PropertyInfo[]) =
-        // The tuple properties are of the form:
-        //   Item1
-        //   ..
-        //   Item1, Item2, ..., Item<maxTuple-1>
-        //   Item1, Item2, ..., Item<maxTuple-1>, Rest
-        // The PropertyInfo may not come back in order, so ensure ordering here.
-#if !NETSTANDARD
-        assert (maxTuple < 10) // Alphasort will only works for upto 9 items: Item1, Item10, Item2, Item3, ..., Item9, Rest
-#endif
-        let props = props |> Array.sortBy (fun p -> p.Name) // they are not always in alphabetic order
-#if !NETSTANDARD
-        assert (props.Length <= maxTuple)
-
-        assert
-            (let haveNames = props |> Array.map (fun p -> p.Name)
-
-             let expectNames =
-                 Array.init props.Length (fun i ->
-                     let j = i + 1 // index j = 1, 2, .., props.Length <= maxTuple
-
-                     if j < maxTuple then
-                         "Item" + string j
-                     elif j = maxTuple then
-                         "Rest"
-                     else
-                         (assert false
-                          "")) // dead code under prior assert, props.Length <= maxTuple
-
-             haveNames = expectNames)
-#endif
-        props
+        // The PropertyInfo[] may not come back in order, so ensure ordering here.
+        props |> Array.sortBy (fun p -> p.Name) // alphabetic works because there is max. 8 of them
 
     let orderTupleFields (fields: FieldInfo[]) =
-        // The tuple fields are of the form:
-        //   Item1
-        //   ..
-        //   Item1, Item2, ..., Item<maxTuple-1>
-        //   Item1, Item2, ..., Item<maxTuple-1>, Rest
-        // The PropertyInfo may not come back in order, so ensure ordering here.
-#if !NETSTANDARD
-        assert (maxTuple < 10) // Alphasort will only works for upto 9 items: Item1, Item10, Item2, Item3, ..., Item9, Rest
-#endif
-        let fields = fields |> Array.sortBy (fun fi -> fi.Name) // they are not always in alphabetic order
-#if !NETSTANDARD
-        assert (fields.Length <= maxTuple)
-
-        assert
-            (let haveNames = fields |> Array.map (fun fi -> fi.Name)
-
-             let expectNames =
-                 Array.init fields.Length (fun i ->
-                     let j = i + 1 // index j = 1, 2, .., fields.Length <= maxTuple
-
-                     if j < maxTuple then
-                         "Item" + string j
-                     elif j = maxTuple then
-                         "Rest"
-                     else
-                         (assert false
-                          "")) // dead code under prior assert, props.Length <= maxTuple
-
-             haveNames = expectNames)
-#endif
-        fields
+        // The FieldInfo[] may not come back in order, so ensure ordering here.
+        fields |> Array.sortBy (fun fi -> fi.Name) // alphabetic works because there is max. 8 of them
 
     let getTupleConstructorMethod (typ: Type) =
         let ctor =
diff --git a/src/FSharp.Core/result.fs b/src/FSharp.Core/result.fs
index 00ec26d05d8..63a63435653 100644
--- a/src/FSharp.Core/result.fs
+++ b/src/FSharp.Core/result.fs
@@ -101,12 +101,6 @@ module Result =
         | Error _ -> []
         | Ok x -> [ x ]
 
-    [<CompiledName("ToSeq")>]
-    let toSeq result =
-        match result with
-        | Error _ -> []
-        | Ok x -> [ x ]
-
     [<CompiledName("ToOption")>]
     let toOption result =
         match result with
diff --git a/src/FSharp.Core/result.fsi b/src/FSharp.Core/result.fsi
index 2641fd1eff3..837f8b4d06c 100644
--- a/src/FSharp.Core/result.fsi
+++ b/src/FSharp.Core/result.fsi
@@ -281,7 +281,7 @@ module Result =
     /// </code>
     /// </example>
     [<CompiledName("ToList")>]
-    val toList: result: Result<'T, 'Error> -> List<'T>
+    val toList: result: Result<'T, 'Error> -> 'T list
 
     /// <summary>Convert the result to an Option value.</summary>
     ///
@@ -296,7 +296,7 @@ module Result =
     /// </code>
     /// </example>
     [<CompiledName("ToOption")>]
-    val toOption: result: Result<'T, 'Error> -> Option<'T>
+    val toOption: result: Result<'T, 'Error> -> 'T option
 
     /// <summary>Convert the result to an Option value.</summary>
     ///
@@ -311,4 +311,4 @@ module Result =
     /// </code>
     /// </example>
     [<CompiledName("ToValueOption")>]
-    val toValueOption: result: Result<'T, 'Error> -> ValueOption<'T>
+    val toValueOption: result: Result<'T, 'Error> -> 'T voption
diff --git a/src/FSharp.Core/resumable.fs b/src/FSharp.Core/resumable.fs
index 7e79af69aee..e63e79f92dd 100644
--- a/src/FSharp.Core/resumable.fs
+++ b/src/FSharp.Core/resumable.fs
@@ -116,9 +116,6 @@ module StateMachineHelpers =
 
 module ResumableCode =
 
-    let inline SetResumptionFunc (sm: byref<ResumableStateMachine<'Data>>) f =
-        sm.ResumptionDynamicInfo.ResumptionFunc <- f
-
     let inline GetResumptionFunc (sm: byref<ResumableStateMachine<'Data>>) =
         sm.ResumptionDynamicInfo.ResumptionFunc
 
diff --git a/src/FSharp.Core/seqcore.fs b/src/FSharp.Core/seqcore.fs
index 2b2b3b9e55b..dcfda570ba9 100644
--- a/src/FSharp.Core/seqcore.fs
+++ b/src/FSharp.Core/seqcore.fs
@@ -210,9 +210,6 @@ module RuntimeHelpers =
     let Generate openf compute closef =
         mkSeq (fun () -> new IEnumerator.GeneratedEnumerable<_,_>(openf, compute, closef) :> IEnumerator<'T>)
 
-    let GenerateUsing (openf : unit -> ('U :> System.IDisposable)) compute =
-        Generate openf compute (fun (s:'U) -> s.Dispose())
-
     let EnumerateFromFunctions create moveNext current =
         Generate
             create
diff --git a/src/FSharp.Core/set.fs b/src/FSharp.Core/set.fs
index f04cc12433e..4a1b9b42f57 100644
--- a/src/FSharp.Core/set.fs
+++ b/src/FSharp.Core/set.fs
@@ -872,7 +872,7 @@ type Set<[<EqualityConditionalOn>] 'T when 'T: comparison>(comparer: IComparer<'
     member x.ToArray() =
         SetTree.toArray x.Tree
 
-    member this.ComputeHashCode() =
+    member private this.ComputeHashCode() =
         let combineHash x y =
             (x <<< 1) + y + 631
 
@@ -904,6 +904,32 @@ type Set<[<EqualityConditionalOn>] 'T when 'T: comparison>(comparer: IComparer<'
         member this.CompareTo(that: obj) =
             SetTree.compare this.Comparer this.Tree ((that :?> Set<'T>).Tree)
 
+    interface IStructuralEquatable with
+        member this.Equals(that, comparer) =
+            match that with
+            | :? Set<'T> as that ->
+                use e1 = (this :> seq<_>).GetEnumerator()
+                use e2 = (that :> seq<_>).GetEnumerator()
+
+                let rec loop () =
+                    let m1 = e1.MoveNext()
+                    let m2 = e2.MoveNext()
+                    (m1 = m2) && (not m1 || ((comparer.Equals(e1.Current, e2.Current)) && loop ()))
+
+                loop ()
+            | _ -> false
+
+        member this.GetHashCode(comparer) =
+            let combineHash x y =
+                (x <<< 1) + y + 631
+
+            let mutable res = 0
+
+            for x in this do
+                res <- combineHash res (comparer.GetHashCode(x))
+
+            res
+
     interface ICollection<'T> with
         member s.Add x =
             ignore x
diff --git a/src/FSharp.Core/set.fsi b/src/FSharp.Core/set.fsi
index b1c51c87afb..f1c2fd291c2 100644
--- a/src/FSharp.Core/set.fsi
+++ b/src/FSharp.Core/set.fsi
@@ -229,6 +229,7 @@ type Set<[<EqualityConditionalOn>] 'T when 'T: comparison> =
     interface IEnumerable<'T>
     interface System.Collections.IEnumerable
     interface System.IComparable
+    interface System.Collections.IStructuralEquatable
     interface IReadOnlyCollection<'T>
     override Equals: obj -> bool
 
diff --git a/src/FSharp.Core/tasks.fs b/src/FSharp.Core/tasks.fs
index a52cae27310..13eb2a43a59 100644
--- a/src/FSharp.Core/tasks.fs
+++ b/src/FSharp.Core/tasks.fs
@@ -459,7 +459,7 @@ module MediumPriority =
                 computation: Async<'TResult1>,
                 continuation: ('TResult1 -> TaskCode<'TOverall, 'TResult2>)
             ) : TaskCode<'TOverall, 'TResult2> =
-            this.Bind(Async.StartAsTask computation, continuation)
+            this.Bind(Async.StartImmediateAsTask computation, continuation)
 
         member inline this.ReturnFrom(computation: Async<'T>) : TaskCode<'T, 'T> =
-            this.ReturnFrom(Async.StartAsTask computation)
+            this.ReturnFrom(Async.StartImmediateAsTask computation)
diff --git a/src/LegacyMSBuildResolver/LegacyMSBuildReferenceResolver.fs b/src/LegacyMSBuildResolver/LegacyMSBuildReferenceResolver.fs
index 977372d675a..80ee208263c 100644
--- a/src/LegacyMSBuildResolver/LegacyMSBuildReferenceResolver.fs
+++ b/src/LegacyMSBuildResolver/LegacyMSBuildReferenceResolver.fs
@@ -34,19 +34,6 @@ let DotNetFrameworkReferenceAssembliesRootDirectory =
 
     PF + @"\Reference Assemblies\Microsoft\Framework\.NETFramework"
 
-/// When targeting .NET 2.0-3.5 on Windows, we expand the {WindowsFramework} and {ReferenceAssemblies} paths manually
-let internal ReplaceVariablesForLegacyFxOnWindows (dirs: string list) =
-    let windowsFramework =
-        Environment.GetEnvironmentVariable("windir") + @"\Microsoft.NET\Framework"
-
-    let referenceAssemblies = DotNetFrameworkReferenceAssembliesRootDirectory
-
-    dirs
-    |> List.map (fun d ->
-        d
-            .Replace("{WindowsFramework}", windowsFramework)
-            .Replace("{ReferenceAssemblies}", referenceAssemblies))
-
 // ATTENTION!: the following code needs to be updated every time we are switching to the new MSBuild version because new .NET framework version was released
 // 1. List of frameworks
 // 2. DeriveTargetFrameworkDirectoriesFor45Plus
diff --git a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.cs.xlf b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.cs.xlf
index fe16dc84f65..1efc72d39cc 100644
--- a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.cs.xlf
+++ b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.cs.xlf
@@ -4,22 +4,22 @@
     <body>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersExKey">
         <source>Found by AssemblyFoldersEx registry key</source>
-        <target state="new">Found by AssemblyFoldersEx registry key</target>
+        <target state="translated">Nalezené klíčem registru AssemblyFoldersEx</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersKey">
         <source>Found by AssemblyFolders registry key</source>
-        <target state="new">Found by AssemblyFolders registry key</target>
+        <target state="translated">Nalezené klíčem registru AssemblyFolders</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionGAC">
         <source>Global Assembly Cache</source>
-        <target state="new">Global Assembly Cache</target>
+        <target state="translated">Globální mezipaměť sestavení</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionNetFramework">
         <source>.NET Framework</source>
-        <target state="new">.NET Framework</target>
+        <target state="translated">.NET Framework</target>
         <note />
       </trans-unit>
     </body>
diff --git a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.de.xlf b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.de.xlf
index 0980cec838a..4f0a70cd829 100644
--- a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.de.xlf
+++ b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.de.xlf
@@ -4,22 +4,22 @@
     <body>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersExKey">
         <source>Found by AssemblyFoldersEx registry key</source>
-        <target state="new">Found by AssemblyFoldersEx registry key</target>
+        <target state="translated">Von AssemblyFoldersEx-Registrierungsschlüssel gefunden</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersKey">
         <source>Found by AssemblyFolders registry key</source>
-        <target state="new">Found by AssemblyFolders registry key</target>
+        <target state="translated">Von AssemblyFolders-Registrierungsschlüssel gefunden</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionGAC">
         <source>Global Assembly Cache</source>
-        <target state="new">Global Assembly Cache</target>
+        <target state="translated">Globaler Assemblycache</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionNetFramework">
         <source>.NET Framework</source>
-        <target state="new">.NET Framework</target>
+        <target state="translated">.NET Framework</target>
         <note />
       </trans-unit>
     </body>
diff --git a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.es.xlf b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.es.xlf
index ae938d2cacd..975fc66a829 100644
--- a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.es.xlf
+++ b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.es.xlf
@@ -4,22 +4,22 @@
     <body>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersExKey">
         <source>Found by AssemblyFoldersEx registry key</source>
-        <target state="new">Found by AssemblyFoldersEx registry key</target>
+        <target state="translated">Encontrado por la clave del Registro AssemblyFoldersEx.</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersKey">
         <source>Found by AssemblyFolders registry key</source>
-        <target state="new">Found by AssemblyFolders registry key</target>
+        <target state="translated">Encontrado por la clave del Registro AssemblyFolders.</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionGAC">
         <source>Global Assembly Cache</source>
-        <target state="new">Global Assembly Cache</target>
+        <target state="translated">Caché global de ensamblados</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionNetFramework">
         <source>.NET Framework</source>
-        <target state="new">.NET Framework</target>
+        <target state="translated">.NET Framework</target>
         <note />
       </trans-unit>
     </body>
diff --git a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.fr.xlf b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.fr.xlf
index 7fe41477230..a34c9a39ee7 100644
--- a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.fr.xlf
+++ b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.fr.xlf
@@ -4,22 +4,22 @@
     <body>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersExKey">
         <source>Found by AssemblyFoldersEx registry key</source>
-        <target state="new">Found by AssemblyFoldersEx registry key</target>
+        <target state="translated">Trouvée par la clé de Registre AssemblyFoldersEx</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersKey">
         <source>Found by AssemblyFolders registry key</source>
-        <target state="new">Found by AssemblyFolders registry key</target>
+        <target state="translated">Trouvée par la clé de Registre AssemblyFolders</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionGAC">
         <source>Global Assembly Cache</source>
-        <target state="new">Global Assembly Cache</target>
+        <target state="translated">Global Assembly Cache</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionNetFramework">
         <source>.NET Framework</source>
-        <target state="new">.NET Framework</target>
+        <target state="translated">.NET Framework</target>
         <note />
       </trans-unit>
     </body>
diff --git a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.it.xlf b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.it.xlf
index d20390cc87e..22d36262342 100644
--- a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.it.xlf
+++ b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.it.xlf
@@ -4,22 +4,22 @@
     <body>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersExKey">
         <source>Found by AssemblyFoldersEx registry key</source>
-        <target state="new">Found by AssemblyFoldersEx registry key</target>
+        <target state="translated">Trovata mediante chiave del Registro di sistema AssemblyFoldersEx</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersKey">
         <source>Found by AssemblyFolders registry key</source>
-        <target state="new">Found by AssemblyFolders registry key</target>
+        <target state="translated">Trovata mediante la chiave del Registro di sistema AssemblyFolders</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionGAC">
         <source>Global Assembly Cache</source>
-        <target state="new">Global Assembly Cache</target>
+        <target state="translated">Global Assembly Cache</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionNetFramework">
         <source>.NET Framework</source>
-        <target state="new">.NET Framework</target>
+        <target state="translated">.NET Framework</target>
         <note />
       </trans-unit>
     </body>
diff --git a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.ja.xlf b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.ja.xlf
index 2f2fbca84a3..a47832b3e62 100644
--- a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.ja.xlf
+++ b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.ja.xlf
@@ -4,22 +4,22 @@
     <body>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersExKey">
         <source>Found by AssemblyFoldersEx registry key</source>
-        <target state="new">Found by AssemblyFoldersEx registry key</target>
+        <target state="translated">AssemblyFoldersEx レジストリ キーによって検出されました</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersKey">
         <source>Found by AssemblyFolders registry key</source>
-        <target state="new">Found by AssemblyFolders registry key</target>
+        <target state="translated">AssemblyFolders レジストリ キーによって検出されました</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionGAC">
         <source>Global Assembly Cache</source>
-        <target state="new">Global Assembly Cache</target>
+        <target state="translated">グローバル アセンブリ キャッシュ</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionNetFramework">
         <source>.NET Framework</source>
-        <target state="new">.NET Framework</target>
+        <target state="translated">.NET Framework</target>
         <note />
       </trans-unit>
     </body>
diff --git a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.ko.xlf b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.ko.xlf
index a57ff6c0dc3..48bdb97ec18 100644
--- a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.ko.xlf
+++ b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.ko.xlf
@@ -4,22 +4,22 @@
     <body>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersExKey">
         <source>Found by AssemblyFoldersEx registry key</source>
-        <target state="new">Found by AssemblyFoldersEx registry key</target>
+        <target state="translated">AssemblyFoldersEx 레지스트리 키로 찾았습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersKey">
         <source>Found by AssemblyFolders registry key</source>
-        <target state="new">Found by AssemblyFolders registry key</target>
+        <target state="translated">AssemblyFolders 레지스트리 키로 찾았습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionGAC">
         <source>Global Assembly Cache</source>
-        <target state="new">Global Assembly Cache</target>
+        <target state="translated">전역 어셈블리 캐시</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionNetFramework">
         <source>.NET Framework</source>
-        <target state="new">.NET Framework</target>
+        <target state="translated">.NET Framework</target>
         <note />
       </trans-unit>
     </body>
diff --git a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.pl.xlf b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.pl.xlf
index 49133a8479c..8b27ac86275 100644
--- a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.pl.xlf
+++ b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.pl.xlf
@@ -4,22 +4,22 @@
     <body>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersExKey">
         <source>Found by AssemblyFoldersEx registry key</source>
-        <target state="new">Found by AssemblyFoldersEx registry key</target>
+        <target state="translated">Znalezione przez klucz rejestru AssemblyFoldersEx</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersKey">
         <source>Found by AssemblyFolders registry key</source>
-        <target state="new">Found by AssemblyFolders registry key</target>
+        <target state="translated">Znalezione przez klucz rejestru AssemblyFolders</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionGAC">
         <source>Global Assembly Cache</source>
-        <target state="new">Global Assembly Cache</target>
+        <target state="translated">Globalna pamięć podręczna zestawów</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionNetFramework">
         <source>.NET Framework</source>
-        <target state="new">.NET Framework</target>
+        <target state="translated">.NET Framework</target>
         <note />
       </trans-unit>
     </body>
diff --git a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.pt-BR.xlf b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.pt-BR.xlf
index fbfa95dbf16..8247129a519 100644
--- a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.pt-BR.xlf
+++ b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.pt-BR.xlf
@@ -4,22 +4,22 @@
     <body>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersExKey">
         <source>Found by AssemblyFoldersEx registry key</source>
-        <target state="new">Found by AssemblyFoldersEx registry key</target>
+        <target state="translated">Localizada pela chave de registro AssemblyFoldersEx</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersKey">
         <source>Found by AssemblyFolders registry key</source>
-        <target state="new">Found by AssemblyFolders registry key</target>
+        <target state="translated">Localizada pela chave de registro AssemblyFolders</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionGAC">
         <source>Global Assembly Cache</source>
-        <target state="new">Global Assembly Cache</target>
+        <target state="translated">Cache de Assembly Global</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionNetFramework">
         <source>.NET Framework</source>
-        <target state="new">.NET Framework</target>
+        <target state="translated">.NET Framework</target>
         <note />
       </trans-unit>
     </body>
diff --git a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.ru.xlf b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.ru.xlf
index c01f76a7296..4b4d86b480c 100644
--- a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.ru.xlf
+++ b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.ru.xlf
@@ -4,22 +4,22 @@
     <body>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersExKey">
         <source>Found by AssemblyFoldersEx registry key</source>
-        <target state="new">Found by AssemblyFoldersEx registry key</target>
+        <target state="translated">Найдено по разделу реестра AssemblyFoldersEx</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersKey">
         <source>Found by AssemblyFolders registry key</source>
-        <target state="new">Found by AssemblyFolders registry key</target>
+        <target state="translated">Найдено по разделу реестра AssemblyFolders</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionGAC">
         <source>Global Assembly Cache</source>
-        <target state="new">Global Assembly Cache</target>
+        <target state="translated">Глобальный кэш сборок</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionNetFramework">
         <source>.NET Framework</source>
-        <target state="new">.NET Framework</target>
+        <target state="translated">.NET Framework</target>
         <note />
       </trans-unit>
     </body>
diff --git a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.tr.xlf b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.tr.xlf
index 3131d7674af..f018b6eb8a3 100644
--- a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.tr.xlf
+++ b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.tr.xlf
@@ -4,22 +4,22 @@
     <body>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersExKey">
         <source>Found by AssemblyFoldersEx registry key</source>
-        <target state="new">Found by AssemblyFoldersEx registry key</target>
+        <target state="translated">AssemblyFoldersEx kayıt defteri anahtarı ile bulunur</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersKey">
         <source>Found by AssemblyFolders registry key</source>
-        <target state="new">Found by AssemblyFolders registry key</target>
+        <target state="translated">AssemblyFolders kayıt defteri anahtarı ile bulunur</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionGAC">
         <source>Global Assembly Cache</source>
-        <target state="new">Global Assembly Cache</target>
+        <target state="translated">Genel Bütünleştirilmiş Kod Önbelleği</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionNetFramework">
         <source>.NET Framework</source>
-        <target state="new">.NET Framework</target>
+        <target state="translated">.NET Framework</target>
         <note />
       </trans-unit>
     </body>
diff --git a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.zh-Hans.xlf b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.zh-Hans.xlf
index 7791accdff9..933560fc589 100644
--- a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.zh-Hans.xlf
+++ b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.zh-Hans.xlf
@@ -4,22 +4,22 @@
     <body>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersExKey">
         <source>Found by AssemblyFoldersEx registry key</source>
-        <target state="new">Found by AssemblyFoldersEx registry key</target>
+        <target state="translated">已由 AssemblyFoldersEx 注册表项找到</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersKey">
         <source>Found by AssemblyFolders registry key</source>
-        <target state="new">Found by AssemblyFolders registry key</target>
+        <target state="translated">已由 AssemblyFolders 注册表项找到</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionGAC">
         <source>Global Assembly Cache</source>
-        <target state="new">Global Assembly Cache</target>
+        <target state="translated">全局程序集缓存</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionNetFramework">
         <source>.NET Framework</source>
-        <target state="new">.NET Framework</target>
+        <target state="translated">.NET Framework</target>
         <note />
       </trans-unit>
     </body>
diff --git a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.zh-Hant.xlf b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.zh-Hant.xlf
index 52a305821cf..f01e41cc97e 100644
--- a/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.zh-Hant.xlf
+++ b/src/LegacyMSBuildResolver/xlf/LegacyResolver.txt.zh-Hant.xlf
@@ -4,22 +4,22 @@
     <body>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersExKey">
         <source>Found by AssemblyFoldersEx registry key</source>
-        <target state="new">Found by AssemblyFoldersEx registry key</target>
+        <target state="translated">依 AssemblyFoldersEx 登錄機碼找到</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionFoundByAssemblyFoldersKey">
         <source>Found by AssemblyFolders registry key</source>
-        <target state="new">Found by AssemblyFolders registry key</target>
+        <target state="translated">依 AssemblyFolders 登錄機碼找到</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionGAC">
         <source>Global Assembly Cache</source>
-        <target state="new">Global Assembly Cache</target>
+        <target state="translated">全域組件快取</target>
         <note />
       </trans-unit>
       <trans-unit id="assemblyResolutionNetFramework">
         <source>.NET Framework</source>
-        <target state="new">.NET Framework</target>
+        <target state="translated">.NET Framework</target>
         <note />
       </trans-unit>
     </body>
diff --git a/src/fsi/console.fs b/src/fsi/console.fs
index b64849394d3..4e68d2aea0b 100644
--- a/src/fsi/console.fs
+++ b/src/fsi/console.fs
@@ -104,6 +104,103 @@ module internal Utils =
             | ' ', false -> nextWordFromIdx line (idx + 1, false)
             | _, _ -> nextWordFromIdx line (idx + 1, true)
 
+    /// An array stores ranges of full-width chars.
+    ///
+    /// The ranges are sorted by increasing order in the array, and each range are stored in the 2nth and 2n+1th
+    /// position in the array (n is the ordinal number of the range)
+    ///
+    /// Array [| a; b; c; d |] represents range [a, b] or [c, d], means chars in these ranges are full-width.
+    ///
+    /// Definition: https://www.unicode.org/reports/tr11/
+    ///
+    /// Data source: https://www.unicode.org/Public/UCD/latest/ucd/EastAsianWidth.txt
+    let private fullWidthCharRanges =
+        Array.concat
+            [|
+                [| '\u1100'; '\u115f' |]
+                [| '\u231a'; '\u231b' |]
+                [| '\u2329'; '\u232a' |]
+                [| '\u23e9'; '\u23ec' |]
+                [| '\u23f0'; '\u23f0' |]
+                [| '\u23f3'; '\u23f3' |]
+                [| '\u25fd'; '\u25fe' |]
+                [| '\u2614'; '\u2615' |]
+                [| '\u2648'; '\u2653' |]
+                [| '\u267f'; '\u267f' |]
+                [| '\u2693'; '\u2693' |]
+                [| '\u26a1'; '\u26a1' |]
+                [| '\u26aa'; '\u26ab' |]
+                [| '\u26bd'; '\u26be' |]
+                [| '\u26c4'; '\u26c5' |]
+                [| '\u26ce'; '\u26ce' |]
+                [| '\u26d4'; '\u26d4' |]
+                [| '\u26ea'; '\u26ea' |]
+                [| '\u26f2'; '\u26f3' |]
+                [| '\u26f5'; '\u26f5' |]
+                [| '\u26fa'; '\u26fa' |]
+                [| '\u26fd'; '\u26fd' |]
+                [| '\u2705'; '\u2705' |]
+                [| '\u270a'; '\u270b' |]
+                [| '\u2728'; '\u2728' |]
+                [| '\u274c'; '\u274c' |]
+                [| '\u274e'; '\u274e' |]
+                [| '\u2753'; '\u2755' |]
+                [| '\u2757'; '\u2757' |]
+                [| '\u2795'; '\u2797' |]
+                [| '\u27b0'; '\u27b0' |]
+                [| '\u27bf'; '\u27bf' |]
+                [| '\u2b1b'; '\u2b1c' |]
+                [| '\u2b50'; '\u2b50' |]
+                [| '\u2b55'; '\u2b55' |]
+                [| '\u2e80'; '\u303e' |]
+                [| '\u3041'; '\u3096' |]
+                [| '\u3099'; '\u30ff' |]
+                [| '\u3105'; '\u312f' |]
+                [| '\u3131'; '\u318e' |]
+                [| '\u3190'; '\u3247' |]
+                [| '\u3250'; '\u4dbf' |]
+                [| '\u4e00'; '\ua4c6' |]
+                [| '\ua960'; '\ua97c' |]
+                [| '\uac00'; '\ud7a3' |]
+                [| '\uf900'; '\ufaff' |]
+                [| '\ufe10'; '\ufe1f' |]
+                [| '\ufe30'; '\ufe6b' |]
+                [| '\uff01'; '\uff60' |]
+                [| '\uffe0'; '\uffe6' |]
+            |]
+
+    let isFullWidth (char) =
+        // for array [| a; b; c; d |],
+        // if a value is in (a, b) or (c, d), the result of Array.BinarySearch will be a negative even number
+        // if a value is a, b, c, d, the result will be a positive number
+        let n = Array.BinarySearch(fullWidthCharRanges, char)
+        n >= 0 || n % 2 = 0
+
+    /// Limits BufferWidth to make sure that full-width characters will not be print to wrong position.
+    ///
+    /// The return value is Console.BufferWidth - 2.
+    ///
+    /// When printing full-width characters to the screen (such as 一二三四五六七八九零),
+    ///
+    /// if BufferWidth = Console.BufferWidth, the output will be
+    ///
+    /// #> 一二三四五六七八九零一二三四五六七八九  # (零 is missing)
+    ///
+    /// #一二三四五六七八九零                      #
+    ///
+    /// if BufferWidth = Console.BufferWidth - 1, the output will be
+    ///
+    /// #> 一二三四五六七八九零一二三四五六七八九零# (零 is printed, but will not correctly cauculate cursor position)
+    ///
+    /// #一二三四五六七八九零                      # (cursor may appear in the middle of the character)
+    ///
+    /// if BufferWidth = Console.BufferWidth - 2, the output will be
+    ///
+    /// #> 一二三四五六七八九零一二三四五六七八九  #
+    ///
+    /// #零一二三四五六七八九零                    # (work correctly)
+    let bufferWidth () = Console.BufferWidth - 2
+
 [<Sealed>]
 type internal Cursor =
     static member ResetTo(top, left) =
@@ -111,14 +208,12 @@ type internal Cursor =
             Console.CursorTop <- min top (Console.BufferHeight - 1)
             Console.CursorLeft <- left)
 
-    static member Move(inset, delta) =
-        let position =
-            Console.CursorTop * (Console.BufferWidth - inset)
-            + (Console.CursorLeft - inset)
-            + delta
+    static member Move(delta) =
+        let width = Utils.bufferWidth ()
+        let position = Console.CursorTop * width + Console.CursorLeft + delta
 
-        let top = position / (Console.BufferWidth - inset)
-        let left = inset + position % (Console.BufferWidth - inset)
+        let top = position / width
+        let left = position % width
         Cursor.ResetTo(top, left)
 
 type internal Anchor =
@@ -137,8 +232,11 @@ type internal Anchor =
 
     member p.PlaceAt(inset, index) =
         //printf "p.top = %d, p.left = %d, inset = %d, index = %d\n" p.top p.left inset index
-        let left = inset + (((p.left - inset) + index) % (Console.BufferWidth - inset))
-        let top = p.top + ((p.left - inset) + index) / (Console.BufferWidth - inset)
+        let width = Utils.bufferWidth ()
+        let index = inset + index
+
+        let left = index % width
+        let top = p.top + index / width
         Cursor.ResetTo(top, left)
 
 type internal ReadLineConsole() =
@@ -209,7 +307,9 @@ type internal ReadLineConsole() =
         | _ -> "^?"
 
     member x.GetCharacterSize(c) =
-        if Char.IsControl(c) then x.MapCharacter(c).Length else 1
+        if Char.IsControl(c) then x.MapCharacter(c).Length
+        elif Utils.isFullWidth c then 2
+        else 1
 
     static member TabSize = 4
 
@@ -242,19 +342,21 @@ type internal ReadLineConsole() =
         /// Cache of optionsCache
         let mutable optionsCache = Options()
 
+        let moveCursorToNextLine c =
+            let charSize = x.GetCharacterSize(c)
+
+            if Console.CursorLeft + charSize > Utils.bufferWidth () then
+                if Console.CursorTop + 1 = Console.BufferHeight then
+                    Console.BufferHeight <- Console.BufferHeight + 1
+
+                Cursor.Move(0)
+
         let writeBlank () =
+            moveCursorToNextLine (' ')
             Console.Write(' ')
-            checkLeftEdge false
 
         let writeChar (c) =
-            if
-                Console.CursorTop = Console.BufferHeight - 1
-                && Console.CursorLeft = Console.BufferWidth - 1
-            then
-                //printf "bottom right!\n"
-                anchor <- { anchor with top = (anchor).top - 1 }
-
-            checkLeftEdge true
+            moveCursorToNextLine (c)
 
             if Char.IsControl(c) then
                 let s = x.MapCharacter c
@@ -262,9 +364,7 @@ type internal ReadLineConsole() =
                 rendered <- rendered + s.Length
             else
                 Console.Write(c)
-                rendered <- rendered + 1
-
-            checkLeftEdge true
+                rendered <- rendered + x.GetCharacterSize(c)
 
         /// The console input buffer.
         let input = new StringBuilder()
@@ -273,25 +373,16 @@ type internal ReadLineConsole() =
         let mutable current = 0
 
         let render () =
-            //printf "render\n"
             let curr = current
             anchor.PlaceAt(x.Inset, 0)
-            let output = new StringBuilder()
-            let mutable position = -1
-
-            for i = 0 to input.Length - 1 do
-                if (i = curr) then
-                    position <- output.Length
-
-                let c = input.Chars(i)
 
-                if (Char.IsControl c) then
-                    output.Append(x.MapCharacter c) |> ignore
+            let rec getLineWidth state i =
+                if i = curr || i = input.Length then
+                    state
                 else
-                    output.Append(c) |> ignore
+                    getLineWidth (state + x.GetCharacterSize(input.Chars i)) (i + 1)
 
-            if (curr = input.Length) then
-                position <- output.Length
+            let position = getLineWidth 0 0
 
             // render the current text, computing a new value for "rendered"
             let old_rendered = rendered
@@ -326,13 +417,13 @@ type internal ReadLineConsole() =
             if current > 0 && (current - 1 < input.Length) then
                 current <- current - 1
                 let c = input.Chars(current)
-                Cursor.Move(x.Inset, -x.GetCharacterSize c)
+                Cursor.Move(-x.GetCharacterSize c)
 
         let moveRight () =
             if current < input.Length then
                 let c = input.Chars(current)
                 current <- current + 1
-                Cursor.Move(x.Inset, x.GetCharacterSize c)
+                Cursor.Move(x.GetCharacterSize c)
 
         let moveWordLeft () =
             if current > 0 && (current - 1 < input.Length) then
diff --git a/tests/FSharp.Compiler.ComponentTests/CompilerOptions/fsc/sourceFiles.fs b/tests/FSharp.Compiler.ComponentTests/CompilerOptions/fsc/sourceFiles.fs
new file mode 100644
index 00000000000..9f467df00cd
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/CompilerOptions/fsc/sourceFiles.fs
@@ -0,0 +1,20 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+module FSharp.Compiler.ComponentTests.CompilerOptions.FscSourceFilesArguments
+
+open Xunit
+open FSharp.Test
+open FSharp.Test.Compiler
+
+
+[<Fact>]
+let ``Reports duplicate sources via warning``() =
+    let file = SourceCodeFileKind.Fs({FileName="test.fs"; SourceText=Some """printfn "Hello" """ })
+ 
+    fsFromString file
+    |> FS
+    |> asExe
+    |> withAdditionalSourceFile file
+    |> compile
+    |> withWarningCodes [3551]
+    |> withErrorCodes []
\ No newline at end of file
diff --git a/tests/FSharp.Compiler.ComponentTests/CompilerOptions/fsc/times/times.fs b/tests/FSharp.Compiler.ComponentTests/CompilerOptions/fsc/times/times.fs
index dcdd57b4000..92b952dda93 100644
--- a/tests/FSharp.Compiler.ComponentTests/CompilerOptions/fsc/times/times.fs
+++ b/tests/FSharp.Compiler.ComponentTests/CompilerOptions/fsc/times/times.fs
@@ -5,6 +5,8 @@ namespace FSharp.Compiler.ComponentTests.CompilerOptions.fsc
 open Xunit
 open FSharp.Test
 open FSharp.Test.Compiler
+open System
+open System.IO
 
 module times =
 
@@ -47,3 +49,46 @@ module times =
         |> withDiagnosticMessageMatches "Unrecognized option: '--times\+'"
         |> ignore
 
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"error_01.fs"|])>]
+    let ``times - to console`` compilation =
+        let oldConsole = Console.Out
+        let sw = new StringWriter()
+        Console.SetOut(sw)
+        use _ = {new IDisposable with
+                     member this.Dispose() = Console.SetOut(oldConsole) }
+
+        compilation
+        |> asFsx
+        |> withOptions ["--times"]
+        |> ignoreWarnings
+        |> compile        
+        |> shouldSucceed  
+        |> ignore<CompilationResult>
+
+        let consoleContents = sw.ToString()
+        Assert.Contains("Parse inputs",consoleContents)
+        Assert.Contains("Typecheck",consoleContents)
+        Assert.Contains("GC0",consoleContents)
+        Assert.Contains("Duration",consoleContents)
+
+
+    [<Theory(Skip="Flaky in CI due to file being locked, disabling for now until file closure is resolved."); Directory(__SOURCE_DIRECTORY__, Includes=[|"error_01.fs"|])>]
+    let ``times - to csv file`` compilation =
+        let tempPath = Path.Combine(Path.GetTempPath(),Guid.NewGuid().ToString() + ".csv")
+        use _ = {new IDisposable with
+                     member this.Dispose() = File.Delete(tempPath) }
+
+        compilation
+        |> asFsx
+        |> withOptions ["--times:"+tempPath]
+        |> ignoreWarnings     
+        |> compile
+        |> shouldSucceed
+        |> ignore<CompilationResult>
+        
+        let csvContents = File.ReadAllLines(tempPath)
+
+        Assert.Contains("Name,StartTime,EndTime,Duration(s),Id,ParentId,RootId",csvContents[0])
+        Assert.Contains(csvContents, fun row -> row.Contains("Typecheck"))
+        Assert.Contains(csvContents, fun row -> row.Contains("Parse inputs"))
+
diff --git a/tests/FSharp.Compiler.ComponentTests/CompilerOptions/fsc/warnon/warnon.fs b/tests/FSharp.Compiler.ComponentTests/CompilerOptions/fsc/warnon/warnon.fs
index 91322a0595d..6c23e82e288 100644
--- a/tests/FSharp.Compiler.ComponentTests/CompilerOptions/fsc/warnon/warnon.fs
+++ b/tests/FSharp.Compiler.ComponentTests/CompilerOptions/fsc/warnon/warnon.fs
@@ -34,3 +34,111 @@ module warnon =
         |> withDiagnosticMessageMatches "The value 'n' is unused$"
         |> ignore
 
+    [<Fact>]
+    let ``warnon unused public function hidden by signature file`` () =
+        let signatureFile: SourceCodeFileKind =
+            SourceCodeFileKind.Create(
+                "Library.fsi",
+                """
+module Foo
+
+val add: a:int -> b:int -> int
+    """     )
+
+        let implementationFile =
+            SourceCodeFileKind.Create(
+                "Library.fs",
+                """
+module Foo
+
+let add a b = a + b
+let subtract a b = a - b
+    """         )
+
+        fsFromString signatureFile
+        |> FS
+        |> withAdditionalSourceFile implementationFile
+        |> withOptions ["--warnon:FS1182"]
+        |> asLibrary
+        |> compile
+        |> withWarningCode 1182
+        |> withDiagnosticMessageMatches "The value 'subtract' is unused$"
+        |> ignore
+
+    [<Fact>]
+    let ``Don't warnon unused public function`` () =
+        let implementationFile =
+            SourceCodeFileKind.Create(
+                "Library.fs",
+                """
+module Foo
+
+let add a b = a + b
+let subtract a b = a - b
+    """         )
+
+        fsFromString implementationFile
+        |> FS
+        |> withOptions ["--warnon:FS1182"]
+        |> asLibrary
+        |> compile
+        |> withDiagnostics []
+        |> ignore
+
+    [<Fact>]
+    let ``Don't warnon unused public function hidden by signature file that starts with an underscore`` () =
+        let signatureFile: SourceCodeFileKind =
+            SourceCodeFileKind.Create(
+                "Library.fsi",
+                """
+module Foo
+
+val add: a:int -> b:int -> int
+    """     )
+
+        let implementationFile =
+            SourceCodeFileKind.Create(
+                "Library.fs",
+                """
+module Foo
+
+let add a b = a + b
+let _subtract a b = a - b
+    """         )
+
+        fsFromString signatureFile
+        |> FS
+        |> withAdditionalSourceFile implementationFile
+        |> withOptions ["--warnon:FS1182"]
+        |> asLibrary
+        |> compile
+        |> withDiagnostics []
+        |> ignore
+
+    [<Fact>]
+    let ``Type extensions are not included in this warnon check`` () =
+        let signatureFile: SourceCodeFileKind =
+            SourceCodeFileKind.Create(
+                "Library.fsi",
+                """
+module Foo
+    """     )
+
+        let implementationFile =
+            SourceCodeFileKind.Create(
+                "Library.fs",
+                """
+module Foo
+
+type System.Int32 with
+    member x.Bar () = x + 1
+    """         )
+
+        fsFromString signatureFile
+        |> FS
+        |> withAdditionalSourceFile implementationFile
+        |> withOptions ["--warnon:FS1182"]
+        |> asLibrary
+        |> compile
+        |> shouldSucceed
+        |> ignore
diff --git a/tests/FSharp.Compiler.ComponentTests/Conformance/DeclarationElements/CustomAttributes/AttributeUsage/AttributeUsage.fs b/tests/FSharp.Compiler.ComponentTests/Conformance/DeclarationElements/CustomAttributes/AttributeUsage/AttributeUsage.fs
index 0161db9cd6e..52c055d71a4 100644
--- a/tests/FSharp.Compiler.ComponentTests/Conformance/DeclarationElements/CustomAttributes/AttributeUsage/AttributeUsage.fs
+++ b/tests/FSharp.Compiler.ComponentTests/Conformance/DeclarationElements/CustomAttributes/AttributeUsage/AttributeUsage.fs
@@ -127,17 +127,6 @@ module AttributeUsage =
             (Error 685, Line 20, Col 5, Line 20, Col 10, "The generic function 'Foo' must be given explicit type argument(s)")
         ]
 
-    // #	SOURCE=E_WithBitwiseAnd01.fsx SCFLAGS="--test:ErrorRanges -a"	# E_WithBitwiseAnd01.fsx
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"E_WithBitwiseAnd01.fsx"|])>]
-    let ``E_WithBitwiseAnd01_fsx`` compilation =
-        compilation
-        |> verifyCompile
-        |> shouldFail
-        |> withDiagnostics [
-            (Error 267, Line 7, Col 25, Line 7, Col 91, "This is not a valid constant expression or custom attribute value")
-            (Warning 839, Line 12, Col 3, Line 12, Col 6, "Unexpected condition in imported assembly: failed to decode AttributeUsage attribute")
-        ]
-
     // SOURCE=E_WithBitwiseOr01.fsx  SCFLAGS="--test:ErrorRanges -a"	# E_WithBitwiseOr01.fsx
     [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"E_WithBitwiseOr01.fsx"|])>]
     let ``E_WithBitwiseOr01_fsx`` compilation =
diff --git a/tests/FSharp.Compiler.ComponentTests/Conformance/TypesAndTypeConstraints/IWSAMsAndSRTPs/IWSAMsAndSRTPsTests.fs b/tests/FSharp.Compiler.ComponentTests/Conformance/TypesAndTypeConstraints/IWSAMsAndSRTPs/IWSAMsAndSRTPsTests.fs
index a328c5f3df2..2f55c8c7c32 100644
--- a/tests/FSharp.Compiler.ComponentTests/Conformance/TypesAndTypeConstraints/IWSAMsAndSRTPs/IWSAMsAndSRTPsTests.fs
+++ b/tests/FSharp.Compiler.ComponentTests/Conformance/TypesAndTypeConstraints/IWSAMsAndSRTPs/IWSAMsAndSRTPsTests.fs
@@ -320,6 +320,28 @@ module ``Equivalence of properties and getters`` =
             IL_000e:  ret
           }"""]
 
+module ``Type checking behavior`` =   
+
+    #if !NETCOREAPP
+    [<Theory(Skip = "IWSAMs are not supported by NET472.")>]
+    #else   
+    [<InlineData("6.0")>]
+    [<InlineData("7.0")>]
+    [<Theory>]
+    #endif
+    let ``Extension method on interface without SAM does not produce a warning`` version =
+        Fsx """
+        type INormalInterface =
+            abstract member IntMember: int
+
+        module INormalInterfaceExtensions =
+            type INormalInterface with
+                static member ExtMethod (a: INormalInterface) =
+                    ()
+        """
+        |> withLangVersion version
+        |> compile
+        |> shouldSucceed
 
 module Negative =
 
@@ -352,11 +374,7 @@ module Negative =
         |> ignore
 
 
-    #if !NETCOREAPP
-    [<Fact(Skip = "IWSAMs are not supported by NET472.")>]
-    #else
-    [<Fact>]
-    #endif
+    [<FactForNETCOREAPP>]
     let ``IWSAM warning`` () =
         Fsx "let fExpectAWarning(x: Types.ISinOperator<'T>) = ()"
         |> withReferences [typesModule]
@@ -375,7 +393,6 @@ module Negative =
         |> withDiagnosticMessage "The trait 'A' invoked by this call has multiple support types. This invocation syntax is not permitted for such traits. See https://aka.ms/fsharp-srtp for guidance."
         |> ignore
 
-
 module InvocationBehavior =
 
     [<Fact>]
@@ -394,11 +411,7 @@ module InvocationBehavior =
         |> shouldFail
         |> withErrorMessage "This function takes too many arguments, or is used in a context where a function is not expected"
 
-    #if !NETCOREAPP
-    [<Fact(Skip = "IWSAMs are not supported by NET472.")>]
-    #else
-    [<Fact>]
-    #endif
+    [<FactForNETCOREAPP>]
     let ``IWSAM Delegate conversion works`` () =
         Fsx
             """
@@ -415,11 +428,7 @@ module InvocationBehavior =
         |> compileAndRun
         |> shouldSucceed
 
-    #if !NETCOREAPP
-    [<Fact(Skip = "IWSAMs are not supported by NET472.")>]
-    #else
-    [<Fact>]
-    #endif
+    [<FactForNETCOREAPP>]
     let ``IWSAM Expression conversion works`` () =
         Fsx
             """
@@ -576,11 +585,7 @@ module ``Implicit conversion`` =
         |> withLangVersion70
         |> withOptions ["--nowarn:3535"]
 
-    #if !NETCOREAPP
-    [<Fact(Skip = "IWSAMs are not supported by NET472.")>]
-    #else
-    [<Fact>]
-    #endif
+    [<FactForNETCOREAPP>]
     let ``Function implicit conversion not supported on constrained type`` () =
         Fsx
             """
@@ -594,11 +599,7 @@ module ``Implicit conversion`` =
         |> shouldFail
         |> withDiagnosticMessageMatches "This expression was expected to have type\\s+'int'\\s+but here has type\\s+''T'"
 
-    #if !NETCOREAPP
-    [<Fact(Skip = "IWSAMs are not supported by NET472.")>]
-    #else
-    [<Fact>]
-    #endif
+    [<FactForNETCOREAPP>]
     let ``Method implicit conversion not supported on constrained type`` () =
         Fsx
             """
@@ -612,11 +613,7 @@ module ``Implicit conversion`` =
         |> shouldFail
         |> withDiagnosticMessageMatches "This expression was expected to have type\\s+'int'\\s+but here has type\\s+''T'"
 
-    #if !NETCOREAPP
-    [<Fact(Skip = "IWSAMs are not supported by NET472.")>]
-    #else
-    [<Fact>]
-    #endif
+    [<FactForNETCOREAPP>]
     let ``Function explicit conversion works on constrained type`` () =
         Fsx
             """
@@ -629,11 +626,7 @@ module ``Implicit conversion`` =
         |> compile
         |> shouldSucceed
 
-    #if !NETCOREAPP
-    [<Fact(Skip = "IWSAMs are not supported by NET472.")>]
-    #else
-    [<Fact>]
-    #endif
+    [<FactForNETCOREAPP>]
     let ``Method explicit conversion works on constrained type`` () =
         Fsx
             """
@@ -731,11 +724,7 @@ module ``Active patterns`` =
         |> withName "Potato"
         |> withOptions ["--nowarn:3535"]
 
-    #if !NETCOREAPP
-    [<Fact(Skip = "IWSAMs are not supported by NET472.")>]
-    #else
-    [<Fact>]
-    #endif
+    [<FactForNETCOREAPP>]
     let ``Using IWSAM in active pattern`` () =
         FSharp """
             module Potato.Test
@@ -765,11 +754,7 @@ module ``Active patterns`` =
             """
         ]
 
-    #if !NETCOREAPP
-    [<Fact(Skip = "IWSAMs are not supported by NET472.")>]
-    #else
-    [<Fact>]
-    #endif
+    [<FactForNETCOREAPP>]
     let ``Using IWSAM equality in active pattern uses generic equality intrinsic`` () =
         FSharp """
             module Potato.Test
@@ -807,11 +792,7 @@ module ``Active patterns`` =
 
 module ``Suppression of System Numerics interfaces on unitized types`` =
 
-#if !NETCOREAPP
-    [<Fact(Skip = "IWSAMs are not supported by NET472.")>]
-#else
-    [<Fact>]
-#endif
+    [<FactForNETCOREAPP>]
     let Baseline () =
         Fsx """
             open System.Numerics
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Enums.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Enums.fs
new file mode 100644
index 00000000000..33217909d2a
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Enums.fs
@@ -0,0 +1,53 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+namespace FSharp.Compiler.ComponentTests.EmittedIL
+
+open Xunit
+open FSharp.Test.Compiler
+
+module Enums =
+
+    [<Fact>]
+    let ``Arithmetic in enum definition works``() =
+        FSharp """
+module Enums
+
+let [<Literal>] one = 1
+
+type Flags =
+    | A = 1
+    | B = (one <<< 1)
+    | C = (one <<< (one * 2))
+        """
+        |> withLangVersionPreview
+        |> compile
+        |> shouldSucceed
+        |> verifyIL [
+            """.field public static literal valuetype Enums/Flags A = int32(0x00000001)"""
+            """.field public static literal valuetype Enums/Flags B = int32(0x00000002)"""
+            """.field public static literal valuetype Enums/Flags C = int32(0x00000004)"""
+        ]
+
+    [<Fact>]
+    let ``Enum with inconsistent case types errors with the right message``() =
+        FSharp """
+module Enums
+
+type E =
+    | A = (1L <<< 0)
+    | B = (1 <<< 1)
+        """
+        |> withLangVersionPreview
+        |> compile
+        |> shouldFail
+        |> withResult {
+            Error = Error 1
+            Range = { StartLine = 6
+                      StartColumn = 11
+                      EndLine = 6
+                      EndColumn = 20 }
+            Message = "This expression was expected to have type
+    'int64'    
+but here has type
+    'int'    "
+        }
\ No newline at end of file
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Literals.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Literals.fs
index 40092066b38..570f22d1377 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Literals.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Literals.fs
@@ -24,3 +24,207 @@ let main _ =
          |> verifyIL ["""
 .field public static literal int32 x = int32(0x00000007)
 .custom instance void [FSharp.Core]Microsoft.FSharp.Core.LiteralAttribute::.ctor() = ( 01 00 00 00 )"""]
+
+
+    [<Fact>]
+    let ``Arithmetic in integer literals is evaluated at compile time``() =
+        FSharp """
+module LiteralArithmetic
+
+let [<Literal>] bytesInMegabyte = 1024L * 1024L
+
+let [<Literal>] bytesInKilobyte = bytesInMegabyte >>> 10
+
+let [<Literal>] bytesInKilobyte2 = bytesInMegabyte / 1024L
+
+let [<Literal>] secondsInDayPlusThree = 3 + (60 * 60 * 24)
+
+let [<Literal>] bitwise = 1us &&& (3us ||| 4us)
+        """
+        |> withLangVersionPreview
+        |> compile
+        |> shouldSucceed
+        |> verifyIL [
+            """.field public static literal int64 bytesInMegabyte = int64(0x100000)"""
+            """.field public static literal int64 bytesInKilobyte = int64(0x400)"""
+            """.field public static literal int64 bytesInKilobyte2 = int64(0x400)"""
+            """.field public static literal int32 secondsInDayPlusThree = int32(0x00015183)"""
+            """.field public static literal uint16 bitwise = uint16(0x0001)"""
+        ]
+
+    [<Fact>]
+    let ``Arithmetic in char and floating point literals is evaluated at compile time``() =
+        // on Linux and Mac floats with no decimal parts are printed without the decimal point (unlike Windows)
+        // let's add some fractions so that the tests are consistent
+        FSharp """
+module LiteralArithmetic
+
+let [<Literal>] bytesInMegabyte = 1024. * 1024. + 0.1
+
+let [<Literal>] bytesInKilobyte = bytesInMegabyte / 1024. + 0.1
+
+let [<Literal>] secondsInDayPlusThree = 3.1f + (60f * 60f * 24f)
+
+let [<Literal>] chars = 'a' + 'b' - 'a'
+        """
+        |> withLangVersionPreview
+        |> compile
+        |> shouldSucceed
+        |> verifyIL [
+            """.field public static literal float64 bytesInMegabyte = float64(1048576.1000000001)"""
+            """.field public static literal float64 bytesInKilobyte = float64(1024.10009765625)"""
+            """.field public static literal float32 secondsInDayPlusThree = float32(86403.102)"""
+            """.field public static literal char chars = char(0x0062)"""
+        ]
+
+    [<Fact>]
+    let ``Logical operations on booleans are evaluated at compile time``() =
+        FSharp """
+module LiteralArithmetic
+
+let [<Literal>] flag = true
+
+let [<Literal>] flippedFlag = not flag
+
+let [<Literal>] simple1 = flippedFlag || false
+
+let [<Literal>] simple2 = true && not true
+
+let [<Literal>] complex1 = false || (flag && not flippedFlag)
+
+let [<Literal>] complex2 = false || (flag && flippedFlag)
+
+let [<Literal>] complex3 = true || (flag && not flippedFlag)
+        """
+        |> withLangVersionPreview
+        |> compile
+        |> shouldSucceed
+        |> verifyIL [
+            """.field public static literal bool flag = bool(true)"""
+            """.field public static literal bool flippedFlag = bool(false)"""
+            """.field public static literal bool simple1 = bool(false)"""
+            """.field public static literal bool simple2 = bool(false)"""
+            """.field public static literal bool complex1 = bool(true)"""
+            """.field public static literal bool complex2 = bool(false)"""
+            """.field public static literal bool complex3 = bool(true)"""
+        ]
+
+    [<Fact>]
+    let ``Arithmetic can be used for constructing enum literals``() =
+        FSharp """
+module LiteralArithmetic
+
+type E =
+    | A = 1
+    | B = 2
+    
+let [<Literal>] x = enum<E> (1 + 1)
+        """
+        |> withLangVersionPreview
+        |> compile
+        |> shouldSucceed
+        |> verifyIL [
+            """.field public static literal valuetype LiteralArithmetic/E x = int32(0x00000002)"""
+        ]
+
+    [<Fact>]
+    let ``Arithmetic can be used for constructing literals in attributes``() =
+        FSharp """
+module LiteralArithmetic
+
+open System.Runtime.CompilerServices
+
+// 256 = AggressiveInlining
+[<MethodImpl(enum -(-1 <<< 8))>]
+let x () =
+    3
+        """
+        |> withLangVersionPreview
+        |> compile
+        |> shouldSucceed
+        |> verifyIL [
+            """.method public static int32  x() cil managed aggressiveinlining"""
+        ]
+
+    [<Fact>]
+    let ``Compilation fails when addition in literal overflows``() =
+        FSharp """
+module LiteralArithmetic
+
+let [<Literal>] x = System.Int32.MaxValue + 1
+        """
+        |> withLangVersionPreview
+        |> compile
+        |> shouldFail
+        |> withResult {
+            Error = Error 3177
+            Range = { StartLine = 4
+                      StartColumn = 21
+                      EndLine = 4
+                      EndColumn = 46 }
+            Message = "This literal expression or attribute argument results in an arithmetic overflow."
+        }
+
+    [<Fact>]
+    let ``Compilation fails when using decimal arithmetic in literal``() =
+        FSharp """
+module LiteralArithmetic
+
+let [<Literal>] x = 1m + 1m
+        """
+        |> withLangVersionPreview
+        |> compile
+        |> shouldFail
+        |> withResults [
+            { Error = Error 267
+              Range = { StartLine = 4
+                        StartColumn = 21
+                        EndLine = 4
+                        EndColumn = 23 }
+              Message = "This is not a valid constant expression or custom attribute value" }
+            { Error = Error 267
+              Range = { StartLine = 4
+                        StartColumn = 26
+                        EndLine = 4
+                        EndColumn = 28 }
+              Message = "This is not a valid constant expression or custom attribute value" }
+            { Error = Error 267
+              Range = { StartLine = 4
+                        StartColumn = 21
+                        EndLine = 4
+                        EndColumn = 28 }
+              Message = "This is not a valid constant expression or custom attribute value" }
+        ]
+
+    [<Fact>]
+    let ``Compilation fails when using arithmetic with a non-literal in literal``() =
+        FSharp """
+module LiteralArithmetic
+
+let [<Literal>] x = 1 + System.DateTime.Now.Hour
+        """
+        |> withLangVersionPreview
+        |> compile
+        |> shouldFail
+        |> withResults [
+#if !NETCOREAPP
+            { Error = Warning 52
+              Range = { StartLine = 4
+                        StartColumn = 25
+                        EndLine = 4
+                        EndColumn = 49 }
+              Message = "The value has been copied to ensure the original is not mutated by this operation or because the copy is implicit when returning a struct from a member and another member is then accessed" }
+#endif
+            { Error = Error 267
+              Range = { StartLine = 4
+                        StartColumn = 25
+                        EndLine = 4
+                        EndColumn = 49 }
+              Message = "This is not a valid constant expression or custom attribute value" }
+            { Error = Error 267
+              Range = { StartLine = 4
+                        StartColumn = 21
+                        EndLine = 4
+                        EndColumn = 49 }
+              Message = "This is not a valid constant expression or custom attribute value" }
+        ]
\ No newline at end of file
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/MethodImplAttribute/MethodImplAttribute.NoInlining_InlineKeyword.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/MethodImplAttribute/MethodImplAttribute.NoInlining_InlineKeyword.fs
new file mode 100644
index 00000000000..b40e3a3f8e0
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/MethodImplAttribute/MethodImplAttribute.NoInlining_InlineKeyword.fs
@@ -0,0 +1,3 @@
+module M
+[<System.Runtime.CompilerServices.MethodImplAttribute(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)>]
+let inline getUnit (f : unit -> unit) = f()
\ No newline at end of file
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/MethodImplAttribute/MethodImplAttribute.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/MethodImplAttribute/MethodImplAttribute.fs
index 51f758b7f47..183be7e87b9 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/MethodImplAttribute/MethodImplAttribute.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/MethodImplAttribute/MethodImplAttribute.fs
@@ -33,6 +33,20 @@ module MethodImplAttribute =
     let ``NoInlining_fs`` compilation =
         compilation
         |> verifyCompilation
+     
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"MethodImplAttribute.NoInlining_InlineKeyword.fs"|])>]
+    let ``NoInlining_fs with inline keyword => should warn in preview version`` compilation =
+        compilation
+        |> withLangVersionPreview
+        |> typecheck
+        |> withSingleDiagnostic (Warning 3151, Line 2, Col 1, Line 3, Col 38, "This member, function or value declaration may not be declared 'inline'")
+    
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"MethodImplAttribute.NoInlining_InlineKeyword.fs"|])>]
+    let ``NoInlining_fs with inline keyword => should not warn in F# 7 or older`` compilation =
+        compilation
+        |> withLangVersion70
+        |> typecheck
+        |> withDiagnostics  []       
 
     // SOURCE=MethodImplAttribute.AggressiveInlining.fs SCFLAGS="-a -g --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd MethodImplAttribute.AggressiveInlining.dll"	# MethodImplAttribute.AggressiveInlining.fs
     [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"MethodImplAttribute.AggressiveInlining.fs"|])>]
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SkipLocalsInit.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SkipLocalsInit.fs
index 8b69fa73281..65ba4655cc2 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SkipLocalsInit.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SkipLocalsInit.fs
@@ -5,9 +5,8 @@ namespace FSharp.Compiler.ComponentTests.EmittedIL
 open Xunit
 open FSharp.Test.Compiler
 
-#if NETCOREAPP
 module ``SkipLocalsInit`` =
-    [<Fact>]
+    [<FSharp.Test.FactForNETCOREAPP>]
     let ``Init in function and closure not emitted when applied on function``() =
         FSharp """
 module SkipLocalsInit
@@ -35,7 +34,7 @@ let x () =
   .maxstack  6
   .locals (int32 V_0)"""]
 
-    [<Fact>]
+    [<FSharp.Test.FactForNETCOREAPP>]
     let ``Init in static method not emitted when applied on class``() =
         FSharp """
 module SkipLocalsInit
@@ -60,7 +59,7 @@ type X () =
   .maxstack  4
   .locals (int32 V_0)"""]
 
-    [<Fact>]
+    [<FSharp.Test.FactForNETCOREAPP>]
     let ``Init in static method and function not emitted when applied on module``() =
         FSharp """
 [<System.Runtime.CompilerServices.SkipLocalsInitAttribute>]
@@ -97,7 +96,7 @@ type X () =
   .maxstack  4
   .locals (int32 V_0)"""]
 
-    [<Fact>]
+    [<FSharp.Test.FactForNETCOREAPP>]
     let ``Init in method and closure not emitted when applied on method``() =
         FSharp """
 module SkipLocalsInit
@@ -131,7 +130,7 @@ type X () =
   .locals (int32 V_0)
 """ ]
 
-    [<Fact>]
+    [<FSharp.Test.FactForNETCOREAPP>]
     let ``Zero init performed to get defaults despite the attribute``() =
         FSharp """
 module SkipLocalsInit
@@ -180,5 +179,4 @@ IL_0019:  ldarg.0
 IL_001a:  ldloc.0
 IL_001b:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [runtime]System.Nullable`1<int64>,!!a>::Invoke(!0)
 IL_0020:  stloc.2
-IL_0021:  ret"""]
-#endif
\ No newline at end of file
+IL_0021:  ret"""]
\ No newline at end of file
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/UnionTypeWithSignature02.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/UnionTypeWithSignature02.fs
index f0d289ff540..92daf21dfd1 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/UnionTypeWithSignature02.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/UnionTypeWithSignature02.fs
@@ -2,7 +2,7 @@
 // Regression test for FSHARP1.0:4040
 // "Signature files do not prevent compiler-generated public constructors from leaking out of discriminated unions"
 // Note that the corresponsing .fsi file is NOT missing the "| C of int" part of the DU
-namespace N
+module N
 
 type T = | C of int
 
diff --git a/tests/FSharp.Compiler.ComponentTests/ErrorMessages/ClassesTests.fs b/tests/FSharp.Compiler.ComponentTests/ErrorMessages/ClassesTests.fs
index eeb3ab1d371..52824cf7278 100644
--- a/tests/FSharp.Compiler.ComponentTests/ErrorMessages/ClassesTests.fs
+++ b/tests/FSharp.Compiler.ComponentTests/ErrorMessages/ClassesTests.fs
@@ -542,4 +542,148 @@ type C() =
         |> withDiagnostics [
             (Error 855, Line 7, Col 19, Line 7, Col 21, "No abstract or interface member was found that corresponds to this override")
             (Error 855, Line 9, Col 19, Line 9, Col 21, "No abstract or interface member was found that corresponds to this override")
-        ]
\ No newline at end of file
+        ]
+
+    [<Fact>]
+    let ``Virtual members were found with multiple types in hierarchy with different overloads langversionPreview`` () =
+        let CSLib =
+            CSharp """
+public class A
+{
+    public virtual void M1(string s) { }
+}
+
+public class B : A
+{
+    public virtual void M1(int i) { }
+}
+        """ |> withName "CSLib"
+
+        let app =
+            FSharp """
+module ClassTests
+type C() =
+    inherit B ()
+    override _.M1 (i: string) = ()
+    override _.M1 (i: int) = ()
+        """ |> withReferences [CSLib]
+        app
+        |> withLangVersionPreview
+        |> compile
+        |> shouldSucceed
+
+    [<Fact>]
+    let ``Virtual member was found with multiple types in hierarchy with different overloads langversionPreview`` () =
+        let CSLib =
+            CSharp """
+public class A
+{
+    public virtual void M1(string s) { }
+}
+
+public class B : A
+{
+    public void M1(int i) { }
+}
+        """ |> withName "CSLib"
+
+        let app =
+            FSharp """
+module ClassTests
+type C() =
+    inherit B ()
+    override _.M1 (i: string) = ()
+        """ |> withReferences [CSLib]
+        app
+        |> withLangVersionPreview
+        |> compile
+        |> shouldSucceed
+
+
+    [<Fact>]
+    let ``Virtual member was found among virtual and non-virtual overloads with lang preview`` () =
+        let CSLib =
+            CSharp """
+public class A
+{
+    public void M1(int i) { }
+    public virtual void M1(string s) { }
+}
+        """ |> withName "CSLib"
+
+        let app =
+            FSharp """
+module ClassTests
+
+type Over () =
+    inherit A ()
+
+    override _.M1 (s: string) = ()
+        """
+        
+        app
+        |> withReferences [CSLib]
+        |> withLangVersionPreview
+        |> compile
+        |> shouldSucceed
+
+
+    [<Fact>]
+    let ``Disallow implementing more than one abstract slot`` () =
+        let app = FSharp """
+module ClassTests
+
+[<AbstractClass>]
+type PA() =
+    abstract M : int -> unit
+
+[<AbstractClass>]
+type PB<'a>() =
+    inherit PA()
+    abstract M : 'a -> unit
+[<AbstractClass>]
+type PC() =
+    inherit PB<int>()
+    // Here, PA.M and PB<int>.M have the same signature, so PA.M is unimplementable.
+    // REVIEW: in future we may give a friendly error at this point
+type PD() =
+    inherit PC()
+    override this.M(x: int) = ()
+        """
+        app
+        |> withLangVersionPreview
+        |> compile
+        |> shouldFail
+        |> withSingleDiagnostic (Error 361, Line 19, Col 19, Line 19, Col 20, "The override 'M: int -> unit' implements more than one abstract slot, e.g. 'abstract PB.M: 'a -> unit' and 'abstract PA.M: int -> unit'")
+
+    [<Fact>]
+    let ``Generic overrides work with preview version`` () =
+        let CSLib =
+            CSharp """
+public class C
+{
+    public virtual void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d) {}
+}
+
+public class D : C
+{
+    public override void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d)
+        where T1 : default
+        where T3 : default
+    {
+        base.M(a, b, c, d);
+    }
+}
+        """ |> withName "CSLib"
+
+        let app =
+            FSharp """
+module ClassTests
+type X =
+    inherit C
+    override this.M(a, b, c, d) = ()
+        """ |> withReferences [CSLib]
+        app
+        |> withLangVersionPreview
+        |> compile
+        |> shouldSucceed
\ No newline at end of file
diff --git a/tests/FSharp.Compiler.ComponentTests/ErrorMessages/UnsupportedAttributes.fs b/tests/FSharp.Compiler.ComponentTests/ErrorMessages/UnsupportedAttributes.fs
index 276bad5963c..fa981de2a14 100644
--- a/tests/FSharp.Compiler.ComponentTests/ErrorMessages/UnsupportedAttributes.fs
+++ b/tests/FSharp.Compiler.ComponentTests/ErrorMessages/UnsupportedAttributes.fs
@@ -2,13 +2,12 @@
 
 namespace FSharp.Compiler.ComponentTests.ErrorMessages
 
-#if NETCOREAPP
 open Xunit
 open FSharp.Test.Compiler
 
 module ``Unsupported Attributes`` =
 
-    [<Fact>]
+    [<FSharp.Test.FactForNETCOREAPP>]
     let ``Warn successfully`` () =
         """
 open System.Runtime.CompilerServices
@@ -51,5 +50,4 @@ type C() =
                         EndColumn = 56 }
               Message =
                "This attribute is currently unsupported by the F# compiler. Applying it will not achieve its intended effect." }
-        ]
-#endif
\ No newline at end of file
+        ]
\ No newline at end of file
diff --git a/tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj b/tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj
index c5dc63107ff..c244723eb72 100644
--- a/tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj
+++ b/tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj
@@ -101,6 +101,7 @@
     <Compile Include="Conformance\UnitsOfMeasure\TypeChecker.fs" />
     <Compile Include="EmittedIL\CompilerGeneratedAttributeOnAccessors.fs" />
     <Compile Include="EmittedIL\EmptyArray.fs" />
+    <Compile Include="EmittedIL\Enums.fs" />
     <Compile Include="EmittedIL\Literals.fs" />
     <Compile Include="EmittedIL\NoCompilerInlining.fs" />
     <Compile Include="EmittedIL\SkipLocalsInit.fs" />
@@ -173,11 +174,14 @@
     <Compile Include="Language\CodeQuotationTests.fs" />
     <Compile Include="Language\InterpolatedStringsTests.fs" />
     <Compile Include="Language\ComputationExpressionTests.fs" />
+    <Compile Include="Language\DynamicAssignmentOperatorTests.fs" />
     <Compile Include="Language\CastingTests.fs" />
     <Compile Include="Language\NameofTests.fs" />
     <Compile Include="Language\ExtensionMethodTests.fs" />
+    <Compile Include="Language\StaticClassTests.fs" />
     <Compile Include="ConstraintSolver\PrimitiveConstraints.fs" />
     <Compile Include="ConstraintSolver\MemberConstraints.fs" />
+    <Compile Include="Interop\DeeplyNestedCSharpClasses.fs" />
     <Compile Include="Interop\SimpleInteropTests.fs" />
     <Compile Include="Interop\RequiredAndInitOnlyProperties.fs" />
     <Compile Include="Interop\StaticsInInterfaces.fs" />
@@ -197,6 +201,7 @@
     <Compile Include="CompilerOptions\fsc\reference.fs" />
     <Compile Include="CompilerOptions\fsc\reflectionfree.fs" />
     <Compile Include="CompilerOptions\fsc\refonlyrefout.fs" />
+	<Compile Include="CompilerOptions\fsc\sourceFiles.fs" />
     <Compile Include="Debugger\PortablePdbs.fs" />
     <Compile Include="Diagnostics\async.fs" />
     <Compile Include="Diagnostics\General.fs" />
@@ -214,6 +219,9 @@
     <Compile Include="FSharpChecker\CommonWorkflows.fs" />
     <Compile Include="FSharpChecker\SymbolUse.fs" />
     <Compile Include="FSharpChecker\FindReferences.fs" />
+  </ItemGroup>
+
+  <ItemGroup>
     <None Include="**\*.cs;**\*.fs;**\*.fsx;**\*.fsi" Exclude="@(Compile)">
       <Link>%(RelativeDir)\TestSource\%(Filename)%(Extension)</Link>
     </None>
diff --git a/tests/FSharp.Compiler.ComponentTests/FSharpChecker/CommonWorkflows.fs b/tests/FSharp.Compiler.ComponentTests/FSharpChecker/CommonWorkflows.fs
index 1afd0d56220..6b5775f23e7 100644
--- a/tests/FSharp.Compiler.ComponentTests/FSharpChecker/CommonWorkflows.fs
+++ b/tests/FSharp.Compiler.ComponentTests/FSharpChecker/CommonWorkflows.fs
@@ -6,6 +6,9 @@ open System.IO
 open Xunit
 
 open FSharp.Test.ProjectGeneration
+open FSharp.Test.ProjectGeneration.Internal
+open FSharp.Compiler.Text
+open FSharp.Compiler.CodeAnalysis
 
 let makeTestProject () =
     SyntheticProject.Create(
@@ -89,3 +92,43 @@ let ``Changes in a referenced project`` () =
         saveFile "Library"
         checkFile "Last" expectSignatureChanged
     }
+
+[<Fact>]
+let ``Language service works if the same file is listed twice`` () = 
+    let file = sourceFile "First" []
+    let project =  SyntheticProject.Create(file)
+    project.Workflow {
+        checkFile "First" expectOk
+        addFileAbove "First" file
+        checkFile "First" (expectSingleWarningAndNoErrors "Please verify that it is included only once in the project file.")
+    }
+
+[<Fact>]
+let ``Using getSource and notifications instead of filesystem`` () =
+
+    let size = 20
+
+    let project =
+        { SyntheticProject.Create() with
+            SourceFiles = [
+                sourceFile $"File%03d{0}" []
+                for i in 1..size do
+                    sourceFile $"File%03d{i}" [$"File%03d{i-1}"]
+            ]
+        }
+
+    let first = "File001"
+    let middle = $"File%03d{size / 2}"
+    let last = $"File%03d{size}"
+
+    ProjectWorkflowBuilder(project, useGetSource = true, useChangeNotifications = true) {
+        updateFile first updatePublicSurface
+        checkFile first expectSignatureChanged
+        checkFile last expectSignatureChanged
+        updateFile middle updatePublicSurface
+        checkFile last expectSignatureChanged
+        addFileAbove middle (sourceFile "addedFile" [first])
+        updateFile middle (addDependency "addedFile")
+        checkFile middle expectSignatureChanged
+        checkFile last expectSignatureChanged
+    }
diff --git a/tests/FSharp.Compiler.ComponentTests/FSharpChecker/FindReferences.fs b/tests/FSharp.Compiler.ComponentTests/FSharpChecker/FindReferences.fs
index b421de62027..83131035443 100644
--- a/tests/FSharp.Compiler.ComponentTests/FSharpChecker/FindReferences.fs
+++ b/tests/FSharp.Compiler.ComponentTests/FSharpChecker/FindReferences.fs
@@ -96,8 +96,12 @@ secondA.DoNothing(secondB)
 
         }
 
-[<Fact>]
-let ``Finding references in project`` () =
+[<Theory>]
+[<InlineData(true, true)>]
+[<InlineData(true, false)>]
+[<InlineData(false, true)>]
+[<InlineData(false, false)>]
+let ``Finding references in project`` (fastCheck, captureIdentifiersWhenParsing) =
     let size = 20
 
     let project =
@@ -111,10 +115,12 @@ let ``Finding references in project`` () =
         |> updateFile "File005" (addDependency "File000")
         |> updateFile "File010" (addDependency "File000")
 
-    let checker = FSharpChecker.Create(enableBackgroundItemKeyStoreAndSemanticClassification = true)
+    let checker = FSharpChecker.Create(
+        enableBackgroundItemKeyStoreAndSemanticClassification = true,
+        captureIdentifiersWhenParsing = captureIdentifiersWhenParsing)
 
     project.WorkflowWith checker {
-        findAllReferencesToModuleFromFile "File000" true (expectNumberOfResults 5)
+        findAllReferencesToModuleFromFile "File000" fastCheck (expectNumberOfResults 5)
     }
 
 [<Fact>]
@@ -189,4 +195,4 @@ let foo x = 5""" })
                 "FileSecond.fs", 8, 2, 4
                 "FileThird.fs", 8, 2, 13
             ])
-        }
+        }
\ No newline at end of file
diff --git a/tests/FSharp.Compiler.ComponentTests/Interop/DeeplyNestedCSharpClasses.fs b/tests/FSharp.Compiler.ComponentTests/Interop/DeeplyNestedCSharpClasses.fs
new file mode 100644
index 00000000000..f346743055a
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/Interop/DeeplyNestedCSharpClasses.fs
@@ -0,0 +1,86 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+namespace FSharp.Compiler.ComponentTests.Interop
+
+open Xunit
+open FSharp.Test.Compiler
+open FSharp.Test
+open System
+
+module ``Deeply nested CSharpClasses`` =
+
+    let cslib =
+        CSharp """
+using System;
+
+namespace MyNamespace
+{
+    public class OuterClass
+    {
+
+        public class InnerClass
+        {
+
+            public class MoreInnerClass
+            {
+                public static void somefunction() { }
+            }
+        }
+    }
+}"""
+
+    [<Fact>]
+    let ``Missing type outerclass generates good message and range`` () =
+
+        let fsharpSource =
+            """
+let loss2 = MyNamespace.OoterClass.InnerClass.MoreInnerClass.somefunction()   //Note the miss-typed functionname we expect a good error message
+"""
+        FSharp fsharpSource
+        |> asExe
+        |> withReferences [cslib]
+        |> compile
+        |> withSingleDiagnostic (Error 39, Line 2, Col 25, Line 2, Col 35, "The value, constructor, namespace or type 'OoterClass' is not defined. Maybe you want one of the following:
+   OuterClass")
+
+    [<Fact>]
+    let ``Missing type nested type innerclass generates good message and range`` () =
+
+        let fsharpSource =
+            """
+let loss2 = MyNamespace.OuterClass.InerClass.MoreInnerClass.somefunction()   //Note the miss-typed InnerClass name we expect a good error message
+"""
+        FSharp fsharpSource
+        |> asExe
+        |> withReferences [cslib]
+        |> compile
+        |> shouldFail
+        |> withSingleDiagnostic (Error 39, Line 2, Col 36, Line 2, Col 45, "The type 'OuterClass' does not define the field, constructor or member 'InerClass'.")
+
+    [<Fact>]
+    let ``Missing type nested type moreinnerclass generates good message and range`` () =
+
+        let fsharpSource =
+            """
+let loss2 = MyNamespace.OuterClass.InnerClass.MoareInnerClass.somefunction()   //Note the miss-typed MoreInnerClass we expect a good error message
+"""
+        FSharp fsharpSource
+        |> asExe
+        |> withReferences [cslib]
+        |> compile
+        |> shouldFail
+        |> withSingleDiagnostic (Error 39, Line 2, Col 47, Line 2, Col 62, "The type 'InnerClass' does not define the field, constructor or member 'MoareInnerClass'.")
+
+    [<Fact>]
+    let ``Missing function generates good message and range`` () =
+
+        let fsharpSource =
+            """
+let loss2 = MyNamespace.OuterClass.InnerClass.MoreInnerClass.somefunctoion()   //Note the miss-typed somefunction we expect a good error message
+"""
+        FSharp fsharpSource
+        |> asExe
+        |> withReferences [cslib]
+        |> compile
+        |> shouldFail
+        |> withSingleDiagnostic ((Error 39, Line 2, Col 62, Line 2, Col 75, """The type 'MoreInnerClass' does not define the field, constructor or member 'somefunctoion'. Maybe you want one of the following:
+   somefunction"""))
diff --git a/tests/FSharp.Compiler.ComponentTests/Interop/RequiredAndInitOnlyProperties.fs b/tests/FSharp.Compiler.ComponentTests/Interop/RequiredAndInitOnlyProperties.fs
index 0b2d4cc37ab..66393325eb3 100644
--- a/tests/FSharp.Compiler.ComponentTests/Interop/RequiredAndInitOnlyProperties.fs
+++ b/tests/FSharp.Compiler.ComponentTests/Interop/RequiredAndInitOnlyProperties.fs
@@ -42,11 +42,7 @@ module ``Required and init-only properties`` =
     }""" |> withCSharpLanguageVersion CSharpLanguageVersion.Preview |> withName "csLib"
 
 
-#if !NETCOREAPP
-    [<Fact(Skip = "NET472 is unsupported runtime for this kind of test.")>]
-#else
-    [<Fact>]
-#endif
+    [<FactForNETCOREAPP>]
     let ``F# can init both set and init-only`` () =
 
         let csharpLib = csharpBaseClass
@@ -72,11 +68,7 @@ let main _ =
         |> compileAndRun
         |> shouldSucceed
 
-#if !NETCOREAPP
-    [<Fact(Skip = "NET472 is unsupported runtime for this kind of test.")>]
-#else
-    [<Fact>]
-#endif
+    [<FactForNETCOREAPP>]
     let ``F# can change set property`` () =
 
         let csharpLib = csharpBaseClass
@@ -107,11 +99,7 @@ let main _ =
         |> compileAndRun
         |> shouldSucceed
     
-#if !NETCOREAPP
-    [<Fact(Skip = "NET472 is unsupported runtime for this kind of test.")>]
-#else
-    [<Fact>]
-#endif
+    [<FactForNETCOREAPP>]
     let ``F# can change set property via calling an explicit setter`` () =
 
         let csharpLib = csharpBaseClass
@@ -142,11 +130,7 @@ let main _ =
         |> compileAndRun
         |> shouldSucceed
 
-#if !NETCOREAPP
-    [<Fact(Skip = "NET472 is unsupported runtime for this kind of test.")>]
-#else
-    [<Fact>]
-#endif
+    [<FactForNETCOREAPP>]
     let ``F# can get property via calling an explicit getter`` () =
 
         let csharpLib = csharpBaseClass
@@ -172,11 +156,7 @@ let main _ =
         |> compileAndRun
         |> shouldSucceed
 
-#if !NETCOREAPP
-    [<Fact(Skip = "NET472 is unsupported runtime for this kind of test.")>]
-#else
-    [<Fact>]
-#endif
+    [<FactForNETCOREAPP>]
     let ``F# cannot change init-only property`` () =
 
         let csharpLib = csharpBaseClass
@@ -204,11 +184,7 @@ let main _ =
             Error 810, Line 9, Col 5, Line 9, Col 17, "Init-only property 'GetInit' cannot be set outside the initialization code. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization"
         ]
 
-#if !NETCOREAPP
-    [<Fact(Skip = "NET472 is unsupported runtime for this kind of test.")>]
-#else
-    [<Fact>]
-#endif
+    [<FactForNETCOREAPP>]
     let ``F# cannot change init-only property via calling an explicit setter`` () =
 
         let csharpLib = csharpBaseClass
@@ -236,11 +212,7 @@ let main _ =
             Error 810, Line 9, Col 5, Line 9, Col 21, "Cannot call 'set_GetInit' - a setter for init-only property, please use object initialization instead. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization"
         ]
 
-#if !NETCOREAPP
-    [<Fact(Skip = "NET472 is unsupported runtime for this kind of test.")>]
-#else
-    [<Fact>]
-#endif
+    [<FactForNETCOREAPP>]
     let ``F# cannot change init-only property via calling an initializer on instance`` () =
 
         let csharpLib = csharpBaseClass
@@ -267,11 +239,7 @@ let main _ =
             Error 810, Line 9, Col 38, Line 9, Col 40, "Init-only property 'GetInit' cannot be set outside the initialization code. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization"
         ]
 
-#if !NETCOREAPP
-    [<Fact(Skip = "IWSAMs are not supported by NET472.")>]
-#else
-    [<Fact>]
-#endif
+    [<FactForNETCOREAPP>]
     let ``F# can change init-only property via SRTP`` () =
 
         let csharpLib = csharpBaseClass
@@ -296,11 +264,7 @@ let main _ =
         |> compile
         |> shouldSucceed
 
- #if !NETCOREAPP
-    [<Fact(Skip = "IWSAMs are not supported by NET472.")>]
-#else
-    [<Fact>]
-#endif
+    [<FactForNETCOREAPP>]
     let ``F# can call special-named methods via SRTP`` () =
 
         let csharpLib = csharpRecord
@@ -325,11 +289,7 @@ let main _ =
         |> compile
         |> shouldSucceed
 
-#if !NETCOREAPP
-    [<Fact(Skip = "NET472 is unsupported runtime for this kind of test.")>]
-#else
-    [<Fact>]
-#endif
+    [<FactForNETCOREAPP>]
     let ``F# should produce compile-time error when required properties are not specified in the initializer`` () =
 
         let csharpLib = csharpRBaseClass
@@ -356,11 +316,7 @@ let main _ =
             Error 3545, Line 8, Col 16, Line 8, Col 22, "The following required properties have to be initalized:" + Environment.NewLine + "   property RAIO.GetSet: int with get, set" + Environment.NewLine + "   property RAIO.GetInit: int with get, set"
         ]
 
-#if !NETCOREAPP
-    [<Fact(Skip = "NET472 is unsupported runtime for this kind of test.")>]
-#else
-    [<Fact>]
-#endif
+    [<FactForNETCOREAPP>]
     let ``F# should produce compile-time error when some required properties are not specified in the initializer`` () =
 
         let csharpLib = csharpRBaseClass
@@ -387,11 +343,7 @@ let main _ =
             Error 3545, Line 8, Col 16, Line 8, Col 30, "The following required properties have to be initalized:" + Environment.NewLine + "   property RAIO.GetInit: int with get, set"
         ]
 
-#if !NETCOREAPP
-    [<Fact(Skip = "NET472 is unsupported runtime for this kind of test.")>]
-#else
-    [<Fact>]
-#endif
+    [<FactForNETCOREAPP>]
     let ``F# should not produce compile-time error when all required properties are specified in the initializer`` () =
 
         let csharpLib = csharpRBaseClass
@@ -420,11 +372,7 @@ let main _ =
         |> compileAndRun
         |> shouldSucceed
 
-    #if !NETCOREAPP
-    [<Fact(Skip = "NET472 is unsupported runtime for this kind of test.")>]
-    #else
-    [<Fact>]
-    #endif
+    [<FactForNETCOREAPP>]
     let ``F# should only be able to explicitly call constructors which set SetsRequiredMembersAttribute`` () =
 
         let csharpLib =
@@ -481,11 +429,7 @@ let main _ =
         |> shouldFail
         |> withSingleDiagnostic (Error 3545, Line 7, Col 21, Line 7, Col 30, "The following required properties have to be initalized:" + Environment.NewLine + "   property RAIO.GetSet: int with get, set" + Environment.NewLine + "   property RAIO.GetInit: int with get, set")
 
-#if !NETCOREAPP
-    [<Fact(Skip = "NET472 is unsupported runtime for this kind of test.")>]
-#else
-    [<Fact>]
-#endif
+    [<FactForNETCOREAPP>]
     let ``F# should produce a warning if RequiredMemberAttribute is specified`` () =
         let fsharpSource =
             """
diff --git a/tests/FSharp.Compiler.ComponentTests/Interop/StaticsInInterfaces.fs b/tests/FSharp.Compiler.ComponentTests/Interop/StaticsInInterfaces.fs
index 3d6afab3f3b..c4cd83d5fd2 100644
--- a/tests/FSharp.Compiler.ComponentTests/Interop/StaticsInInterfaces.fs
+++ b/tests/FSharp.Compiler.ComponentTests/Interop/StaticsInInterfaces.fs
@@ -63,11 +63,7 @@ module ``Static Methods In Interfaces`` =
         }
         """  |> withCSharpLanguageVersion CSharpLanguageVersion.Preview |> withName "csOpLib"
 
-    #if !NETCOREAPP
-    [<Fact(Skip = "NET472 is unsupported runtime for this kind of test.")>]
-#else
-    [<Fact>]
-#endif
+    [<FactForNETCOREAPP>]
     let ``F# can use operators declared in C#`` () =
 
         let fsharpSource =
@@ -111,11 +107,7 @@ let main _ =
         |> compileAndRun
         |> shouldSucceed
 
-#if !NETCOREAPP
-    [<Fact(Skip = "NET472 is unsupported runtime for this kind of test.")>]
-#else
-    [<Fact>]
-#endif
+    [<FactForNETCOREAPP>]
     let ``F# can call static methods declared in interfaces from C#`` () =
 
         let csharpLib = csharpBaseClass 
@@ -170,11 +162,7 @@ let main _ =
             ...
         }
     *)
-    #if !NETCOREAPP
-    [<Fact(Skip = "NET472 is unsupported runtime for this kind of test.")>]
-    #else
-    [<Fact>]
-    #endif
+    [<FactForNETCOREAPP>]
     let ``F# generates valid IL for abstract static interface methods`` () =
 
         let csharpLib = csharpBaseClass 
@@ -268,11 +256,7 @@ Next(class StaticsTesting/MyRepeatSequence2 other) cil managed
     }
         """]
     
-#if !NETCOREAPP
-    [<Fact(Skip = "NET472 is unsupported runtime for this kind of test.")>]
-#else
-    [<Fact>]
-#endif
+    [<FactForNETCOREAPP>]
     let ``F# can implement static methods declared in interfaces from C#`` () =
 
         let csharpLib = csharpBaseClass 
@@ -317,11 +301,7 @@ let main _ =
         |> compileAndRun
         |> shouldSucceed
 
-#if !NETCOREAPP
-    [<Fact(Skip = "NET472 is unsupported runtime for this kind of test.")>]
-#else
-    [<Fact>]
-#endif
+    [<FactForNETCOREAPP>]
     let ``F# can implement interfaces with static abstract methods`` () =
 
         let fsharpSource =
@@ -343,11 +323,7 @@ let main _ = 0
         |> compileAndRun
         |> shouldSucceed
 
-#if !NETCOREAPP
-    [<Fact(Skip = "NET472 is unsupported runtime for this kind of test.")>]
-#else
-    [<Fact>]
-#endif
+    [<FactForNETCOREAPP>]
     let ``F# supports inference for types of arguments when implementing interfaces`` () =
 
         let fsharpSource =
@@ -369,11 +345,7 @@ let main _ = 0
         |> compileAndRun
         |> shouldSucceed
 
-#if !NETCOREAPP
-    [<Fact(Skip = "NET472 is unsupported runtime for this kind of test.")>]
-#else
-    [<Fact>]
-#endif
+    [<FactForNETCOREAPP>]
     let ``F# can call interface with static abstract method`` () =
         FSharp
             """
@@ -639,11 +611,7 @@ module Test =
 #endif
         ]
 
-#if !NETCOREAPP
-    [<Fact(Skip = "NET472 is unsupported runtime for this kind of test.")>]
-#else
-    [<Fact>]
-#endif
+    [<FactForNETCOREAPP>]
     let ``C# can call constrained method defined in F#`` () =
         let FSharpLib =
             FSharp """
diff --git a/tests/FSharp.Compiler.ComponentTests/Language/AttributeCheckingTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/AttributeCheckingTests.fs
index a5db85f88de..3ab5266f31a 100644
--- a/tests/FSharp.Compiler.ComponentTests/Language/AttributeCheckingTests.fs
+++ b/tests/FSharp.Compiler.ComponentTests/Language/AttributeCheckingTests.fs
@@ -43,11 +43,7 @@ type C() =
          |> compile
          |> shouldSucceed
     
-#if !NETCOREAPP
-    [<Fact(Skip = "NET472 is unsupported runtime for this kind of test.")>]
-#else
-    [<Fact>]
-#endif
+    [<FSharp.Test.FactForNETCOREAPP>]
     let ``Regression: typechecker does not fail when attribute is on type variable (https://github.com/dotnet/fsharp/issues/13525)`` () =
         let csharpBaseClass = 
             CSharp """
diff --git a/tests/FSharp.Compiler.ComponentTests/Language/ComputationExpressionTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/ComputationExpressionTests.fs
index 52a4ccabe4c..fa1c8c49b42 100644
--- a/tests/FSharp.Compiler.ComponentTests/Language/ComputationExpressionTests.fs
+++ b/tests/FSharp.Compiler.ComponentTests/Language/ComputationExpressionTests.fs
@@ -92,4 +92,47 @@ let x = lb {1; 2; if true then 3;}
         |> compile
         |> shouldFail
         |> withSingleDiagnostic (Error 708, Line 10, Col 19, Line 10, Col 31, "This control construct may only be used if the computation expression builder defines a 'Zero' method")
-        |> ignore
\ No newline at end of file
+        |> ignore
+
+    [<Theory>]
+    [<InlineData("preview","BindReturn")>]
+    [<InlineData("preview","BindReturn")>]
+    [<InlineData("preview","WithoutBindReturn")>]
+    [<InlineData("4.7","BindReturn")>]   
+    [<InlineData("4.7","WithoutBindReturn")>]  
+    let ``A CE with BindReturn and Zero can omit else in an if-then return`` (langVersion, bindReturnName) = 
+        let code = $"""
+type Builder () =
+    member inline __.Return (x: 'T) = Seq.singleton x
+    member inline __.Bind (p: seq<'T>, rest: 'T->seq<'U>) = Seq.collect rest p
+    member inline __.Zero () = Seq.empty
+    member inline __.%s{bindReturnName}  (x : seq<'T>, f: 'T -> 'U)  = Seq.map f x
+
+let seqbuilder= new Builder ()
+
+let _pythags = seqbuilder {{
+  let! z = seq [5;10]  
+  if (z > 6) then return (z,z) }} """
+        code
+        |> FSharp
+        |> withLangVersion langVersion
+        |> typecheck
+        |> shouldSucceed
+
+    [<Fact>] 
+    let ``A CE with BindReturn and Zero can work without Return if flow control is not used`` () = 
+        let code = $"""
+type Builder () =
+    member inline __.Bind (p: seq<'T>, rest: 'T->seq<'U>) = Seq.collect rest p
+    //member inline __.Zero () = Seq.empty
+    member inline __.BindReturn  (x : seq<'T>, f: 'T -> 'U)  = Seq.map f x
+
+let seqbuilder= new Builder ()
+
+let _pythags = seqbuilder {{
+  let! z = seq [5;10]  
+  return (z,z) }} """
+        code
+        |> FSharp     
+        |> typecheck
+        |> shouldSucceed
\ No newline at end of file
diff --git a/tests/FSharp.Compiler.ComponentTests/Language/DynamicAssignmentOperatorTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/DynamicAssignmentOperatorTests.fs
new file mode 100644
index 00000000000..69525f0ef38
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/Language/DynamicAssignmentOperatorTests.fs
@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+namespace FSharp.Compiler.ComponentTests.Language
+
+open System
+open Xunit
+open FSharp.Test.Compiler
+
+module DynamicAssignmentOperatorTests =
+
+    [<Theory>]
+    [<InlineData("6.0")>]
+    [<InlineData("7.0")>]
+    let ``Implementing dynamic assignment operator does not produce a warning`` version = 
+        Fsx """
+        type T = T with
+            static member inline (?<-) (f, x, y) = f x y
+        """
+        |> withLangVersion version
+        |> compile
+        |> shouldSucceed
\ No newline at end of file
diff --git a/tests/FSharp.Compiler.ComponentTests/Language/IndexerSetterParamArray.fs b/tests/FSharp.Compiler.ComponentTests/Language/IndexerSetterParamArray.fs
index 4db7e7be9b4..471e8c9c3a8 100644
--- a/tests/FSharp.Compiler.ComponentTests/Language/IndexerSetterParamArray.fs
+++ b/tests/FSharp.Compiler.ComponentTests/Language/IndexerSetterParamArray.fs
@@ -5,11 +5,10 @@ namespace FSharp.Compiler.ComponentTests
 open Xunit
 open FSharp.Test.Compiler
 
-#if NETCOREAPP
 // Test cases for https://github.com/dotnet/fsharp/issues/9369
 module IndexerSetterParamArray =
 
-    [<Fact>]
+    [<FSharp.Test.FactForNETCOREAPP>]
     let ``Indexer setter can use ParamArray`` () =
         FSharp """
 module One
@@ -59,7 +58,7 @@ if v5 <> "set([|2|], 7); get([|2|])" then failwith "not right value"
 
 
     // In this case the indexers take one initial arg then a ParamArray
-    [<Fact>]
+    [<FSharp.Test.FactForNETCOREAPP>]
     let ``Indexer setter can use ParamArray with one initial arg`` () =
         FSharp """
 module One
@@ -118,7 +117,7 @@ if v5 <> "set(1, [|2|], 7); get(1, [|2|])" then failwith "not right value"
      |> compileExeAndRun
      |> shouldSucceed
 
-    [<Fact>]
+    [<FSharp.Test.FactForNETCOREAPP>]
     let ``Indexer setter via extension can use ParamArray`` () =
         FSharp """
 module One
@@ -169,6 +168,4 @@ if v5 <> "set([|2|], 7); get([|2|])" then failwith "not right value"
     """
      |> ignoreWarnings
      |> compileExeAndRun
-     |> shouldSucceed
-
-#endif
\ No newline at end of file
+     |> shouldSucceed
\ No newline at end of file
diff --git a/tests/FSharp.Compiler.ComponentTests/Language/InterpolatedStringsTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/InterpolatedStringsTests.fs
index 14dbb4fd0a1..c51836e105a 100644
--- a/tests/FSharp.Compiler.ComponentTests/Language/InterpolatedStringsTests.fs
+++ b/tests/FSharp.Compiler.ComponentTests/Language/InterpolatedStringsTests.fs
@@ -30,4 +30,21 @@ let b: System.IComparable = $"string"
 let c: System.IFormattable = $"string"
         """
         |> compile
-        |> shouldSucceed
\ No newline at end of file
+        |> shouldSucceed
+
+    [<Fact>]
+    let ``Interpolated string literal typed as FormattableString handles double braces correctly`` () =
+        Fsx """
+let a = $"{{hello}} world" : System.FormattableString
+printf $"{a.Format}"
+        """
+        |> withLangVersionPreview
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContains "{{hello}} world"
+
+    [<Fact>]
+    let ``Percent sign characters in interpolated strings`` () =
+        Assert.Equal("%", $"%%")
+        Assert.Equal("42%", $"{42}%%")
+        Assert.Equal("% 42", $"%%%3d{42}")
diff --git a/tests/FSharp.Compiler.ComponentTests/Language/StaticClassTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/StaticClassTests.fs
new file mode 100644
index 00000000000..aea9ede61a0
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/Language/StaticClassTests.fs
@@ -0,0 +1,780 @@
+namespace FSharp.Compiler.ComponentTests.Language
+
+open Xunit
+open FSharp.Test.Compiler
+
+module StaticClassTests =
+
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type in lang version70`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type T = class end
+        """
+         |> withLangVersion70
+         |> compile
+         |> shouldSucceed
+
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type in lang preview`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type T = class end
+        """
+         |> withLangVersionPreview
+         |> compile
+         |> shouldSucceed
+
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type with constructor in lang preview`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type T() = class end
+        """
+         |> withLangVersionPreview
+         |> compile
+         |> shouldSucceed
+
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type with constructor in lang version70`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type T() = class end
+        """
+         |> withLangVersion70
+         |> compile
+         |> shouldSucceed
+
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type with constructor with arguments in lang preview`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type T(x: int) = class end
+        """
+         |> withLangVersionPreview
+         |> compile
+         |> shouldFail
+         |> withDiagnostics [
+             (Warning 3552, Line 3, Col 8, Line 3, Col 14, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Constructor with arguments is not allowed.")
+         ]
+
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type with constructor with arguments in lang version70`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type T(x: int) = class end
+        """
+         |> withLangVersion70
+         |> compile
+         |> shouldSucceed
+
+    [<Fact>]
+    let ``When Sealed and AbstractClass on a type with additional constructors in lang preview`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type T =
+    new () = {}
+        """
+         |> withLangVersionPreview
+         |> compile
+         |> shouldFail
+         |> withDiagnostics [
+             (Warning 3553, Line 4, Col 5, Line 4, Col 16, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Additional constructor is not allowed.")
+         ]
+
+    [<Fact>]
+    let ``When Sealed and AbstractClass on a type with additional constructors in lang version70`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type T =
+    new () = {}
+        """
+         |> withLangVersion70
+         |> compile
+         |> shouldSucceed
+
+    [<Fact>]
+    let ``When Sealed and AbstractClass on a type with a primary(parameters) and additional constructor in lang preview`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type T(x: int) =
+    new () = T(42)
+        """
+         |> withLangVersionPreview
+         |> compile
+         |> shouldFail
+         |> withDiagnostics [
+             (Warning 3552, Line 3, Col 8, Line 3, Col 14, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Constructor with arguments is not allowed.")
+             (Warning 3553, Line 4, Col 5, Line 4, Col 19, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Additional constructor is not allowed.")
+         ]
+         
+    [<Fact>]
+    let ``When Sealed and AbstractClass on a type with explicit fields and constructor in lang version70`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type B =
+    val F : int
+    val mutable G : int
+    new () = { F = 3; G = 3 }
+        """
+         |> withLangVersion70
+         |> compile
+         |> shouldSucceed
+    [<Fact>]
+    let ``When Sealed and AbstractClass on a generic type with constructor in lang version70`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type ListDebugView<'T>(l: 'T list) = class end
+        """
+         |> withLangVersion70
+         |> compile
+         |> shouldSucceed
+         
+    [<Fact>]
+    let ``When Sealed and AbstractClass on a generic type with constructor in lang preview`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type ListDebugView<'T>(l: 'T list) = class end
+        """
+         |> withLangVersionPreview
+         |> compile
+         |> shouldFail
+         |> withDiagnostics [
+             (Warning 3552, Line 3, Col 24, Line 3, Col 34, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Constructor with arguments is not allowed.")
+         ]
+
+    [<Fact>]
+    let ``When Sealed and AbstractClass on a type with explicit fields and constructor in lang preview`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type B =
+    val F : int
+    val mutable G : int
+    new () = { F = 3; G = 3 }
+        """
+         |> withLangVersionPreview
+         |> compile
+         |> shouldFail
+         |> withDiagnostics [
+             (Warning 3553, Line 6, Col 5, Line 6, Col 30, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Additional constructor is not allowed.")
+             (Warning 3558, Line 4, Col 9, Line 4, Col 10, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Explicit field declarations are not allowed.")
+             (Warning 3558, Line 5, Col 17, Line 5, Col 18, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Explicit field declarations are not allowed.")
+         ]
+
+    [<Theory>]
+    [<InlineData("preview")>]
+    [<InlineData("7.0")>]
+    let ``Mutually recursive type definition that using custom attributes``(langVersion) =
+        let code = """
+        module Test
+
+        open System.Diagnostics
+
+        [<DefaultAugmentation(false)>]
+        [<DebuggerTypeProxyAttribute(typedefof<MyCustomListDebugView<_>>)>]
+        [<DebuggerDisplay("{DebugDisplay,nq}")>]
+        [<CompiledName("MyCustomList")>]
+        type MyCustomList<'T> = 
+            | Empty
+            | NonEmpty of Head: 'T * Tail: MyCustomList<'T>
+        
+        and MyImbaAlias<'T> = MyCustomList<'T>
+
+        //-------------------------------------------------------------------------
+        // List (debug view)
+        //-------------------------------------------------------------------------
+
+        and
+            MyCustomListDebugView<'T>(l: MyCustomList<'T>) =
+                let asList =
+                    let rec toList ml = 
+                        match ml with
+                        | Empty -> []
+                        | NonEmpty (head,tail) -> head :: (toList tail)
+                    toList l
+
+                [<DebuggerBrowsable(DebuggerBrowsableState.RootHidden)>]
+                member x.Items = asList |> List.toArray
+
+                [<DebuggerBrowsable(DebuggerBrowsableState.Collapsed)>]
+                member x._FullList = asList |> List.toArray
+
+        """
+        Fs code
+        |> withLangVersion langVersion
+        |> compile
+        |> shouldSucceed
+
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type with instance members in lang version70`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type T() =
+    member this.M() = ()
+    static member X = 1
+        """
+         |> withLangVersion70
+         |> compile
+         |> shouldSucceed
+         
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type with instance members in lang preview`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type T() =
+    member this.M() = ()
+    static member X = 1
+        """
+         |> withLangVersionPreview
+         |> compile
+         |> shouldFail
+         |> withDiagnostics [
+             (Warning 3554, Line 4, Col 5, Line 4, Col 25, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Instance members are not allowed.")
+         ]
+         
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type with static members in lang version70`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type T() =
+    static member M() = ()
+    static member X = T.M()
+        """
+         |> withLangVersion70
+         |> compile
+         |> shouldSucceed
+         
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type with static members in lang preview`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type T() =
+    static member M() = ()
+    static member X = T.M()
+        """
+         |> withLangVersionPreview
+         |> compile
+         |> shouldSucceed
+         
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type with static and non static let bindings in lang 70`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type C() =
+    let a = 1
+    static let x = 1
+        """
+         |> withLangVersion70
+         |> compile
+         |> shouldSucceed
+         
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type with static and non static recursive let bindings in lang 70`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type C() =
+    let rec a = 1
+    static let x = 1
+        """
+         |> withLangVersion70
+         |> compile
+         |> shouldSucceed
+         
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type with static let bindings in lang 70`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type C() =
+    static let a = 1
+    static let x = a
+        """
+         |> withLangVersion70
+         |> compile
+         |> shouldSucceed
+         
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type with recursive static let bindings in lang 70`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type C() =
+    static let rec a = 1
+    static let x = a
+        """
+         |> withLangVersion70
+         |> compile
+         |> shouldSucceed
+         
+    [<Fact>]
+    let ``Sealed and AbstractClass with static and non static let bindings in lang preview`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type C() =
+    let a = 1
+    static let X = 1
+        """
+         |> withLangVersionPreview
+         |> compile
+         |> shouldFail
+         |> withDiagnostics [
+             (Warning 3555, Line 4, Col 5, Line 4, Col 14, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Instance let bindings are not allowed.")
+         ]
+         
+    [<Fact>]
+    let ``Sealed and AbstractClass with static and non static recursive let bindings in lang preview`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type C() =
+    let rec a = 1
+    static let X = 1
+        """
+         |> withLangVersionPreview
+         |> compile
+         |> shouldFail
+         |> withDiagnostics [
+             (Warning 3555, Line 4, Col 5, Line 4, Col 18, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Instance let bindings are not allowed.")
+         ]
+
+    [<Fact>]
+    let ``Sealed and AbstractClass with static let bindings in lang preview`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type C() =
+    static let a = 1
+    static let X = a
+        """
+         |> withLangVersionPreview
+         |> compile
+         |> shouldSucceed
+         
+    [<Fact>]
+    let ``Sealed and AbstractClass with recursive static let bindings in lang preview`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type C() =
+    static let rec a = 1
+    static let X = a
+        """
+         |> withLangVersionPreview
+         |> compile
+         |> shouldSucceed
+         
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type implementing interface in lang 70`` () =
+        Fsx """
+type MyInterface =
+    abstract member M : unit -> unit
+
+[<Sealed; AbstractClass>]
+type C() =
+    interface MyInterface with
+        member this.M() = ()
+        """
+         |> withLangVersion70
+         |> compile
+         |> shouldSucceed
+         
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type implicit constructor implementing interface in lang 70`` () =
+        Fsx """
+type MyInterface =
+    abstract member M : unit -> unit
+
+[<Sealed; AbstractClass>]
+type C =
+    interface MyInterface with
+        member this.M() = ()
+        """
+         |> withLangVersion70
+         |> compile
+         |> shouldSucceed
+         
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type implementing interface in lang preview`` () =
+        Fsx """
+type MyInterface =
+    abstract member M : unit -> unit
+
+[<Sealed; AbstractClass>]
+type C() =
+    interface MyInterface with
+        member this.M() = ()
+        """
+         |> withLangVersionPreview
+         |> compile
+         |> shouldFail
+         |> withDiagnostics [
+            (Warning 3556, Line 8, Col 9, Line 8, Col 29, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Implementing interfaces is not allowed.")
+         ]
+         
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type implicit constructor implementing interface in lang preview`` () =
+        Fsx """
+type MyInterface =
+    abstract member M : unit -> unit
+
+[<Sealed; AbstractClass>]
+type C =
+    interface MyInterface with
+        member this.M() = ()
+        """
+         |> withLangVersionPreview
+         |> compile
+         |> shouldFail
+         |> withDiagnostics [
+            (Warning 3556, Line 8, Col 9, Line 8, Col 29, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Implementing interfaces is not allowed.")
+         ]
+         
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type implicit constructor declaring abstract members in Lang 70`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type T =
+    abstract A : int
+    abstract B : int with get, set
+    abstract C : i:int -> int
+    abstract D : i:int -> int
+        """
+         |> withLangVersion70
+         |> compile
+         |> shouldSucceed
+    
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type declaring abstract members in Lang 70`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type T() =
+    abstract A : int
+    abstract B : int with get, set
+    abstract C : i:int -> int
+    abstract D : i:int -> int
+        """
+         |> withLangVersion70
+         |> compile
+         |> shouldSucceed
+         
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type with implicit constructor declaring abstract members in Lang preview`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type T =
+    abstract C : i:int -> int
+    abstract D : i:int -> int
+        """
+         |> withLangVersionPreview
+         |> compile
+         |> shouldFail
+         |> withDiagnostics [
+             (Warning 3557, Line 4, Col 14, Line 4, Col 15, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Abstract member declarations are not allowed.")
+             (Warning 3557, Line 5, Col 14, Line 5, Col 15, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Abstract member declarations are not allowed.")
+         ]
+         
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type declaring abstract members in Lang preview`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type T() =
+    abstract C : i:int -> int
+    abstract D : i:int -> int
+        """
+         |> withLangVersionPreview
+         |> compile
+         |> shouldFail
+         |> withDiagnostics [
+             (Warning 3557, Line 4, Col 14, Line 4, Col 15, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Abstract member declarations are not allowed.")
+             (Warning 3557, Line 5, Col 14, Line 5, Col 15, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Abstract member declarations are not allowed.")
+         ]
+
+    #if !NETCOREAPP
+    [<Fact(Skip = "IWSAMs are not supported by NET472.")>]
+    #else
+    [<Fact>]
+    #endif
+    let ``Sealed and AbstractClass on a type implementing an interface with static abstract members in Lang 70`` () =
+        Fsx """
+[<Interface>]
+type InputRetriever<'T when 'T:>InputRetriever<'T>> =
+    static abstract Read: unit -> string
+
+[<AbstractClass;Sealed>]
+type ConsoleRetriever = 
+    interface InputRetriever<ConsoleRetriever> with
+        static member Read() = 
+            stdout.WriteLine("Please enter a value and press enter")
+            stdin.ReadLine()
+        """
+         |> withNoWarn 3535
+         |> withLangVersion70
+         |> compile
+         |> shouldSucceed
+         
+    #if !NETCOREAPP
+    [<Fact(Skip = "IWSAMs are not supported by NET472.")>]
+    #else
+    [<Fact>]
+    #endif
+    let ``Sealed and AbstractClass on a type implicit constructor implementing an interface with static abstract members in Lang preview`` () =
+        Fsx """
+[<Interface>]
+type InputRetriever<'T when 'T:>InputRetriever<'T>> =
+    static abstract Read: unit -> string
+
+[<AbstractClass;Sealed>]
+type ConsoleRetriever = 
+    interface InputRetriever<ConsoleRetriever> with
+        static member Read() = 
+            stdout.WriteLine("Please enter a value and press enter")
+            stdin.ReadLine()
+        """
+         |> withNoWarn 3535
+         |> withLangVersionPreview
+         |> compile
+         |> shouldSucceed
+         
+    #if !NETCOREAPP
+    [<Fact(Skip = "IWSAMs are not supported by NET472.")>]
+    #else
+    [<Fact>]
+    #endif
+    let ``Sealed and AbstractClass on a type implementing an interface with static abstract members in Lang preview`` () =
+        Fsx """
+[<Interface>]
+type InputRetriever<'T when 'T:>InputRetriever<'T>> =
+    static abstract Read: unit -> string
+
+[<AbstractClass;Sealed>]
+type ConsoleRetriever() = 
+    interface InputRetriever<ConsoleRetriever> with
+        static member Read() = 
+            stdout.WriteLine("Please enter a value and press enter")
+            stdin.ReadLine()
+        """
+         |> withNoWarn 3535
+         |> withLangVersionPreview
+         |> compile
+         |> shouldSucceed
+         
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type with implicit constructor declaring static explicit field in Lang 70`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type T =
+    [<DefaultValue>]
+    static val mutable private F : int
+    [<DefaultValue>]
+    static val mutable private G : int
+    
+    static member Inc() = T.F <- T.F + 1
+    
+    static member Get() = T.F
+        """
+         |> withLangVersion70
+         |> compile
+         |> shouldSucceed
+         
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type with declaring static explicit field in Lang 70`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type T() =
+    [<DefaultValue>]
+    static val mutable private F : int
+    [<DefaultValue>]
+    static val mutable private G : int
+    
+    static member Inc() = T.F <- T.F + 1
+    
+    static member Get() = T.F
+        """
+         |> withLangVersion70
+         |> compile
+         |> shouldSucceed
+         
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type with implicit constructor declaring static explicit field in Lang preview`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type T =
+    [<DefaultValue>]
+    static val mutable private F : int
+    [<DefaultValue>]
+    static val mutable private G : int
+    
+    static member Inc() = T.F <- T.F + 1
+    
+    static member Get() = T.F
+        """
+         |> withLangVersionPreview
+         |> compile
+         |> shouldSucceed
+         
+    [<Fact>]
+    let ``Sealed and AbstractClass on a type with declaring static explicit field in Lang preview`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type T() =
+    [<DefaultValue>]
+    static val mutable private F : int
+    [<DefaultValue>]
+    static val mutable private G : int
+    
+    static member Inc() = T.F <- T.F + 1
+    
+    static member Get() = T.F
+        """
+         |> withLangVersionPreview
+         |> compile
+         |> shouldSucceed
+         
+    [<Fact>]
+    let ``When Sealed and AbstractClass on a type with non static explicit fields and implicit constructor in lang 70`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type B =
+    val F : int
+    val mutable G : int
+        """
+         |> withLangVersion70
+         |> compile
+         |> shouldSucceed
+
+    [<Fact>]
+    let ``When Sealed and AbstractClass on a type with non static explicit fields and constructor in lang 70`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type B() =
+    val F : int
+    val mutable G : int
+        """
+         |> withLangVersion70
+         |> compile
+         |> shouldFail
+         |> withDiagnostics [
+             (Error 880, Line 4, Col 9, Line 4, Col 16, "Uninitialized 'val' fields must be mutable and marked with the '[<DefaultValue>]' attribute. Consider using a 'let' binding instead of a 'val' field.")
+             (Error 880, Line 5, Col 17, Line 5, Col 24, "Uninitialized 'val' fields must be mutable and marked with the '[<DefaultValue>]' attribute. Consider using a 'let' binding instead of a 'val' field.")
+         ]
+
+    [<Fact>]
+    let ``When Sealed and AbstractClass on a type with non static explicit fields and implicit constructor in lang preview`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type B =
+    val F : int
+    val mutable G : int
+        """
+         |> withLangVersionPreview
+         |> compile
+         |> shouldFail
+         |> withDiagnostics [
+             (Warning 3558, Line 4, Col 9, Line 4, Col 10, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Explicit field declarations are not allowed.")
+             (Warning 3558, Line 5, Col 17, Line 5, Col 18, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Explicit field declarations are not allowed.")
+         ]
+         
+    [<Fact>]
+    let ``When Sealed and AbstractClass on a type with non static explicit fields and constructor in lang preview`` () =
+        Fsx """
+[<Sealed; AbstractClass>]
+type B() =
+    val F : int
+    val mutable G : int
+        """
+         |> withLangVersionPreview
+         |> compile
+         |> shouldFail
+         |> withDiagnostics [
+             (Error 880, Line 4, Col 9, Line 4, Col 16, "Uninitialized 'val' fields must be mutable and marked with the '[<DefaultValue>]' attribute. Consider using a 'let' binding instead of a 'val' field.")
+             (Error 880, Line 5, Col 17, Line 5, Col 24, "Uninitialized 'val' fields must be mutable and marked with the '[<DefaultValue>]' attribute. Consider using a 'let' binding instead of a 'val' field.")
+             (Warning 3558, Line 4, Col 9, Line 4, Col 10, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Explicit field declarations are not allowed.")
+             (Warning 3558, Line 5, Col 17, Line 5, Col 18, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Explicit field declarations are not allowed.")
+         ]
+    
+    [<Fact>]
+    let ``Sealed and AbstractClass on a types with instance member properties on lang version70`` () =
+        Fsx """ 
+[<Sealed; AbstractClass>]
+type T =
+    member _.Item with get i = 3
+    member _.Item1 with set i value = ()
+    member _.Item2 with get i = 3 and set i value = ()
+        """
+         |> withLangVersion70
+         |> compile
+         |> shouldSucceed
+
+    [<Fact>]
+    let ``Sealed and AbstractClass on a types with instance member properties on lang preview`` () =
+        Fsx """ 
+[<Sealed; AbstractClass>]
+type T =
+    member _.Item with get i = 3
+    member _.Item1 with set i value = ()
+    member _.Item2 with get i = 3 and set i value = ()
+        """
+         |> withLangVersionPreview
+         |> compile
+         |> shouldFail
+         |> withDiagnostics [
+             (Warning 3554, Line 4, Col 5, Line 4, Col 33, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Instance members are not allowed.")
+             (Warning 3554, Line 5, Col 5, Line 5, Col 41, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Instance members are not allowed.")
+             (Warning 3554, Line 6, Col 5, Line 6, Col 55, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Instance members are not allowed.")
+         ]
+         
+    [<Fact>]
+    let ``Sealed and AbstractClass on types with non static members lang version70`` () =
+        Fsx """ 
+[<Sealed; AbstractClass>]
+type T =
+    abstract A : int
+    abstract B : int with get, set
+    abstract C : i:int -> int
+    abstract D : i:int -> int
+    default _.D i = i + 3
+    member _.E = 3
+    val F : int
+    val mutable G : int
+    member _.H (i, j) = i + j
+    member _.Item with get i = 3 and set i value = ()
+    override _.ToString () = "🙃"
+    new () = { F = 3; G = 3 }
+    new (x, y) = { F = x; G = y }
+        """
+         |> withLangVersion70
+         |> compile
+         |> shouldSucceed
+         
+    [<Fact>]
+    let ``Sealed and AbstractClass on a types with non static members in lang version preview`` () =
+        Fsx """ 
+[<Sealed; AbstractClass>]
+type T =
+    abstract A : int
+    abstract B : int with get, set
+    abstract C : i:int -> int
+    abstract D : i:int -> int
+    default _.D i = i + 3
+    member _.E = 3
+    val F : int
+    val mutable G : int
+    member _.H (i, j) = i + j
+    member _.Item with get i = 3 and set i value = ()
+    override _.ToString () = "🙃"
+    new () = { F = 3; G = 3 }
+    new (x, y) = { F = x; G = y }
+        """
+         |> withLangVersionPreview
+         |> compile
+         |> shouldFail
+         |> withDiagnostics [
+             (Warning 3554, Line 8, Col 5, Line 8, Col 26, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Instance members are not allowed.")
+             (Warning 3554, Line 9, Col 5, Line 9, Col 19, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Instance members are not allowed.")
+             (Warning 3554, Line 12, Col 5, Line 12, Col 30, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Instance members are not allowed.")
+             (Warning 3554, Line 13, Col 5, Line 13, Col 54, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Instance members are not allowed.")
+             (Warning 3554, Line 14, Col 5, Line 14, Col 34, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Instance members are not allowed.")
+             (Warning 3553, Line 15, Col 5, Line 15, Col 30, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Additional constructor is not allowed.")
+             (Warning 3553, Line 16, Col 5, Line 16, Col 34, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Additional constructor is not allowed.")
+             (Warning 3557, Line 4, Col 14, Line 4, Col 15, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Abstract member declarations are not allowed.")
+             (Warning 3557, Line 5, Col 14, Line 5, Col 15, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Abstract member declarations are not allowed.")
+             (Warning 3557, Line 6, Col 14, Line 6, Col 15, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Abstract member declarations are not allowed.")
+             (Warning 3557, Line 7, Col 14, Line 7, Col 15, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Abstract member declarations are not allowed.")
+             (Warning 3558, Line 10, Col 9, Line 10, Col 10, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Explicit field declarations are not allowed.")
+             (Warning 3558, Line 11, Col 17, Line 11, Col 18, "If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Explicit field declarations are not allowed.")
+         ]
\ No newline at end of file
diff --git a/tests/FSharp.Compiler.ComponentTests/Scripting/Interactive.fs b/tests/FSharp.Compiler.ComponentTests/Scripting/Interactive.fs
index faf21a9c7a9..cfc86ff3618 100644
--- a/tests/FSharp.Compiler.ComponentTests/Scripting/Interactive.fs
+++ b/tests/FSharp.Compiler.ComponentTests/Scripting/Interactive.fs
@@ -3,6 +3,7 @@
 namespace FSharp.Compiler.ComponentTests.Scripting
 
 open Xunit
+open System
 open FSharp.Test.Compiler
 
 module ``Interactive tests`` =
@@ -35,3 +36,17 @@ module ``External FSI tests`` =
         Fsx "1+a"
         |> runFsi
         |> shouldFail
+
+
+    [<Fact>]
+    let ``Internals visible over a large number of submissions``() =
+        let submission =
+            let lines = [|
+                yield """let internal original_submission = "From the first submission";;""" + Environment.NewLine
+                for _ in 1 .. 200 do yield """if original_submission <> "From the first submission" then failwith $"Failed to read an internal at line: {__LINE__}";;""" + Environment.NewLine
+                |]
+            lines |> Array.fold(fun acc line -> acc + line) ""
+        Fsx submission
+        |> runFsi
+        |> shouldSucceed
+
diff --git a/tests/FSharp.Compiler.ComponentTests/SkipLocalsInit.fs b/tests/FSharp.Compiler.ComponentTests/SkipLocalsInit.fs
index 8b69fa73281..65ba4655cc2 100644
--- a/tests/FSharp.Compiler.ComponentTests/SkipLocalsInit.fs
+++ b/tests/FSharp.Compiler.ComponentTests/SkipLocalsInit.fs
@@ -5,9 +5,8 @@ namespace FSharp.Compiler.ComponentTests.EmittedIL
 open Xunit
 open FSharp.Test.Compiler
 
-#if NETCOREAPP
 module ``SkipLocalsInit`` =
-    [<Fact>]
+    [<FSharp.Test.FactForNETCOREAPP>]
     let ``Init in function and closure not emitted when applied on function``() =
         FSharp """
 module SkipLocalsInit
@@ -35,7 +34,7 @@ let x () =
   .maxstack  6
   .locals (int32 V_0)"""]
 
-    [<Fact>]
+    [<FSharp.Test.FactForNETCOREAPP>]
     let ``Init in static method not emitted when applied on class``() =
         FSharp """
 module SkipLocalsInit
@@ -60,7 +59,7 @@ type X () =
   .maxstack  4
   .locals (int32 V_0)"""]
 
-    [<Fact>]
+    [<FSharp.Test.FactForNETCOREAPP>]
     let ``Init in static method and function not emitted when applied on module``() =
         FSharp """
 [<System.Runtime.CompilerServices.SkipLocalsInitAttribute>]
@@ -97,7 +96,7 @@ type X () =
   .maxstack  4
   .locals (int32 V_0)"""]
 
-    [<Fact>]
+    [<FSharp.Test.FactForNETCOREAPP>]
     let ``Init in method and closure not emitted when applied on method``() =
         FSharp """
 module SkipLocalsInit
@@ -131,7 +130,7 @@ type X () =
   .locals (int32 V_0)
 """ ]
 
-    [<Fact>]
+    [<FSharp.Test.FactForNETCOREAPP>]
     let ``Zero init performed to get defaults despite the attribute``() =
         FSharp """
 module SkipLocalsInit
@@ -180,5 +179,4 @@ IL_0019:  ldarg.0
 IL_001a:  ldloc.0
 IL_001b:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [runtime]System.Nullable`1<int64>,!!a>::Invoke(!0)
 IL_0020:  stloc.2
-IL_0021:  ret"""]
-#endif
\ No newline at end of file
+IL_0021:  ret"""]
\ No newline at end of file
diff --git a/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected b/tests/FSharp.Compiler.Service.Tests/FSharp.Compiler.Service.SurfaceArea.netstandard20.debug.bsl
similarity index 98%
rename from tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected
rename to tests/FSharp.Compiler.Service.Tests/FSharp.Compiler.Service.SurfaceArea.netstandard20.debug.bsl
index aa47d72a960..8ce003becdf 100644
--- a/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected
+++ b/tests/FSharp.Compiler.Service.Tests/FSharp.Compiler.Service.SurfaceArea.netstandard20.debug.bsl
@@ -1,4 +1,12 @@
-FSharp.Compiler.AbstractIL.IL
+! AssemblyReference: FSharp.Core
+! AssemblyReference: System.Buffers
+! AssemblyReference: System.Collections.Immutable
+! AssemblyReference: System.Diagnostics.DiagnosticSource
+! AssemblyReference: System.Memory
+! AssemblyReference: System.Reflection.Emit
+! AssemblyReference: System.Reflection.Emit.ILGeneration
+! AssemblyReference: System.Reflection.Metadata
+! AssemblyReference: netstandard
 FSharp.Compiler.AbstractIL.IL+ILArgConvention+Tags: Int32 CDecl
 FSharp.Compiler.AbstractIL.IL+ILArgConvention+Tags: Int32 Default
 FSharp.Compiler.AbstractIL.IL+ILArgConvention+Tags: Int32 FastCall
@@ -1866,7 +1874,6 @@ FSharp.Compiler.AbstractIL.IL: ILTypeDefs mkILTypeDefsComputed(Microsoft.FSharp.
 FSharp.Compiler.AbstractIL.IL: ILTypeDefs mkILTypeDefsFromArray(ILTypeDef[])
 FSharp.Compiler.AbstractIL.IL: Int32 NoMetadataIdx
 FSharp.Compiler.AbstractIL.IL: Int32 get_NoMetadataIdx()
-FSharp.Compiler.AbstractIL.ILBinaryReader
 FSharp.Compiler.AbstractIL.ILBinaryReader+ILModuleReader: ILModuleDef ILModuleDef
 FSharp.Compiler.AbstractIL.ILBinaryReader+ILModuleReader: ILModuleDef get_ILModuleDef()
 FSharp.Compiler.AbstractIL.ILBinaryReader+ILModuleReader: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILAssemblyRef] ILAssemblyRefs
@@ -1935,7 +1942,22 @@ FSharp.Compiler.AbstractIL.ILBinaryReader: FSharp.Compiler.AbstractIL.ILBinaryRe
 FSharp.Compiler.AbstractIL.ILBinaryReader: FSharp.Compiler.AbstractIL.ILBinaryReader+MetadataOnlyFlag
 FSharp.Compiler.AbstractIL.ILBinaryReader: FSharp.Compiler.AbstractIL.ILBinaryReader+ReduceMemoryFlag
 FSharp.Compiler.AbstractIL.ILBinaryReader: FSharp.Compiler.AbstractIL.ILBinaryReader+Shim
-FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer
+FSharp.Compiler.CodeAnalysis.DocumentSource+Custom: Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.ISourceText]] Item
+FSharp.Compiler.CodeAnalysis.DocumentSource+Custom: Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.ISourceText]] get_Item()
+FSharp.Compiler.CodeAnalysis.DocumentSource+Tags: Int32 Custom
+FSharp.Compiler.CodeAnalysis.DocumentSource+Tags: Int32 FileSystem
+FSharp.Compiler.CodeAnalysis.DocumentSource: Boolean IsCustom
+FSharp.Compiler.CodeAnalysis.DocumentSource: Boolean IsFileSystem
+FSharp.Compiler.CodeAnalysis.DocumentSource: Boolean get_IsCustom()
+FSharp.Compiler.CodeAnalysis.DocumentSource: Boolean get_IsFileSystem()
+FSharp.Compiler.CodeAnalysis.DocumentSource: FSharp.Compiler.CodeAnalysis.DocumentSource FileSystem
+FSharp.Compiler.CodeAnalysis.DocumentSource: FSharp.Compiler.CodeAnalysis.DocumentSource NewCustom(Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.ISourceText]])
+FSharp.Compiler.CodeAnalysis.DocumentSource: FSharp.Compiler.CodeAnalysis.DocumentSource get_FileSystem()
+FSharp.Compiler.CodeAnalysis.DocumentSource: FSharp.Compiler.CodeAnalysis.DocumentSource+Custom
+FSharp.Compiler.CodeAnalysis.DocumentSource: FSharp.Compiler.CodeAnalysis.DocumentSource+Tags
+FSharp.Compiler.CodeAnalysis.DocumentSource: Int32 Tag
+FSharp.Compiler.CodeAnalysis.DocumentSource: Int32 get_Tag()
+FSharp.Compiler.CodeAnalysis.DocumentSource: System.String ToString()
 FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer+Succeeded: FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults Item
 FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer+Succeeded: FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults get_Item()
 FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer+Tags: Int32 Aborted
@@ -1957,7 +1979,6 @@ FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer: Int32 GetHashCode(System.Col
 FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer: Int32 Tag
 FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer: Int32 get_Tag()
 FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer: System.String ToString()
-FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults
 FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: Boolean HasFullTypeCheckInfo
 FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: Boolean IsRelativeNameResolvableFromSymbol(FSharp.Compiler.Text.Position, Microsoft.FSharp.Collections.FSharpList`1[System.String], FSharp.Compiler.Symbols.FSharpSymbol)
 FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: Boolean get_HasFullTypeCheckInfo()
@@ -1991,7 +2012,6 @@ FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: System.String ToString()
 FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: System.String[] DependencyFiles
 FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: System.String[] get_DependencyFiles()
 FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: System.Tuple`2[FSharp.Compiler.Text.Range,System.Int32][] GetFormatSpecifierLocationsAndArity()
-FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults
 FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults: Boolean HasCriticalErrors
 FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults: Boolean get_HasCriticalErrors()
 FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults: FSharp.Compiler.CodeAnalysis.FSharpProjectContext ProjectContext
@@ -2008,8 +2028,7 @@ FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults: FSharp.Compiler.Symbols.
 FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults: System.String ToString()
 FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults: System.String[] DependencyFiles
 FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults: System.String[] get_DependencyFiles()
-FSharp.Compiler.CodeAnalysis.FSharpChecker
-FSharp.Compiler.CodeAnalysis.FSharpChecker: FSharp.Compiler.CodeAnalysis.FSharpChecker Create(Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.CodeAnalysis.LegacyReferenceResolver], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[System.String,System.DateTime],Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Object,System.IntPtr,System.Int32]]]], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+FSharp.Compiler.CodeAnalysis.FSharpChecker: FSharp.Compiler.CodeAnalysis.FSharpChecker Create(Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.CodeAnalysis.LegacyReferenceResolver], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[System.String,System.DateTime],Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Object,System.IntPtr,System.Int32]]]], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.CodeAnalysis.DocumentSource])
 FSharp.Compiler.CodeAnalysis.FSharpChecker: FSharp.Compiler.CodeAnalysis.FSharpChecker Instance
 FSharp.Compiler.CodeAnalysis.FSharpChecker: FSharp.Compiler.CodeAnalysis.FSharpChecker get_Instance()
 FSharp.Compiler.CodeAnalysis.FSharpChecker: FSharp.Compiler.CodeAnalysis.FSharpProjectOptions GetProjectOptionsFromCommandLineArgs(System.String, System.String[], Microsoft.FSharp.Core.FSharpOption`1[System.DateTime], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
@@ -2025,6 +2044,7 @@ FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync
 FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[FSharp.Compiler.CodeAnalysis.FSharpParseFileResults] ParseFileInProject(System.String, System.String, FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.String])
 FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer]] CheckFileInProjectAllowingStaleCachedResults(FSharp.Compiler.CodeAnalysis.FSharpParseFileResults, System.String, Int32, System.String, FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, Microsoft.FSharp.Core.FSharpOption`1[System.String])
 FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.EditorServices.SemanticClassificationView]] GetBackgroundSemanticClassificationForFile(System.String, FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] NotifyFileChanged(System.String, FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, Microsoft.FSharp.Core.FSharpOption`1[System.String])
 FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] NotifyProjectCleaned(FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, Microsoft.FSharp.Core.FSharpOption`1[System.String])
 FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[System.Collections.Generic.IEnumerable`1[FSharp.Compiler.Text.Range]] FindBackgroundReferencesInFile(System.String, FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, FSharp.Compiler.Symbols.FSharpSymbol, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.String])
 FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[System.Tuple`2[FSharp.Compiler.CodeAnalysis.FSharpParseFileResults,FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer]] ParseAndCheckFileInProject(System.String, Int32, FSharp.Compiler.Text.ISourceText, FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, Microsoft.FSharp.Core.FSharpOption`1[System.String])
@@ -2050,7 +2070,6 @@ FSharp.Compiler.CodeAnalysis.FSharpChecker: Void ClearCache(System.Collections.G
 FSharp.Compiler.CodeAnalysis.FSharpChecker: Void ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients()
 FSharp.Compiler.CodeAnalysis.FSharpChecker: Void InvalidateAll()
 FSharp.Compiler.CodeAnalysis.FSharpChecker: Void InvalidateConfiguration(FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, Microsoft.FSharp.Core.FSharpOption`1[System.String])
-FSharp.Compiler.CodeAnalysis.FSharpParseFileResults
 FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: Boolean IsBindingALambdaAtPosition(FSharp.Compiler.Text.Position)
 FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: Boolean IsPosContainedInApplication(FSharp.Compiler.Text.Position)
 FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: Boolean IsPositionContainedInACurriedParameter(FSharp.Compiler.Text.Position)
@@ -2078,7 +2097,6 @@ FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: System.String FileName
 FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: System.String get_FileName()
 FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: System.String[] DependencyFiles
 FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: System.String[] get_DependencyFiles()
-FSharp.Compiler.CodeAnalysis.FSharpParsingOptions
 FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean ApplyLineDirectives
 FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean CompilingFSharpCore
 FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean Equals(FSharp.Compiler.CodeAnalysis.FSharpParsingOptions)
@@ -2109,13 +2127,11 @@ FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: System.String get_LangVersion
 FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: System.String[] SourceFiles
 FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: System.String[] get_SourceFiles()
 FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Void .ctor(System.String[], Boolean, Microsoft.FSharp.Collections.FSharpList`1[System.String], FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions, System.String, Boolean, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Boolean, Boolean)
-FSharp.Compiler.CodeAnalysis.FSharpProjectContext
 FSharp.Compiler.CodeAnalysis.FSharpProjectContext: FSharp.Compiler.CodeAnalysis.FSharpProjectOptions ProjectOptions
 FSharp.Compiler.CodeAnalysis.FSharpProjectContext: FSharp.Compiler.CodeAnalysis.FSharpProjectOptions get_ProjectOptions()
 FSharp.Compiler.CodeAnalysis.FSharpProjectContext: FSharp.Compiler.Symbols.FSharpAccessibilityRights AccessibilityRights
 FSharp.Compiler.CodeAnalysis.FSharpProjectContext: FSharp.Compiler.Symbols.FSharpAccessibilityRights get_AccessibilityRights()
 FSharp.Compiler.CodeAnalysis.FSharpProjectContext: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpAssembly] GetReferencedAssemblies()
-FSharp.Compiler.CodeAnalysis.FSharpProjectOptions
 FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: Boolean Equals(FSharp.Compiler.CodeAnalysis.FSharpProjectOptions)
 FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: Boolean Equals(System.Object)
 FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
@@ -2145,7 +2161,6 @@ FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: System.String[] SourceFiles
 FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: System.String[] get_OtherOptions()
 FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: System.String[] get_SourceFiles()
 FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: Void .ctor(System.String, Microsoft.FSharp.Core.FSharpOption`1[System.String], System.String[], System.String[], FSharp.Compiler.CodeAnalysis.FSharpReferencedProject[], Boolean, Boolean, System.DateTime, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.CodeAnalysis.FSharpUnresolvedReferencesSet], Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[FSharp.Compiler.Text.Range,System.String,System.String]], Microsoft.FSharp.Core.FSharpOption`1[System.Int64])
-FSharp.Compiler.CodeAnalysis.FSharpReferencedProject
 FSharp.Compiler.CodeAnalysis.FSharpReferencedProject: Boolean Equals(System.Object)
 FSharp.Compiler.CodeAnalysis.FSharpReferencedProject: FSharp.Compiler.CodeAnalysis.FSharpReferencedProject CreateFSharp(System.String, FSharp.Compiler.CodeAnalysis.FSharpProjectOptions)
 FSharp.Compiler.CodeAnalysis.FSharpReferencedProject: FSharp.Compiler.CodeAnalysis.FSharpReferencedProject CreateFromILModuleReader(System.String, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.DateTime], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,FSharp.Compiler.AbstractIL.ILBinaryReader+ILModuleReader])
@@ -2154,7 +2169,6 @@ FSharp.Compiler.CodeAnalysis.FSharpReferencedProject: Int32 GetHashCode()
 FSharp.Compiler.CodeAnalysis.FSharpReferencedProject: System.String OutputFile
 FSharp.Compiler.CodeAnalysis.FSharpReferencedProject: System.String ToString()
 FSharp.Compiler.CodeAnalysis.FSharpReferencedProject: System.String get_OutputFile()
-FSharp.Compiler.CodeAnalysis.FSharpSymbolUse
 FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean IsFromAttribute
 FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean IsFromComputationExpression
 FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean IsFromDefinition
@@ -2184,21 +2198,17 @@ FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Microsoft.FSharp.Collections.FShar
 FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: System.String FileName
 FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: System.String ToString()
 FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: System.String get_FileName()
-FSharp.Compiler.CodeAnalysis.FSharpUnresolvedReferencesSet
 FSharp.Compiler.CodeAnalysis.FSharpUnresolvedReferencesSet: Boolean Equals(FSharp.Compiler.CodeAnalysis.FSharpUnresolvedReferencesSet)
 FSharp.Compiler.CodeAnalysis.FSharpUnresolvedReferencesSet: Boolean Equals(System.Object)
 FSharp.Compiler.CodeAnalysis.FSharpUnresolvedReferencesSet: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
 FSharp.Compiler.CodeAnalysis.FSharpUnresolvedReferencesSet: Int32 GetHashCode()
 FSharp.Compiler.CodeAnalysis.FSharpUnresolvedReferencesSet: Int32 GetHashCode(System.Collections.IEqualityComparer)
 FSharp.Compiler.CodeAnalysis.FSharpUnresolvedReferencesSet: System.String ToString()
-FSharp.Compiler.CodeAnalysis.ILegacyReferenceResolver
 FSharp.Compiler.CodeAnalysis.ILegacyReferenceResolver: FSharp.Compiler.CodeAnalysis.LegacyResolvedFile[] Resolve(FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment, System.Tuple`2[System.String,System.String][], System.String, Microsoft.FSharp.Collections.FSharpList`1[System.String], System.String, System.String, Microsoft.FSharp.Collections.FSharpList`1[System.String], System.String, Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[System.Boolean,Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.Unit]]])
 FSharp.Compiler.CodeAnalysis.ILegacyReferenceResolver: System.String DotNetFrameworkReferenceAssembliesRootDirectory
 FSharp.Compiler.CodeAnalysis.ILegacyReferenceResolver: System.String HighestInstalledNetFrameworkVersion()
 FSharp.Compiler.CodeAnalysis.ILegacyReferenceResolver: System.String get_DotNetFrameworkReferenceAssembliesRootDirectory()
-FSharp.Compiler.CodeAnalysis.LegacyReferenceResolver
 FSharp.Compiler.CodeAnalysis.LegacyReferenceResolver: Void .ctor(FSharp.Compiler.CodeAnalysis.ILegacyReferenceResolver)
-FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment
 FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment+EditingOrCompilation: Boolean get_isEditing()
 FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment+EditingOrCompilation: Boolean isEditing
 FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment+Tags: Int32 CompilationAndEvaluation
@@ -2223,14 +2233,12 @@ FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment: Int32 GetHashCode(Syst
 FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment: Int32 Tag
 FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment: Int32 get_Tag()
 FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment: System.String ToString()
-FSharp.Compiler.CodeAnalysis.LegacyResolutionFailure
 FSharp.Compiler.CodeAnalysis.LegacyResolutionFailure: Boolean Equals(System.Object)
 FSharp.Compiler.CodeAnalysis.LegacyResolutionFailure: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
 FSharp.Compiler.CodeAnalysis.LegacyResolutionFailure: Int32 GetHashCode()
 FSharp.Compiler.CodeAnalysis.LegacyResolutionFailure: Int32 GetHashCode(System.Collections.IEqualityComparer)
 FSharp.Compiler.CodeAnalysis.LegacyResolutionFailure: System.String get_Message()
 FSharp.Compiler.CodeAnalysis.LegacyResolutionFailure: Void .ctor()
-FSharp.Compiler.CodeAnalysis.LegacyResolvedFile
 FSharp.Compiler.CodeAnalysis.LegacyResolvedFile: Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[System.String,System.String],System.String] get_prepareToolTip()
 FSharp.Compiler.CodeAnalysis.LegacyResolvedFile: Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[System.String,System.String],System.String] prepareToolTip
 FSharp.Compiler.CodeAnalysis.LegacyResolvedFile: System.String ToString()
@@ -2239,7 +2247,6 @@ FSharp.Compiler.CodeAnalysis.LegacyResolvedFile: System.String get_baggage()
 FSharp.Compiler.CodeAnalysis.LegacyResolvedFile: System.String get_itemSpec()
 FSharp.Compiler.CodeAnalysis.LegacyResolvedFile: System.String itemSpec
 FSharp.Compiler.CodeAnalysis.LegacyResolvedFile: Void .ctor(System.String, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[System.String,System.String],System.String], System.String)
-FSharp.Compiler.CompilerEnvironment
 FSharp.Compiler.CompilerEnvironment: Boolean IsCheckerSupportedSubcategory(System.String)
 FSharp.Compiler.CompilerEnvironment: Boolean IsCompilable(System.String)
 FSharp.Compiler.CompilerEnvironment: Boolean IsScriptFile(System.String)
@@ -2248,14 +2255,11 @@ FSharp.Compiler.CompilerEnvironment: Microsoft.FSharp.Collections.FSharpList`1[S
 FSharp.Compiler.CompilerEnvironment: Microsoft.FSharp.Collections.FSharpList`1[System.String] GetConditionalDefinesForEditing(FSharp.Compiler.CodeAnalysis.FSharpParsingOptions)
 FSharp.Compiler.CompilerEnvironment: Microsoft.FSharp.Core.FSharpOption`1[System.String] BinFolderOfDefaultFSharpCompiler(Microsoft.FSharp.Core.FSharpOption`1[System.String])
 FSharp.Compiler.CompilerEnvironment: System.Guid GetDebuggerLanguageID()
-FSharp.Compiler.DependencyManager.AssemblyResolutionProbe
 FSharp.Compiler.DependencyManager.AssemblyResolutionProbe: System.Collections.Generic.IEnumerable`1[System.String] EndInvoke(System.IAsyncResult)
 FSharp.Compiler.DependencyManager.AssemblyResolutionProbe: System.Collections.Generic.IEnumerable`1[System.String] Invoke()
 FSharp.Compiler.DependencyManager.AssemblyResolutionProbe: System.IAsyncResult BeginInvoke(System.AsyncCallback, System.Object)
 FSharp.Compiler.DependencyManager.AssemblyResolutionProbe: Void .ctor(System.Object, IntPtr)
-FSharp.Compiler.DependencyManager.AssemblyResolveHandler
 FSharp.Compiler.DependencyManager.AssemblyResolveHandler: Void .ctor(FSharp.Compiler.DependencyManager.AssemblyResolutionProbe)
-FSharp.Compiler.DependencyManager.DependencyProvider
 FSharp.Compiler.DependencyManager.DependencyProvider: FSharp.Compiler.DependencyManager.IDependencyManagerProvider TryFindDependencyManagerByKey(System.Collections.Generic.IEnumerable`1[System.String], System.String, FSharp.Compiler.DependencyManager.ResolvingErrorReport, System.String)
 FSharp.Compiler.DependencyManager.DependencyProvider: FSharp.Compiler.DependencyManager.IResolveDependenciesResult Resolve(FSharp.Compiler.DependencyManager.IDependencyManagerProvider, System.String, System.Collections.Generic.IEnumerable`1[System.Tuple`2[System.String,System.String]], FSharp.Compiler.DependencyManager.ResolvingErrorReport, System.String, System.String, System.String, System.String, System.String, Int32)
 FSharp.Compiler.DependencyManager.DependencyProvider: System.String[] GetRegisteredDependencyManagerHelpText(System.Collections.Generic.IEnumerable`1[System.String], System.String, FSharp.Compiler.DependencyManager.ResolvingErrorReport)
@@ -2267,7 +2271,6 @@ FSharp.Compiler.DependencyManager.DependencyProvider: Void .ctor(FSharp.Compiler
 FSharp.Compiler.DependencyManager.DependencyProvider: Void .ctor(FSharp.Compiler.DependencyManager.NativeResolutionProbe)
 FSharp.Compiler.DependencyManager.DependencyProvider: Void .ctor(FSharp.Compiler.DependencyManager.NativeResolutionProbe, Boolean)
 FSharp.Compiler.DependencyManager.DependencyProvider: Void ClearResultsCache(System.Collections.Generic.IEnumerable`1[System.String], System.String, FSharp.Compiler.DependencyManager.ResolvingErrorReport)
-FSharp.Compiler.DependencyManager.ErrorReportType
 FSharp.Compiler.DependencyManager.ErrorReportType+Tags: Int32 Error
 FSharp.Compiler.DependencyManager.ErrorReportType+Tags: Int32 Warning
 FSharp.Compiler.DependencyManager.ErrorReportType: Boolean Equals(FSharp.Compiler.DependencyManager.ErrorReportType)
@@ -2290,7 +2293,6 @@ FSharp.Compiler.DependencyManager.ErrorReportType: Int32 GetHashCode(System.Coll
 FSharp.Compiler.DependencyManager.ErrorReportType: Int32 Tag
 FSharp.Compiler.DependencyManager.ErrorReportType: Int32 get_Tag()
 FSharp.Compiler.DependencyManager.ErrorReportType: System.String ToString()
-FSharp.Compiler.DependencyManager.IDependencyManagerProvider
 FSharp.Compiler.DependencyManager.IDependencyManagerProvider: FSharp.Compiler.DependencyManager.IResolveDependenciesResult ResolveDependencies(System.String, System.String, System.String, System.String, System.Collections.Generic.IEnumerable`1[System.Tuple`2[System.String,System.String]], System.String, System.String, Int32)
 FSharp.Compiler.DependencyManager.IDependencyManagerProvider: System.String Key
 FSharp.Compiler.DependencyManager.IDependencyManagerProvider: System.String Name
@@ -2299,7 +2301,6 @@ FSharp.Compiler.DependencyManager.IDependencyManagerProvider: System.String get_
 FSharp.Compiler.DependencyManager.IDependencyManagerProvider: System.String[] HelpMessages
 FSharp.Compiler.DependencyManager.IDependencyManagerProvider: System.String[] get_HelpMessages()
 FSharp.Compiler.DependencyManager.IDependencyManagerProvider: Void ClearResultsCache()
-FSharp.Compiler.DependencyManager.IResolveDependenciesResult
 FSharp.Compiler.DependencyManager.IResolveDependenciesResult: Boolean Success
 FSharp.Compiler.DependencyManager.IResolveDependenciesResult: Boolean get_Success()
 FSharp.Compiler.DependencyManager.IResolveDependenciesResult: System.Collections.Generic.IEnumerable`1[System.String] Resolutions
@@ -2312,22 +2313,17 @@ FSharp.Compiler.DependencyManager.IResolveDependenciesResult: System.String[] St
 FSharp.Compiler.DependencyManager.IResolveDependenciesResult: System.String[] StdOut
 FSharp.Compiler.DependencyManager.IResolveDependenciesResult: System.String[] get_StdError()
 FSharp.Compiler.DependencyManager.IResolveDependenciesResult: System.String[] get_StdOut()
-FSharp.Compiler.DependencyManager.NativeDllResolveHandler
 FSharp.Compiler.DependencyManager.NativeDllResolveHandler: Void .ctor(FSharp.Compiler.DependencyManager.NativeResolutionProbe)
-FSharp.Compiler.DependencyManager.NativeResolutionProbe
 FSharp.Compiler.DependencyManager.NativeResolutionProbe: System.Collections.Generic.IEnumerable`1[System.String] EndInvoke(System.IAsyncResult)
 FSharp.Compiler.DependencyManager.NativeResolutionProbe: System.Collections.Generic.IEnumerable`1[System.String] Invoke()
 FSharp.Compiler.DependencyManager.NativeResolutionProbe: System.IAsyncResult BeginInvoke(System.AsyncCallback, System.Object)
 FSharp.Compiler.DependencyManager.NativeResolutionProbe: Void .ctor(System.Object, IntPtr)
-FSharp.Compiler.DependencyManager.ResolvingErrorReport
 FSharp.Compiler.DependencyManager.ResolvingErrorReport: System.IAsyncResult BeginInvoke(FSharp.Compiler.DependencyManager.ErrorReportType, Int32, System.String, System.AsyncCallback, System.Object)
 FSharp.Compiler.DependencyManager.ResolvingErrorReport: Void .ctor(System.Object, IntPtr)
 FSharp.Compiler.DependencyManager.ResolvingErrorReport: Void EndInvoke(System.IAsyncResult)
 FSharp.Compiler.DependencyManager.ResolvingErrorReport: Void Invoke(FSharp.Compiler.DependencyManager.ErrorReportType, Int32, System.String)
-FSharp.Compiler.Diagnostics.CompilerDiagnostics
 FSharp.Compiler.Diagnostics.CompilerDiagnostics: System.Collections.Generic.IEnumerable`1[System.String] GetSuggestedNames(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.Unit],Microsoft.FSharp.Core.Unit], System.String)
 FSharp.Compiler.Diagnostics.CompilerDiagnostics: System.String GetErrorMessage(FSharp.Compiler.Diagnostics.FSharpDiagnosticKind)
-FSharp.Compiler.Diagnostics.FSharpDiagnostic
 FSharp.Compiler.Diagnostics.FSharpDiagnostic: FSharp.Compiler.Diagnostics.FSharpDiagnostic Create(FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity, System.String, Int32, FSharp.Compiler.Text.Range, Microsoft.FSharp.Core.FSharpOption`1[System.String], Microsoft.FSharp.Core.FSharpOption`1[System.String])
 FSharp.Compiler.Diagnostics.FSharpDiagnostic: FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity Severity
 FSharp.Compiler.Diagnostics.FSharpDiagnostic: FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity get_Severity()
@@ -2360,7 +2356,6 @@ FSharp.Compiler.Diagnostics.FSharpDiagnostic: System.String get_ErrorNumberText(
 FSharp.Compiler.Diagnostics.FSharpDiagnostic: System.String get_FileName()
 FSharp.Compiler.Diagnostics.FSharpDiagnostic: System.String get_Message()
 FSharp.Compiler.Diagnostics.FSharpDiagnostic: System.String get_Subcategory()
-FSharp.Compiler.Diagnostics.FSharpDiagnosticKind
 FSharp.Compiler.Diagnostics.FSharpDiagnosticKind+ReplaceWithSuggestion: System.String get_suggestion()
 FSharp.Compiler.Diagnostics.FSharpDiagnosticKind+ReplaceWithSuggestion: System.String suggestion
 FSharp.Compiler.Diagnostics.FSharpDiagnosticKind+Tags: Int32 AddIndexerDot
@@ -2385,7 +2380,6 @@ FSharp.Compiler.Diagnostics.FSharpDiagnosticKind: Int32 GetHashCode(System.Colle
 FSharp.Compiler.Diagnostics.FSharpDiagnosticKind: Int32 Tag
 FSharp.Compiler.Diagnostics.FSharpDiagnosticKind: Int32 get_Tag()
 FSharp.Compiler.Diagnostics.FSharpDiagnosticKind: System.String ToString()
-FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions
 FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Boolean CheckXmlDocs
 FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Boolean Equals(FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions)
 FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Boolean Equals(System.Object)
@@ -2412,7 +2406,6 @@ FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Microsoft.FSharp.Collection
 FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Microsoft.FSharp.Collections.FSharpList`1[System.Int32] get_WarnOn()
 FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: System.String ToString()
 FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Void .ctor(Int32, Boolean, Microsoft.FSharp.Collections.FSharpList`1[System.Int32], Microsoft.FSharp.Collections.FSharpList`1[System.Int32], Microsoft.FSharp.Collections.FSharpList`1[System.Int32], Microsoft.FSharp.Collections.FSharpList`1[System.Int32])
-FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity
 FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity+Tags: Int32 Error
 FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity+Tags: Int32 Hidden
 FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity+Tags: Int32 Info
@@ -2445,10 +2438,8 @@ FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: Int32 GetHashCode(System.C
 FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: Int32 Tag
 FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: Int32 get_Tag()
 FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: System.String ToString()
-FSharp.Compiler.EditorServices.AssemblyContent
 FSharp.Compiler.EditorServices.AssemblyContent: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.AssemblySymbol] GetAssemblyContent(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.EditorServices.IAssemblyContentCache,Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.AssemblySymbol]],Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.AssemblySymbol]], FSharp.Compiler.EditorServices.AssemblyContentType, Microsoft.FSharp.Core.FSharpOption`1[System.String], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpAssembly])
 FSharp.Compiler.EditorServices.AssemblyContent: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.AssemblySymbol] GetAssemblySignatureContent(FSharp.Compiler.EditorServices.AssemblyContentType, FSharp.Compiler.Symbols.FSharpAssemblySignature)
-FSharp.Compiler.EditorServices.AssemblyContentType
 FSharp.Compiler.EditorServices.AssemblyContentType+Tags: Int32 Full
 FSharp.Compiler.EditorServices.AssemblyContentType+Tags: Int32 Public
 FSharp.Compiler.EditorServices.AssemblyContentType: Boolean Equals(FSharp.Compiler.EditorServices.AssemblyContentType)
@@ -2471,7 +2462,6 @@ FSharp.Compiler.EditorServices.AssemblyContentType: Int32 GetHashCode(System.Col
 FSharp.Compiler.EditorServices.AssemblyContentType: Int32 Tag
 FSharp.Compiler.EditorServices.AssemblyContentType: Int32 get_Tag()
 FSharp.Compiler.EditorServices.AssemblyContentType: System.String ToString()
-FSharp.Compiler.EditorServices.AssemblySymbol
 FSharp.Compiler.EditorServices.AssemblySymbol: FSharp.Compiler.EditorServices.UnresolvedSymbol UnresolvedSymbol
 FSharp.Compiler.EditorServices.AssemblySymbol: FSharp.Compiler.EditorServices.UnresolvedSymbol get_UnresolvedSymbol()
 FSharp.Compiler.EditorServices.AssemblySymbol: FSharp.Compiler.Symbols.FSharpSymbol Symbol
@@ -2492,7 +2482,6 @@ FSharp.Compiler.EditorServices.AssemblySymbol: System.String get_FullName()
 FSharp.Compiler.EditorServices.AssemblySymbol: System.String[] CleanedIdents
 FSharp.Compiler.EditorServices.AssemblySymbol: System.String[] get_CleanedIdents()
 FSharp.Compiler.EditorServices.AssemblySymbol: Void .ctor(System.String, System.String[], Microsoft.FSharp.Core.FSharpOption`1[System.String[]], Microsoft.FSharp.Core.FSharpOption`1[System.String[]], Microsoft.FSharp.Core.FSharpOption`1[System.String[]], Microsoft.FSharp.Core.FSharpOption`1[System.String[]], FSharp.Compiler.Symbols.FSharpSymbol, Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.EditorServices.LookupType,FSharp.Compiler.EditorServices.EntityKind], FSharp.Compiler.EditorServices.UnresolvedSymbol)
-FSharp.Compiler.EditorServices.CompletionContext
 FSharp.Compiler.EditorServices.CompletionContext+Inherit: FSharp.Compiler.EditorServices.InheritanceContext context
 FSharp.Compiler.EditorServices.CompletionContext+Inherit: FSharp.Compiler.EditorServices.InheritanceContext get_context()
 FSharp.Compiler.EditorServices.CompletionContext+Inherit: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[System.String],Microsoft.FSharp.Core.FSharpOption`1[System.String]] get_path()
@@ -2564,7 +2553,6 @@ FSharp.Compiler.EditorServices.CompletionContext: Int32 GetHashCode(System.Colle
 FSharp.Compiler.EditorServices.CompletionContext: Int32 Tag
 FSharp.Compiler.EditorServices.CompletionContext: Int32 get_Tag()
 FSharp.Compiler.EditorServices.CompletionContext: System.String ToString()
-FSharp.Compiler.EditorServices.CompletionItemKind
 FSharp.Compiler.EditorServices.CompletionItemKind+Method: Boolean get_isExtension()
 FSharp.Compiler.EditorServices.CompletionItemKind+Method: Boolean isExtension
 FSharp.Compiler.EditorServices.CompletionItemKind+Tags: Int32 Argument
@@ -2614,7 +2602,6 @@ FSharp.Compiler.EditorServices.CompletionItemKind: Int32 GetHashCode(System.Coll
 FSharp.Compiler.EditorServices.CompletionItemKind: Int32 Tag
 FSharp.Compiler.EditorServices.CompletionItemKind: Int32 get_Tag()
 FSharp.Compiler.EditorServices.CompletionItemKind: System.String ToString()
-FSharp.Compiler.EditorServices.DeclarationListInfo
 FSharp.Compiler.EditorServices.DeclarationListInfo: Boolean IsError
 FSharp.Compiler.EditorServices.DeclarationListInfo: Boolean IsForType
 FSharp.Compiler.EditorServices.DeclarationListInfo: Boolean get_IsError()
@@ -2623,7 +2610,6 @@ FSharp.Compiler.EditorServices.DeclarationListInfo: FSharp.Compiler.EditorServic
 FSharp.Compiler.EditorServices.DeclarationListInfo: FSharp.Compiler.EditorServices.DeclarationListInfo get_Empty()
 FSharp.Compiler.EditorServices.DeclarationListInfo: FSharp.Compiler.EditorServices.DeclarationListItem[] Items
 FSharp.Compiler.EditorServices.DeclarationListInfo: FSharp.Compiler.EditorServices.DeclarationListItem[] get_Items()
-FSharp.Compiler.EditorServices.DeclarationListItem
 FSharp.Compiler.EditorServices.DeclarationListItem: Boolean IsOwnMember
 FSharp.Compiler.EditorServices.DeclarationListItem: Boolean IsResolved
 FSharp.Compiler.EditorServices.DeclarationListItem: Boolean get_IsOwnMember()
@@ -2648,11 +2634,9 @@ FSharp.Compiler.EditorServices.DeclarationListItem: System.String get_FullName()
 FSharp.Compiler.EditorServices.DeclarationListItem: System.String get_Name()
 FSharp.Compiler.EditorServices.DeclarationListItem: System.String get_NameInCode()
 FSharp.Compiler.EditorServices.DeclarationListItem: System.String get_NameInList()
-FSharp.Compiler.EditorServices.EntityCache
 FSharp.Compiler.EditorServices.EntityCache: T Locking[T](Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.EditorServices.IAssemblyContentCache,T])
 FSharp.Compiler.EditorServices.EntityCache: Void .ctor()
 FSharp.Compiler.EditorServices.EntityCache: Void Clear()
-FSharp.Compiler.EditorServices.EntityKind
 FSharp.Compiler.EditorServices.EntityKind+FunctionOrValue: Boolean get_isActivePattern()
 FSharp.Compiler.EditorServices.EntityKind+FunctionOrValue: Boolean isActivePattern
 FSharp.Compiler.EditorServices.EntityKind+Module: FSharp.Compiler.EditorServices.ModuleKind Item
@@ -2689,7 +2673,6 @@ FSharp.Compiler.EditorServices.EntityKind: Int32 GetHashCode(System.Collections.
 FSharp.Compiler.EditorServices.EntityKind: Int32 Tag
 FSharp.Compiler.EditorServices.EntityKind: Int32 get_Tag()
 FSharp.Compiler.EditorServices.EntityKind: System.String ToString()
-FSharp.Compiler.EditorServices.FSharpGlyph
 FSharp.Compiler.EditorServices.FSharpGlyph+Tags: Int32 Class
 FSharp.Compiler.EditorServices.FSharpGlyph+Tags: Int32 Constant
 FSharp.Compiler.EditorServices.FSharpGlyph+Tags: Int32 Delegate
@@ -2812,7 +2795,6 @@ FSharp.Compiler.EditorServices.FSharpGlyph: Int32 GetHashCode(System.Collections
 FSharp.Compiler.EditorServices.FSharpGlyph: Int32 Tag
 FSharp.Compiler.EditorServices.FSharpGlyph: Int32 get_Tag()
 FSharp.Compiler.EditorServices.FSharpGlyph: System.String ToString()
-FSharp.Compiler.EditorServices.FindDeclExternalParam
 FSharp.Compiler.EditorServices.FindDeclExternalParam: Boolean Equals(FSharp.Compiler.EditorServices.FindDeclExternalParam)
 FSharp.Compiler.EditorServices.FindDeclExternalParam: Boolean Equals(System.Object)
 FSharp.Compiler.EditorServices.FindDeclExternalParam: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
@@ -2827,7 +2809,6 @@ FSharp.Compiler.EditorServices.FindDeclExternalParam: Int32 CompareTo(System.Obj
 FSharp.Compiler.EditorServices.FindDeclExternalParam: Int32 GetHashCode()
 FSharp.Compiler.EditorServices.FindDeclExternalParam: Int32 GetHashCode(System.Collections.IEqualityComparer)
 FSharp.Compiler.EditorServices.FindDeclExternalParam: System.String ToString()
-FSharp.Compiler.EditorServices.FindDeclExternalSymbol
 FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Constructor: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.FindDeclExternalParam] args
 FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Constructor: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.FindDeclExternalParam] get_args()
 FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Constructor: System.String get_typeName()
@@ -2896,7 +2877,6 @@ FSharp.Compiler.EditorServices.FindDeclExternalSymbol: Int32 GetHashCode(System.
 FSharp.Compiler.EditorServices.FindDeclExternalSymbol: Int32 Tag
 FSharp.Compiler.EditorServices.FindDeclExternalSymbol: Int32 get_Tag()
 FSharp.Compiler.EditorServices.FindDeclExternalSymbol: System.String ToString()
-FSharp.Compiler.EditorServices.FindDeclExternalType
 FSharp.Compiler.EditorServices.FindDeclExternalType+Array: FSharp.Compiler.EditorServices.FindDeclExternalType get_inner()
 FSharp.Compiler.EditorServices.FindDeclExternalType+Array: FSharp.Compiler.EditorServices.FindDeclExternalType inner
 FSharp.Compiler.EditorServices.FindDeclExternalType+Pointer: FSharp.Compiler.EditorServices.FindDeclExternalType get_inner()
@@ -2939,7 +2919,6 @@ FSharp.Compiler.EditorServices.FindDeclExternalType: Int32 GetHashCode(System.Co
 FSharp.Compiler.EditorServices.FindDeclExternalType: Int32 Tag
 FSharp.Compiler.EditorServices.FindDeclExternalType: Int32 get_Tag()
 FSharp.Compiler.EditorServices.FindDeclExternalType: System.String ToString()
-FSharp.Compiler.EditorServices.FindDeclFailureReason
 FSharp.Compiler.EditorServices.FindDeclFailureReason+ProvidedMember: System.String get_memberName()
 FSharp.Compiler.EditorServices.FindDeclFailureReason+ProvidedMember: System.String memberName
 FSharp.Compiler.EditorServices.FindDeclFailureReason+ProvidedType: System.String get_typeName()
@@ -2978,7 +2957,6 @@ FSharp.Compiler.EditorServices.FindDeclFailureReason: Int32 GetHashCode(System.C
 FSharp.Compiler.EditorServices.FindDeclFailureReason: Int32 Tag
 FSharp.Compiler.EditorServices.FindDeclFailureReason: Int32 get_Tag()
 FSharp.Compiler.EditorServices.FindDeclFailureReason: System.String ToString()
-FSharp.Compiler.EditorServices.FindDeclResult
 FSharp.Compiler.EditorServices.FindDeclResult+DeclFound: FSharp.Compiler.Text.Range get_location()
 FSharp.Compiler.EditorServices.FindDeclResult+DeclFound: FSharp.Compiler.Text.Range location
 FSharp.Compiler.EditorServices.FindDeclResult+DeclNotFound: FSharp.Compiler.EditorServices.FindDeclFailureReason Item
@@ -3011,10 +2989,8 @@ FSharp.Compiler.EditorServices.FindDeclResult: Int32 GetHashCode(System.Collecti
 FSharp.Compiler.EditorServices.FindDeclResult: Int32 Tag
 FSharp.Compiler.EditorServices.FindDeclResult: Int32 get_Tag()
 FSharp.Compiler.EditorServices.FindDeclResult: System.String ToString()
-FSharp.Compiler.EditorServices.IAssemblyContentCache
 FSharp.Compiler.EditorServices.IAssemblyContentCache: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.EditorServices.AssemblyContentCacheEntry] TryGet(System.String)
 FSharp.Compiler.EditorServices.IAssemblyContentCache: Void Set(System.String, FSharp.Compiler.EditorServices.AssemblyContentCacheEntry)
-FSharp.Compiler.EditorServices.InheritanceContext
 FSharp.Compiler.EditorServices.InheritanceContext+Tags: Int32 Class
 FSharp.Compiler.EditorServices.InheritanceContext+Tags: Int32 Interface
 FSharp.Compiler.EditorServices.InheritanceContext+Tags: Int32 Unknown
@@ -3042,7 +3018,6 @@ FSharp.Compiler.EditorServices.InheritanceContext: Int32 GetHashCode(System.Coll
 FSharp.Compiler.EditorServices.InheritanceContext: Int32 Tag
 FSharp.Compiler.EditorServices.InheritanceContext: Int32 get_Tag()
 FSharp.Compiler.EditorServices.InheritanceContext: System.String ToString()
-FSharp.Compiler.EditorServices.InsertionContext
 FSharp.Compiler.EditorServices.InsertionContext: Boolean Equals(FSharp.Compiler.EditorServices.InsertionContext)
 FSharp.Compiler.EditorServices.InsertionContext: Boolean Equals(System.Object)
 FSharp.Compiler.EditorServices.InsertionContext: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
@@ -3054,7 +3029,6 @@ FSharp.Compiler.EditorServices.InsertionContext: Int32 GetHashCode()
 FSharp.Compiler.EditorServices.InsertionContext: Int32 GetHashCode(System.Collections.IEqualityComparer)
 FSharp.Compiler.EditorServices.InsertionContext: System.String ToString()
 FSharp.Compiler.EditorServices.InsertionContext: Void .ctor(FSharp.Compiler.EditorServices.ScopeKind, FSharp.Compiler.Text.Position)
-FSharp.Compiler.EditorServices.InsertionContextEntity
 FSharp.Compiler.EditorServices.InsertionContextEntity: Boolean Equals(FSharp.Compiler.EditorServices.InsertionContextEntity)
 FSharp.Compiler.EditorServices.InsertionContextEntity: Boolean Equals(System.Object)
 FSharp.Compiler.EditorServices.InsertionContextEntity: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
@@ -3075,7 +3049,6 @@ FSharp.Compiler.EditorServices.InsertionContextEntity: System.String get_FullRel
 FSharp.Compiler.EditorServices.InsertionContextEntity: System.String get_LastIdent()
 FSharp.Compiler.EditorServices.InsertionContextEntity: System.String get_Qualifier()
 FSharp.Compiler.EditorServices.InsertionContextEntity: Void .ctor(System.String, System.String, Microsoft.FSharp.Core.FSharpOption`1[System.String], System.String, System.String)
-FSharp.Compiler.EditorServices.InterfaceData
 FSharp.Compiler.EditorServices.InterfaceData+Interface: FSharp.Compiler.Syntax.SynType get_interfaceType()
 FSharp.Compiler.EditorServices.InterfaceData+Interface: FSharp.Compiler.Syntax.SynType interfaceType
 FSharp.Compiler.EditorServices.InterfaceData+Interface: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn]] get_memberDefns()
@@ -3102,7 +3075,6 @@ FSharp.Compiler.EditorServices.InterfaceData: Int32 get_Tag()
 FSharp.Compiler.EditorServices.InterfaceData: System.String ToString()
 FSharp.Compiler.EditorServices.InterfaceData: System.String[] TypeParameters
 FSharp.Compiler.EditorServices.InterfaceData: System.String[] get_TypeParameters()
-FSharp.Compiler.EditorServices.InterfaceStubGenerator
 FSharp.Compiler.EditorServices.InterfaceStubGenerator: Boolean HasNoInterfaceMember(FSharp.Compiler.Symbols.FSharpEntity)
 FSharp.Compiler.EditorServices.InterfaceStubGenerator: Boolean IsInterface(FSharp.Compiler.Symbols.FSharpEntity)
 FSharp.Compiler.EditorServices.InterfaceStubGenerator: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[System.String,FSharp.Compiler.Text.Range]] GetMemberNameAndRanges(FSharp.Compiler.EditorServices.InterfaceData)
@@ -3110,7 +3082,6 @@ FSharp.Compiler.EditorServices.InterfaceStubGenerator: Microsoft.FSharp.Control.
 FSharp.Compiler.EditorServices.InterfaceStubGenerator: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.EditorServices.InterfaceData] TryFindInterfaceDeclaration(FSharp.Compiler.Text.Position, FSharp.Compiler.Syntax.ParsedInput)
 FSharp.Compiler.EditorServices.InterfaceStubGenerator: System.Collections.Generic.IEnumerable`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue,System.Collections.Generic.IEnumerable`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpGenericParameter,FSharp.Compiler.Symbols.FSharpType]]]] GetInterfaceMembers(FSharp.Compiler.Symbols.FSharpEntity)
 FSharp.Compiler.EditorServices.InterfaceStubGenerator: System.String FormatInterface(Int32, Int32, System.String[], System.String, System.String, FSharp.Compiler.Symbols.FSharpDisplayContext, Microsoft.FSharp.Collections.FSharpSet`1[System.String], FSharp.Compiler.Symbols.FSharpEntity, Boolean)
-FSharp.Compiler.EditorServices.LookupType
 FSharp.Compiler.EditorServices.LookupType+Tags: Int32 Fuzzy
 FSharp.Compiler.EditorServices.LookupType+Tags: Int32 Precise
 FSharp.Compiler.EditorServices.LookupType: Boolean Equals(FSharp.Compiler.EditorServices.LookupType)
@@ -3133,7 +3104,6 @@ FSharp.Compiler.EditorServices.LookupType: Int32 GetHashCode(System.Collections.
 FSharp.Compiler.EditorServices.LookupType: Int32 Tag
 FSharp.Compiler.EditorServices.LookupType: Int32 get_Tag()
 FSharp.Compiler.EditorServices.LookupType: System.String ToString()
-FSharp.Compiler.EditorServices.MaybeUnresolvedIdent
 FSharp.Compiler.EditorServices.MaybeUnresolvedIdent: Boolean Equals(FSharp.Compiler.EditorServices.MaybeUnresolvedIdent)
 FSharp.Compiler.EditorServices.MaybeUnresolvedIdent: Boolean Equals(System.Object)
 FSharp.Compiler.EditorServices.MaybeUnresolvedIdent: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
@@ -3148,12 +3118,10 @@ FSharp.Compiler.EditorServices.MaybeUnresolvedIdent: System.String Ident
 FSharp.Compiler.EditorServices.MaybeUnresolvedIdent: System.String ToString()
 FSharp.Compiler.EditorServices.MaybeUnresolvedIdent: System.String get_Ident()
 FSharp.Compiler.EditorServices.MaybeUnresolvedIdent: Void .ctor(System.String, Boolean)
-FSharp.Compiler.EditorServices.MethodGroup
 FSharp.Compiler.EditorServices.MethodGroup: FSharp.Compiler.EditorServices.MethodGroupItem[] Methods
 FSharp.Compiler.EditorServices.MethodGroup: FSharp.Compiler.EditorServices.MethodGroupItem[] get_Methods()
 FSharp.Compiler.EditorServices.MethodGroup: System.String MethodName
 FSharp.Compiler.EditorServices.MethodGroup: System.String get_MethodName()
-FSharp.Compiler.EditorServices.MethodGroupItem
 FSharp.Compiler.EditorServices.MethodGroupItem: Boolean HasParamArrayArg
 FSharp.Compiler.EditorServices.MethodGroupItem: Boolean HasParameters
 FSharp.Compiler.EditorServices.MethodGroupItem: Boolean get_HasParamArrayArg()
@@ -3168,7 +3136,6 @@ FSharp.Compiler.EditorServices.MethodGroupItem: FSharp.Compiler.Symbols.FSharpXm
 FSharp.Compiler.EditorServices.MethodGroupItem: FSharp.Compiler.Symbols.FSharpXmlDoc get_XmlDoc()
 FSharp.Compiler.EditorServices.MethodGroupItem: FSharp.Compiler.Text.TaggedText[] ReturnTypeText
 FSharp.Compiler.EditorServices.MethodGroupItem: FSharp.Compiler.Text.TaggedText[] get_ReturnTypeText()
-FSharp.Compiler.EditorServices.MethodGroupItemParameter
 FSharp.Compiler.EditorServices.MethodGroupItemParameter: Boolean IsOptional
 FSharp.Compiler.EditorServices.MethodGroupItemParameter: Boolean get_IsOptional()
 FSharp.Compiler.EditorServices.MethodGroupItemParameter: FSharp.Compiler.Text.TaggedText[] Display
@@ -3177,7 +3144,6 @@ FSharp.Compiler.EditorServices.MethodGroupItemParameter: System.String Canonical
 FSharp.Compiler.EditorServices.MethodGroupItemParameter: System.String ParameterName
 FSharp.Compiler.EditorServices.MethodGroupItemParameter: System.String get_CanonicalTypeTextForSorting()
 FSharp.Compiler.EditorServices.MethodGroupItemParameter: System.String get_ParameterName()
-FSharp.Compiler.EditorServices.ModuleKind
 FSharp.Compiler.EditorServices.ModuleKind: Boolean Equals(FSharp.Compiler.EditorServices.ModuleKind)
 FSharp.Compiler.EditorServices.ModuleKind: Boolean Equals(System.Object)
 FSharp.Compiler.EditorServices.ModuleKind: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
@@ -3192,7 +3158,6 @@ FSharp.Compiler.EditorServices.ModuleKind: Int32 GetHashCode()
 FSharp.Compiler.EditorServices.ModuleKind: Int32 GetHashCode(System.Collections.IEqualityComparer)
 FSharp.Compiler.EditorServices.ModuleKind: System.String ToString()
 FSharp.Compiler.EditorServices.ModuleKind: Void .ctor(Boolean, Boolean)
-FSharp.Compiler.EditorServices.NavigableContainer
 FSharp.Compiler.EditorServices.NavigableContainer: Boolean Equals(FSharp.Compiler.EditorServices.NavigableContainer)
 FSharp.Compiler.EditorServices.NavigableContainer: Boolean Equals(System.Object)
 FSharp.Compiler.EditorServices.NavigableContainer: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
@@ -3207,7 +3172,6 @@ FSharp.Compiler.EditorServices.NavigableContainer: System.String LogicalName
 FSharp.Compiler.EditorServices.NavigableContainer: System.String ToString()
 FSharp.Compiler.EditorServices.NavigableContainer: System.String get_LogicalName()
 FSharp.Compiler.EditorServices.NavigableContainer: Void .ctor(FSharp.Compiler.EditorServices.NavigableContainerType, System.String)
-FSharp.Compiler.EditorServices.NavigableContainerType
 FSharp.Compiler.EditorServices.NavigableContainerType+Tags: Int32 Exception
 FSharp.Compiler.EditorServices.NavigableContainerType+Tags: Int32 File
 FSharp.Compiler.EditorServices.NavigableContainerType+Tags: Int32 Module
@@ -3245,7 +3209,6 @@ FSharp.Compiler.EditorServices.NavigableContainerType: Int32 GetHashCode(System.
 FSharp.Compiler.EditorServices.NavigableContainerType: Int32 Tag
 FSharp.Compiler.EditorServices.NavigableContainerType: Int32 get_Tag()
 FSharp.Compiler.EditorServices.NavigableContainerType: System.String ToString()
-FSharp.Compiler.EditorServices.NavigableItem
 FSharp.Compiler.EditorServices.NavigableItem: Boolean Equals(FSharp.Compiler.EditorServices.NavigableItem)
 FSharp.Compiler.EditorServices.NavigableItem: Boolean Equals(System.Object)
 FSharp.Compiler.EditorServices.NavigableItem: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
@@ -3263,7 +3226,6 @@ FSharp.Compiler.EditorServices.NavigableItem: System.String LogicalName
 FSharp.Compiler.EditorServices.NavigableItem: System.String ToString()
 FSharp.Compiler.EditorServices.NavigableItem: System.String get_LogicalName()
 FSharp.Compiler.EditorServices.NavigableItem: Void .ctor(System.String, FSharp.Compiler.Text.Range, Boolean, FSharp.Compiler.EditorServices.NavigableItemKind, FSharp.Compiler.EditorServices.NavigableContainer)
-FSharp.Compiler.EditorServices.NavigableItemKind
 FSharp.Compiler.EditorServices.NavigableItemKind+Tags: Int32 Constructor
 FSharp.Compiler.EditorServices.NavigableItemKind+Tags: Int32 EnumCase
 FSharp.Compiler.EditorServices.NavigableItemKind+Tags: Int32 Exception
@@ -3331,11 +3293,8 @@ FSharp.Compiler.EditorServices.NavigableItemKind: Int32 GetHashCode(System.Colle
 FSharp.Compiler.EditorServices.NavigableItemKind: Int32 Tag
 FSharp.Compiler.EditorServices.NavigableItemKind: Int32 get_Tag()
 FSharp.Compiler.EditorServices.NavigableItemKind: System.String ToString()
-FSharp.Compiler.EditorServices.NavigateTo
 FSharp.Compiler.EditorServices.NavigateTo: FSharp.Compiler.EditorServices.NavigableItem[] GetNavigableItems(FSharp.Compiler.Syntax.ParsedInput)
-FSharp.Compiler.EditorServices.Navigation
 FSharp.Compiler.EditorServices.Navigation: FSharp.Compiler.EditorServices.NavigationItems getNavigation(FSharp.Compiler.Syntax.ParsedInput)
-FSharp.Compiler.EditorServices.NavigationEntityKind
 FSharp.Compiler.EditorServices.NavigationEntityKind+Tags: Int32 Class
 FSharp.Compiler.EditorServices.NavigationEntityKind+Tags: Int32 Enum
 FSharp.Compiler.EditorServices.NavigationEntityKind+Tags: Int32 Exception
@@ -3388,7 +3347,6 @@ FSharp.Compiler.EditorServices.NavigationEntityKind: Int32 GetHashCode(System.Co
 FSharp.Compiler.EditorServices.NavigationEntityKind: Int32 Tag
 FSharp.Compiler.EditorServices.NavigationEntityKind: Int32 get_Tag()
 FSharp.Compiler.EditorServices.NavigationEntityKind: System.String ToString()
-FSharp.Compiler.EditorServices.NavigationItem
 FSharp.Compiler.EditorServices.NavigationItem: Boolean IsAbstract
 FSharp.Compiler.EditorServices.NavigationItem: Boolean IsSingleTopLevel
 FSharp.Compiler.EditorServices.NavigationItem: Boolean get_IsAbstract()
@@ -3409,7 +3367,6 @@ FSharp.Compiler.EditorServices.NavigationItem: System.String LogicalName
 FSharp.Compiler.EditorServices.NavigationItem: System.String UniqueName
 FSharp.Compiler.EditorServices.NavigationItem: System.String get_LogicalName()
 FSharp.Compiler.EditorServices.NavigationItem: System.String get_UniqueName()
-FSharp.Compiler.EditorServices.NavigationItemKind
 FSharp.Compiler.EditorServices.NavigationItemKind+Tags: Int32 Exception
 FSharp.Compiler.EditorServices.NavigationItemKind+Tags: Int32 Field
 FSharp.Compiler.EditorServices.NavigationItemKind+Tags: Int32 Method
@@ -3467,17 +3424,14 @@ FSharp.Compiler.EditorServices.NavigationItemKind: Int32 GetHashCode(System.Coll
 FSharp.Compiler.EditorServices.NavigationItemKind: Int32 Tag
 FSharp.Compiler.EditorServices.NavigationItemKind: Int32 get_Tag()
 FSharp.Compiler.EditorServices.NavigationItemKind: System.String ToString()
-FSharp.Compiler.EditorServices.NavigationItems
 FSharp.Compiler.EditorServices.NavigationItems: FSharp.Compiler.EditorServices.NavigationTopLevelDeclaration[] Declarations
 FSharp.Compiler.EditorServices.NavigationItems: FSharp.Compiler.EditorServices.NavigationTopLevelDeclaration[] get_Declarations()
-FSharp.Compiler.EditorServices.NavigationTopLevelDeclaration
 FSharp.Compiler.EditorServices.NavigationTopLevelDeclaration: FSharp.Compiler.EditorServices.NavigationItem Declaration
 FSharp.Compiler.EditorServices.NavigationTopLevelDeclaration: FSharp.Compiler.EditorServices.NavigationItem get_Declaration()
 FSharp.Compiler.EditorServices.NavigationTopLevelDeclaration: FSharp.Compiler.EditorServices.NavigationItem[] Nested
 FSharp.Compiler.EditorServices.NavigationTopLevelDeclaration: FSharp.Compiler.EditorServices.NavigationItem[] get_Nested()
 FSharp.Compiler.EditorServices.NavigationTopLevelDeclaration: System.String ToString()
 FSharp.Compiler.EditorServices.NavigationTopLevelDeclaration: Void .ctor(FSharp.Compiler.EditorServices.NavigationItem, FSharp.Compiler.EditorServices.NavigationItem[])
-FSharp.Compiler.EditorServices.OpenStatementInsertionPoint
 FSharp.Compiler.EditorServices.OpenStatementInsertionPoint+Tags: Int32 Nearest
 FSharp.Compiler.EditorServices.OpenStatementInsertionPoint+Tags: Int32 TopLevel
 FSharp.Compiler.EditorServices.OpenStatementInsertionPoint: Boolean Equals(FSharp.Compiler.EditorServices.OpenStatementInsertionPoint)
@@ -3500,7 +3454,6 @@ FSharp.Compiler.EditorServices.OpenStatementInsertionPoint: Int32 GetHashCode(Sy
 FSharp.Compiler.EditorServices.OpenStatementInsertionPoint: Int32 Tag
 FSharp.Compiler.EditorServices.OpenStatementInsertionPoint: Int32 get_Tag()
 FSharp.Compiler.EditorServices.OpenStatementInsertionPoint: System.String ToString()
-FSharp.Compiler.EditorServices.ParameterLocations
 FSharp.Compiler.EditorServices.ParameterLocations: Boolean IsThereACloseParen
 FSharp.Compiler.EditorServices.ParameterLocations: Boolean get_IsThereACloseParen()
 FSharp.Compiler.EditorServices.ParameterLocations: FSharp.Compiler.EditorServices.TupledArgumentLocation[] ArgumentLocations
@@ -3518,7 +3471,6 @@ FSharp.Compiler.EditorServices.ParameterLocations: Microsoft.FSharp.Collections.
 FSharp.Compiler.EditorServices.ParameterLocations: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.EditorServices.ParameterLocations] Find(FSharp.Compiler.Text.Position, FSharp.Compiler.Syntax.ParsedInput)
 FSharp.Compiler.EditorServices.ParameterLocations: Microsoft.FSharp.Core.FSharpOption`1[System.String][] NamedParamNames
 FSharp.Compiler.EditorServices.ParameterLocations: Microsoft.FSharp.Core.FSharpOption`1[System.String][] get_NamedParamNames()
-FSharp.Compiler.EditorServices.ParsedInput
 FSharp.Compiler.EditorServices.ParsedInput: FSharp.Compiler.EditorServices.InsertionContext FindNearestPointToInsertOpenDeclaration(Int32, FSharp.Compiler.Syntax.ParsedInput, System.String[], FSharp.Compiler.EditorServices.OpenStatementInsertionPoint)
 FSharp.Compiler.EditorServices.ParsedInput: FSharp.Compiler.Text.Position AdjustInsertionPoint(Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.String], FSharp.Compiler.EditorServices.InsertionContext)
 FSharp.Compiler.EditorServices.ParsedInput: Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`4[Microsoft.FSharp.Core.FSharpOption`1[System.String[]],Microsoft.FSharp.Core.FSharpOption`1[System.String[]],Microsoft.FSharp.Core.FSharpOption`1[System.String[]],System.String[]],System.Tuple`2[FSharp.Compiler.EditorServices.InsertionContextEntity,FSharp.Compiler.EditorServices.InsertionContext][]] TryFindInsertionContext(Int32, FSharp.Compiler.Syntax.ParsedInput, FSharp.Compiler.EditorServices.MaybeUnresolvedIdent[], FSharp.Compiler.EditorServices.OpenStatementInsertionPoint)
@@ -3529,7 +3481,6 @@ FSharp.Compiler.EditorServices.ParsedInput: Microsoft.FSharp.Core.FSharpOption`1
 FSharp.Compiler.EditorServices.ParsedInput: Microsoft.FSharp.Core.FSharpOption`1[System.String] TryFindExpressionIslandInPosition(FSharp.Compiler.Text.Position, FSharp.Compiler.Syntax.ParsedInput)
 FSharp.Compiler.EditorServices.ParsedInput: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Text.Position,System.Boolean]] TryFindExpressionASTLeftOfDotLeftOfCursor(FSharp.Compiler.Text.Position, FSharp.Compiler.Syntax.ParsedInput)
 FSharp.Compiler.EditorServices.ParsedInput: System.String[] GetFullNameOfSmallestModuleOrNamespaceAtPoint(FSharp.Compiler.Text.Position, FSharp.Compiler.Syntax.ParsedInput)
-FSharp.Compiler.EditorServices.PartialLongName
 FSharp.Compiler.EditorServices.PartialLongName: Boolean Equals(FSharp.Compiler.EditorServices.PartialLongName)
 FSharp.Compiler.EditorServices.PartialLongName: Boolean Equals(System.Object)
 FSharp.Compiler.EditorServices.PartialLongName: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
@@ -3549,7 +3500,6 @@ FSharp.Compiler.EditorServices.PartialLongName: System.String PartialIdent
 FSharp.Compiler.EditorServices.PartialLongName: System.String ToString()
 FSharp.Compiler.EditorServices.PartialLongName: System.String get_PartialIdent()
 FSharp.Compiler.EditorServices.PartialLongName: Void .ctor(Microsoft.FSharp.Collections.FSharpList`1[System.String], System.String, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-FSharp.Compiler.EditorServices.QuickParse
 FSharp.Compiler.EditorServices.QuickParse: Boolean TestMemberOrOverrideDeclaration(FSharp.Compiler.Tokenization.FSharpTokenInfo[])
 FSharp.Compiler.EditorServices.QuickParse: FSharp.Compiler.EditorServices.PartialLongName GetPartialLongNameEx(System.String, Int32)
 FSharp.Compiler.EditorServices.QuickParse: Int32 CorrectIdentifierToken(System.String, Int32)
@@ -3557,7 +3507,6 @@ FSharp.Compiler.EditorServices.QuickParse: Int32 MagicalAdjustmentConstant
 FSharp.Compiler.EditorServices.QuickParse: Int32 get_MagicalAdjustmentConstant()
 FSharp.Compiler.EditorServices.QuickParse: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.String,System.Int32,System.Boolean]] GetCompleteIdentifierIsland(Boolean, System.String, Int32)
 FSharp.Compiler.EditorServices.QuickParse: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[System.String],System.String] GetPartialLongName(System.String, Int32)
-FSharp.Compiler.EditorServices.RecordContext
 FSharp.Compiler.EditorServices.RecordContext+Constructor: System.String get_typeName()
 FSharp.Compiler.EditorServices.RecordContext+Constructor: System.String typeName
 FSharp.Compiler.EditorServices.RecordContext+CopyOnUpdate: FSharp.Compiler.Text.Range get_range()
@@ -3604,7 +3553,6 @@ FSharp.Compiler.EditorServices.RecordContext: Int32 GetHashCode(System.Collectio
 FSharp.Compiler.EditorServices.RecordContext: Int32 Tag
 FSharp.Compiler.EditorServices.RecordContext: Int32 get_Tag()
 FSharp.Compiler.EditorServices.RecordContext: System.String ToString()
-FSharp.Compiler.EditorServices.ScopeKind
 FSharp.Compiler.EditorServices.ScopeKind+Tags: Int32 HashDirective
 FSharp.Compiler.EditorServices.ScopeKind+Tags: Int32 Namespace
 FSharp.Compiler.EditorServices.ScopeKind+Tags: Int32 NestedModule
@@ -3642,7 +3590,6 @@ FSharp.Compiler.EditorServices.ScopeKind: Int32 GetHashCode(System.Collections.I
 FSharp.Compiler.EditorServices.ScopeKind: Int32 Tag
 FSharp.Compiler.EditorServices.ScopeKind: Int32 get_Tag()
 FSharp.Compiler.EditorServices.ScopeKind: System.String ToString()
-FSharp.Compiler.EditorServices.SemanticClassificationItem
 FSharp.Compiler.EditorServices.SemanticClassificationItem: Boolean Equals(FSharp.Compiler.EditorServices.SemanticClassificationItem)
 FSharp.Compiler.EditorServices.SemanticClassificationItem: Boolean Equals(System.Object)
 FSharp.Compiler.EditorServices.SemanticClassificationItem: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
@@ -3653,7 +3600,6 @@ FSharp.Compiler.EditorServices.SemanticClassificationItem: FSharp.Compiler.Text.
 FSharp.Compiler.EditorServices.SemanticClassificationItem: Int32 GetHashCode()
 FSharp.Compiler.EditorServices.SemanticClassificationItem: Int32 GetHashCode(System.Collections.IEqualityComparer)
 FSharp.Compiler.EditorServices.SemanticClassificationItem: Void .ctor(System.Tuple`2[FSharp.Compiler.Text.Range,FSharp.Compiler.EditorServices.SemanticClassificationType])
-FSharp.Compiler.EditorServices.SemanticClassificationType
 FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType ComputationExpression
 FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType ConstructorForReferenceType
 FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType ConstructorForValueType
@@ -3692,9 +3638,7 @@ FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.Edito
 FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType Value
 FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType ValueType
 FSharp.Compiler.EditorServices.SemanticClassificationType: Int32 value__
-FSharp.Compiler.EditorServices.SemanticClassificationView
 FSharp.Compiler.EditorServices.SemanticClassificationView: Void ForEach(Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.EditorServices.SemanticClassificationItem,Microsoft.FSharp.Core.Unit])
-FSharp.Compiler.EditorServices.SimplifyNames
 FSharp.Compiler.EditorServices.SimplifyNames+SimplifiableRange: Boolean Equals(SimplifiableRange)
 FSharp.Compiler.EditorServices.SimplifyNames+SimplifiableRange: Boolean Equals(System.Object)
 FSharp.Compiler.EditorServices.SimplifyNames+SimplifiableRange: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
@@ -3708,7 +3652,6 @@ FSharp.Compiler.EditorServices.SimplifyNames+SimplifiableRange: System.String ge
 FSharp.Compiler.EditorServices.SimplifyNames+SimplifiableRange: Void .ctor(FSharp.Compiler.Text.Range, System.String)
 FSharp.Compiler.EditorServices.SimplifyNames: FSharp.Compiler.EditorServices.SimplifyNames+SimplifiableRange
 FSharp.Compiler.EditorServices.SimplifyNames: Microsoft.FSharp.Control.FSharpAsync`1[System.Collections.Generic.IEnumerable`1[FSharp.Compiler.EditorServices.SimplifyNames+SimplifiableRange]] getSimplifiableNames(FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.String])
-FSharp.Compiler.EditorServices.Structure
 FSharp.Compiler.EditorServices.Structure+Collapse+Tags: Int32 Below
 FSharp.Compiler.EditorServices.Structure+Collapse+Tags: Int32 Same
 FSharp.Compiler.EditorServices.Structure+Collapse: Boolean Equals(Collapse)
@@ -3992,7 +3935,6 @@ FSharp.Compiler.EditorServices.Structure: FSharp.Compiler.EditorServices.Structu
 FSharp.Compiler.EditorServices.Structure: FSharp.Compiler.EditorServices.Structure+Scope
 FSharp.Compiler.EditorServices.Structure: FSharp.Compiler.EditorServices.Structure+ScopeRange
 FSharp.Compiler.EditorServices.Structure: System.Collections.Generic.IEnumerable`1[FSharp.Compiler.EditorServices.Structure+ScopeRange] getOutliningRanges(System.String[], FSharp.Compiler.Syntax.ParsedInput)
-FSharp.Compiler.EditorServices.ToolTipElement
 FSharp.Compiler.EditorServices.ToolTipElement+CompositionError: System.String errorText
 FSharp.Compiler.EditorServices.ToolTipElement+CompositionError: System.String get_errorText()
 FSharp.Compiler.EditorServices.ToolTipElement+Group: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.ToolTipElementData] elements
@@ -4022,7 +3964,6 @@ FSharp.Compiler.EditorServices.ToolTipElement: Int32 GetHashCode(System.Collecti
 FSharp.Compiler.EditorServices.ToolTipElement: Int32 Tag
 FSharp.Compiler.EditorServices.ToolTipElement: Int32 get_Tag()
 FSharp.Compiler.EditorServices.ToolTipElement: System.String ToString()
-FSharp.Compiler.EditorServices.ToolTipElementData
 FSharp.Compiler.EditorServices.ToolTipElementData: Boolean Equals(FSharp.Compiler.EditorServices.ToolTipElementData)
 FSharp.Compiler.EditorServices.ToolTipElementData: Boolean Equals(System.Object)
 FSharp.Compiler.EditorServices.ToolTipElementData: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
@@ -4040,7 +3981,6 @@ FSharp.Compiler.EditorServices.ToolTipElementData: Microsoft.FSharp.Core.FSharpO
 FSharp.Compiler.EditorServices.ToolTipElementData: Microsoft.FSharp.Core.FSharpOption`1[System.String] get_ParamName()
 FSharp.Compiler.EditorServices.ToolTipElementData: System.String ToString()
 FSharp.Compiler.EditorServices.ToolTipElementData: Void .ctor(FSharp.Compiler.Text.TaggedText[], FSharp.Compiler.Symbols.FSharpXmlDoc, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.TaggedText[]], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.TaggedText[]], Microsoft.FSharp.Core.FSharpOption`1[System.String])
-FSharp.Compiler.EditorServices.ToolTipText
 FSharp.Compiler.EditorServices.ToolTipText: Boolean Equals(FSharp.Compiler.EditorServices.ToolTipText)
 FSharp.Compiler.EditorServices.ToolTipText: Boolean Equals(System.Object)
 FSharp.Compiler.EditorServices.ToolTipText: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
@@ -4052,7 +3992,6 @@ FSharp.Compiler.EditorServices.ToolTipText: Int32 get_Tag()
 FSharp.Compiler.EditorServices.ToolTipText: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.ToolTipElement] Item
 FSharp.Compiler.EditorServices.ToolTipText: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.ToolTipElement] get_Item()
 FSharp.Compiler.EditorServices.ToolTipText: System.String ToString()
-FSharp.Compiler.EditorServices.TupledArgumentLocation
 FSharp.Compiler.EditorServices.TupledArgumentLocation: Boolean Equals(FSharp.Compiler.EditorServices.TupledArgumentLocation)
 FSharp.Compiler.EditorServices.TupledArgumentLocation: Boolean Equals(System.Object)
 FSharp.Compiler.EditorServices.TupledArgumentLocation: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
@@ -4064,7 +4003,6 @@ FSharp.Compiler.EditorServices.TupledArgumentLocation: Int32 GetHashCode()
 FSharp.Compiler.EditorServices.TupledArgumentLocation: Int32 GetHashCode(System.Collections.IEqualityComparer)
 FSharp.Compiler.EditorServices.TupledArgumentLocation: System.String ToString()
 FSharp.Compiler.EditorServices.TupledArgumentLocation: Void .ctor(Boolean, FSharp.Compiler.Text.Range)
-FSharp.Compiler.EditorServices.UnresolvedSymbol
 FSharp.Compiler.EditorServices.UnresolvedSymbol: Boolean Equals(FSharp.Compiler.EditorServices.UnresolvedSymbol)
 FSharp.Compiler.EditorServices.UnresolvedSymbol: Boolean Equals(System.Object)
 FSharp.Compiler.EditorServices.UnresolvedSymbol: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
@@ -4081,15 +4019,10 @@ FSharp.Compiler.EditorServices.UnresolvedSymbol: System.String get_FullName()
 FSharp.Compiler.EditorServices.UnresolvedSymbol: System.String[] Namespace
 FSharp.Compiler.EditorServices.UnresolvedSymbol: System.String[] get_Namespace()
 FSharp.Compiler.EditorServices.UnresolvedSymbol: Void .ctor(System.String, System.String, System.String[])
-FSharp.Compiler.EditorServices.UnusedDeclarations
 FSharp.Compiler.EditorServices.UnusedDeclarations: Microsoft.FSharp.Control.FSharpAsync`1[System.Collections.Generic.IEnumerable`1[FSharp.Compiler.Text.Range]] getUnusedDeclarations(FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults, Boolean)
-FSharp.Compiler.EditorServices.UnusedOpens
 FSharp.Compiler.EditorServices.UnusedOpens: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.Range]] getUnusedOpens(FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.String])
-FSharp.Compiler.EditorServices.XmlDocComment
 FSharp.Compiler.EditorServices.XmlDocComment: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] IsBlank(System.String)
-FSharp.Compiler.EditorServices.XmlDocParser
 FSharp.Compiler.EditorServices.XmlDocParser: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.XmlDocable] GetXmlDocables(FSharp.Compiler.Text.ISourceText, FSharp.Compiler.Syntax.ParsedInput)
-FSharp.Compiler.EditorServices.XmlDocable
 FSharp.Compiler.EditorServices.XmlDocable: Boolean Equals(FSharp.Compiler.EditorServices.XmlDocable)
 FSharp.Compiler.EditorServices.XmlDocable: Boolean Equals(System.Object)
 FSharp.Compiler.EditorServices.XmlDocable: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
@@ -4108,7 +4041,6 @@ FSharp.Compiler.EditorServices.XmlDocable: Int32 line
 FSharp.Compiler.EditorServices.XmlDocable: Microsoft.FSharp.Collections.FSharpList`1[System.String] get_paramNames()
 FSharp.Compiler.EditorServices.XmlDocable: Microsoft.FSharp.Collections.FSharpList`1[System.String] paramNames
 FSharp.Compiler.EditorServices.XmlDocable: System.String ToString()
-FSharp.Compiler.IO.ByteMemory
 FSharp.Compiler.IO.ByteMemory: Byte Item [Int32]
 FSharp.Compiler.IO.ByteMemory: Byte get_Item(Int32)
 FSharp.Compiler.IO.ByteMemory: Byte[] ReadAllBytes()
@@ -4132,9 +4064,7 @@ FSharp.Compiler.IO.ByteMemory: UInt16 ReadUInt16(Int32)
 FSharp.Compiler.IO.ByteMemory: Void Copy(Int32, Byte[], Int32, Int32)
 FSharp.Compiler.IO.ByteMemory: Void CopyTo(System.IO.Stream)
 FSharp.Compiler.IO.ByteMemory: Void set_Item(Int32, Byte)
-FSharp.Compiler.IO.DefaultAssemblyLoader
 FSharp.Compiler.IO.DefaultAssemblyLoader: Void .ctor()
-FSharp.Compiler.IO.DefaultFileSystem
 FSharp.Compiler.IO.DefaultFileSystem: Boolean DirectoryExistsShim(System.String)
 FSharp.Compiler.IO.DefaultFileSystem: Boolean FileExistsShim(System.String)
 FSharp.Compiler.IO.DefaultFileSystem: Boolean IsInvalidPathShim(System.String)
@@ -4158,14 +4088,11 @@ FSharp.Compiler.IO.DefaultFileSystem: Void .ctor()
 FSharp.Compiler.IO.DefaultFileSystem: Void CopyShim(System.String, System.String, Boolean)
 FSharp.Compiler.IO.DefaultFileSystem: Void DirectoryDeleteShim(System.String)
 FSharp.Compiler.IO.DefaultFileSystem: Void FileDeleteShim(System.String)
-FSharp.Compiler.IO.FileSystemAutoOpens
 FSharp.Compiler.IO.FileSystemAutoOpens: FSharp.Compiler.IO.IFileSystem FileSystem
 FSharp.Compiler.IO.FileSystemAutoOpens: FSharp.Compiler.IO.IFileSystem get_FileSystem()
 FSharp.Compiler.IO.FileSystemAutoOpens: Void set_FileSystem(FSharp.Compiler.IO.IFileSystem)
-FSharp.Compiler.IO.IAssemblyLoader
 FSharp.Compiler.IO.IAssemblyLoader: System.Reflection.Assembly AssemblyLoad(System.Reflection.AssemblyName)
 FSharp.Compiler.IO.IAssemblyLoader: System.Reflection.Assembly AssemblyLoadFrom(System.String)
-FSharp.Compiler.IO.IFileSystem
 FSharp.Compiler.IO.IFileSystem: Boolean DirectoryExistsShim(System.String)
 FSharp.Compiler.IO.IFileSystem: Boolean FileExistsShim(System.String)
 FSharp.Compiler.IO.IFileSystem: Boolean IsInvalidPathShim(System.String)
@@ -4188,7 +4115,6 @@ FSharp.Compiler.IO.IFileSystem: System.String NormalizePathShim(System.String)
 FSharp.Compiler.IO.IFileSystem: Void CopyShim(System.String, System.String, Boolean)
 FSharp.Compiler.IO.IFileSystem: Void DirectoryDeleteShim(System.String)
 FSharp.Compiler.IO.IFileSystem: Void FileDeleteShim(System.String)
-FSharp.Compiler.IO.StreamExtensions
 FSharp.Compiler.IO.StreamExtensions: Byte[] Stream.ReadAllBytes(System.IO.Stream)
 FSharp.Compiler.IO.StreamExtensions: Byte[] Stream.ReadBytes(System.IO.Stream, Int32, Int32)
 FSharp.Compiler.IO.StreamExtensions: FSharp.Compiler.IO.ByteMemory Stream.AsByteMemory(System.IO.Stream)
@@ -4200,7 +4126,6 @@ FSharp.Compiler.IO.StreamExtensions: System.String[] Stream.ReadAllLines(System.
 FSharp.Compiler.IO.StreamExtensions: Void Stream.WriteAllLines(System.IO.Stream, System.Collections.Generic.IEnumerable`1[System.String], Microsoft.FSharp.Core.FSharpOption`1[System.Text.Encoding])
 FSharp.Compiler.IO.StreamExtensions: Void Stream.WriteAllText(System.IO.Stream, System.String)
 FSharp.Compiler.IO.StreamExtensions: Void Stream.Write[a](System.IO.Stream, a)
-FSharp.Compiler.Interactive.CtrlBreakHandlers
 FSharp.Compiler.Interactive.CtrlBreakHandlers+CtrlBreakClient: Void .ctor(System.String)
 FSharp.Compiler.Interactive.CtrlBreakHandlers+CtrlBreakClient: Void Interrupt()
 FSharp.Compiler.Interactive.CtrlBreakHandlers+CtrlBreakService: Void .ctor(System.String)
@@ -4208,7 +4133,6 @@ FSharp.Compiler.Interactive.CtrlBreakHandlers+CtrlBreakService: Void Interrupt()
 FSharp.Compiler.Interactive.CtrlBreakHandlers+CtrlBreakService: Void Run()
 FSharp.Compiler.Interactive.CtrlBreakHandlers: FSharp.Compiler.Interactive.CtrlBreakHandlers+CtrlBreakClient
 FSharp.Compiler.Interactive.CtrlBreakHandlers: FSharp.Compiler.Interactive.CtrlBreakHandlers+CtrlBreakService
-FSharp.Compiler.Interactive.Shell
 FSharp.Compiler.Interactive.Shell+CompilerInputStream: Boolean CanRead
 FSharp.Compiler.Interactive.Shell+CompilerInputStream: Boolean CanSeek
 FSharp.Compiler.Interactive.Shell+CompilerInputStream: Boolean CanWrite
@@ -4383,7 +4307,6 @@ FSharp.Compiler.Interactive.Shell: FSharp.Compiler.Interactive.Shell+FsiEvaluati
 FSharp.Compiler.Interactive.Shell: FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig
 FSharp.Compiler.Interactive.Shell: FSharp.Compiler.Interactive.Shell+FsiValue
 FSharp.Compiler.Interactive.Shell: FSharp.Compiler.Interactive.Shell+Settings
-FSharp.Compiler.Symbols.FSharpAbstractParameter
 FSharp.Compiler.Symbols.FSharpAbstractParameter: Boolean IsInArg
 FSharp.Compiler.Symbols.FSharpAbstractParameter: Boolean IsOptionalArg
 FSharp.Compiler.Symbols.FSharpAbstractParameter: Boolean IsOutArg
@@ -4396,7 +4319,6 @@ FSharp.Compiler.Symbols.FSharpAbstractParameter: Microsoft.FSharp.Core.FSharpOpt
 FSharp.Compiler.Symbols.FSharpAbstractParameter: Microsoft.FSharp.Core.FSharpOption`1[System.String] get_Name()
 FSharp.Compiler.Symbols.FSharpAbstractParameter: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAttribute] Attributes
 FSharp.Compiler.Symbols.FSharpAbstractParameter: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAttribute] get_Attributes()
-FSharp.Compiler.Symbols.FSharpAbstractSignature
 FSharp.Compiler.Symbols.FSharpAbstractSignature: FSharp.Compiler.Symbols.FSharpType AbstractReturnType
 FSharp.Compiler.Symbols.FSharpAbstractSignature: FSharp.Compiler.Symbols.FSharpType DeclaringType
 FSharp.Compiler.Symbols.FSharpAbstractSignature: FSharp.Compiler.Symbols.FSharpType get_AbstractReturnType()
@@ -4409,7 +4331,6 @@ FSharp.Compiler.Symbols.FSharpAbstractSignature: System.Collections.Generic.ILis
 FSharp.Compiler.Symbols.FSharpAbstractSignature: System.Collections.Generic.IList`1[System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAbstractParameter]] get_AbstractArguments()
 FSharp.Compiler.Symbols.FSharpAbstractSignature: System.String Name
 FSharp.Compiler.Symbols.FSharpAbstractSignature: System.String get_Name()
-FSharp.Compiler.Symbols.FSharpAccessibility
 FSharp.Compiler.Symbols.FSharpAccessibility: Boolean IsInternal
 FSharp.Compiler.Symbols.FSharpAccessibility: Boolean IsPrivate
 FSharp.Compiler.Symbols.FSharpAccessibility: Boolean IsProtected
@@ -4419,8 +4340,6 @@ FSharp.Compiler.Symbols.FSharpAccessibility: Boolean get_IsPrivate()
 FSharp.Compiler.Symbols.FSharpAccessibility: Boolean get_IsProtected()
 FSharp.Compiler.Symbols.FSharpAccessibility: Boolean get_IsPublic()
 FSharp.Compiler.Symbols.FSharpAccessibility: System.String ToString()
-FSharp.Compiler.Symbols.FSharpAccessibilityRights
-FSharp.Compiler.Symbols.FSharpActivePatternCase
 FSharp.Compiler.Symbols.FSharpActivePatternCase: FSharp.Compiler.Symbols.FSharpActivePatternGroup Group
 FSharp.Compiler.Symbols.FSharpActivePatternCase: FSharp.Compiler.Symbols.FSharpActivePatternGroup get_Group()
 FSharp.Compiler.Symbols.FSharpActivePatternCase: FSharp.Compiler.Symbols.FSharpXmlDoc XmlDoc
@@ -4433,7 +4352,6 @@ FSharp.Compiler.Symbols.FSharpActivePatternCase: System.String Name
 FSharp.Compiler.Symbols.FSharpActivePatternCase: System.String XmlDocSig
 FSharp.Compiler.Symbols.FSharpActivePatternCase: System.String get_Name()
 FSharp.Compiler.Symbols.FSharpActivePatternCase: System.String get_XmlDocSig()
-FSharp.Compiler.Symbols.FSharpActivePatternGroup
 FSharp.Compiler.Symbols.FSharpActivePatternGroup: Boolean IsTotal
 FSharp.Compiler.Symbols.FSharpActivePatternGroup: Boolean get_IsTotal()
 FSharp.Compiler.Symbols.FSharpActivePatternGroup: FSharp.Compiler.Symbols.FSharpType OverallType
@@ -4444,7 +4362,6 @@ FSharp.Compiler.Symbols.FSharpActivePatternGroup: Microsoft.FSharp.Core.FSharpOp
 FSharp.Compiler.Symbols.FSharpActivePatternGroup: Microsoft.FSharp.Core.FSharpOption`1[System.String] get_Name()
 FSharp.Compiler.Symbols.FSharpActivePatternGroup: System.Collections.Generic.IList`1[System.String] Names
 FSharp.Compiler.Symbols.FSharpActivePatternGroup: System.Collections.Generic.IList`1[System.String] get_Names()
-FSharp.Compiler.Symbols.FSharpAnonRecordTypeDetails
 FSharp.Compiler.Symbols.FSharpAnonRecordTypeDetails: FSharp.Compiler.Symbols.FSharpAssembly Assembly
 FSharp.Compiler.Symbols.FSharpAnonRecordTypeDetails: FSharp.Compiler.Symbols.FSharpAssembly get_Assembly()
 FSharp.Compiler.Symbols.FSharpAnonRecordTypeDetails: Microsoft.FSharp.Collections.FSharpList`1[System.String] EnclosingCompiledTypeNames
@@ -4453,7 +4370,6 @@ FSharp.Compiler.Symbols.FSharpAnonRecordTypeDetails: System.String CompiledName
 FSharp.Compiler.Symbols.FSharpAnonRecordTypeDetails: System.String get_CompiledName()
 FSharp.Compiler.Symbols.FSharpAnonRecordTypeDetails: System.String[] SortedFieldNames
 FSharp.Compiler.Symbols.FSharpAnonRecordTypeDetails: System.String[] get_SortedFieldNames()
-FSharp.Compiler.Symbols.FSharpAssembly
 FSharp.Compiler.Symbols.FSharpAssembly: Boolean IsProviderGenerated
 FSharp.Compiler.Symbols.FSharpAssembly: Boolean get_IsProviderGenerated()
 FSharp.Compiler.Symbols.FSharpAssembly: FSharp.Compiler.Symbols.FSharpAssemblySignature Contents
@@ -4465,10 +4381,8 @@ FSharp.Compiler.Symbols.FSharpAssembly: System.String SimpleName
 FSharp.Compiler.Symbols.FSharpAssembly: System.String ToString()
 FSharp.Compiler.Symbols.FSharpAssembly: System.String get_QualifiedName()
 FSharp.Compiler.Symbols.FSharpAssembly: System.String get_SimpleName()
-FSharp.Compiler.Symbols.FSharpAssemblyContents
 FSharp.Compiler.Symbols.FSharpAssemblyContents: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpImplementationFileContents] ImplementationFiles
 FSharp.Compiler.Symbols.FSharpAssemblyContents: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpImplementationFileContents] get_ImplementationFiles()
-FSharp.Compiler.Symbols.FSharpAssemblySignature
 FSharp.Compiler.Symbols.FSharpAssemblySignature: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpEntity] FindEntityByPath(Microsoft.FSharp.Collections.FSharpList`1[System.String])
 FSharp.Compiler.Symbols.FSharpAssemblySignature: System.Collections.Generic.IEnumerable`1[FSharp.Compiler.Symbols.FSharpEntity] TryGetEntities()
 FSharp.Compiler.Symbols.FSharpAssemblySignature: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAttribute] Attributes
@@ -4476,7 +4390,6 @@ FSharp.Compiler.Symbols.FSharpAssemblySignature: System.Collections.Generic.ILis
 FSharp.Compiler.Symbols.FSharpAssemblySignature: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpEntity] Entities
 FSharp.Compiler.Symbols.FSharpAssemblySignature: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpEntity] get_Entities()
 FSharp.Compiler.Symbols.FSharpAssemblySignature: System.String ToString()
-FSharp.Compiler.Symbols.FSharpAttribute
 FSharp.Compiler.Symbols.FSharpAttribute: Boolean IsAttribute[T]()
 FSharp.Compiler.Symbols.FSharpAttribute: Boolean IsUnresolved
 FSharp.Compiler.Symbols.FSharpAttribute: Boolean get_IsUnresolved()
@@ -4490,19 +4403,16 @@ FSharp.Compiler.Symbols.FSharpAttribute: System.Collections.Generic.IList`1[Syst
 FSharp.Compiler.Symbols.FSharpAttribute: System.Collections.Generic.IList`1[System.Tuple`4[FSharp.Compiler.Symbols.FSharpType,System.String,System.Boolean,System.Object]] get_NamedArguments()
 FSharp.Compiler.Symbols.FSharpAttribute: System.String Format(FSharp.Compiler.Symbols.FSharpDisplayContext)
 FSharp.Compiler.Symbols.FSharpAttribute: System.String ToString()
-FSharp.Compiler.Symbols.FSharpDelegateSignature
 FSharp.Compiler.Symbols.FSharpDelegateSignature: FSharp.Compiler.Symbols.FSharpType DelegateReturnType
 FSharp.Compiler.Symbols.FSharpDelegateSignature: FSharp.Compiler.Symbols.FSharpType get_DelegateReturnType()
 FSharp.Compiler.Symbols.FSharpDelegateSignature: System.Collections.Generic.IList`1[System.Tuple`2[Microsoft.FSharp.Core.FSharpOption`1[System.String],FSharp.Compiler.Symbols.FSharpType]] DelegateArguments
 FSharp.Compiler.Symbols.FSharpDelegateSignature: System.Collections.Generic.IList`1[System.Tuple`2[Microsoft.FSharp.Core.FSharpOption`1[System.String],FSharp.Compiler.Symbols.FSharpType]] get_DelegateArguments()
 FSharp.Compiler.Symbols.FSharpDelegateSignature: System.String ToString()
-FSharp.Compiler.Symbols.FSharpDisplayContext
 FSharp.Compiler.Symbols.FSharpDisplayContext: FSharp.Compiler.Symbols.FSharpDisplayContext Empty
 FSharp.Compiler.Symbols.FSharpDisplayContext: FSharp.Compiler.Symbols.FSharpDisplayContext WithPrefixGenericParameters()
 FSharp.Compiler.Symbols.FSharpDisplayContext: FSharp.Compiler.Symbols.FSharpDisplayContext WithShortTypeNames(Boolean)
 FSharp.Compiler.Symbols.FSharpDisplayContext: FSharp.Compiler.Symbols.FSharpDisplayContext WithSuffixGenericParameters()
 FSharp.Compiler.Symbols.FSharpDisplayContext: FSharp.Compiler.Symbols.FSharpDisplayContext get_Empty()
-FSharp.Compiler.Symbols.FSharpEntity
 FSharp.Compiler.Symbols.FSharpEntity: Boolean Equals(System.Object)
 FSharp.Compiler.Symbols.FSharpEntity: Boolean HasAssemblyCodeRepresentation
 FSharp.Compiler.Symbols.FSharpEntity: Boolean HasFSharpModuleSuffix
@@ -4625,7 +4535,6 @@ FSharp.Compiler.Symbols.FSharpEntity: System.String get_FullName()
 FSharp.Compiler.Symbols.FSharpEntity: System.String get_LogicalName()
 FSharp.Compiler.Symbols.FSharpEntity: System.String get_QualifiedName()
 FSharp.Compiler.Symbols.FSharpEntity: System.String get_XmlDocSig()
-FSharp.Compiler.Symbols.FSharpExpr
 FSharp.Compiler.Symbols.FSharpExpr: FSharp.Compiler.Symbols.FSharpType Type
 FSharp.Compiler.Symbols.FSharpExpr: FSharp.Compiler.Symbols.FSharpType get_Type()
 FSharp.Compiler.Symbols.FSharpExpr: FSharp.Compiler.Text.Range Range
@@ -4633,7 +4542,6 @@ FSharp.Compiler.Symbols.FSharpExpr: FSharp.Compiler.Text.Range get_Range()
 FSharp.Compiler.Symbols.FSharpExpr: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpExpr] ImmediateSubExpressions
 FSharp.Compiler.Symbols.FSharpExpr: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpExpr] get_ImmediateSubExpressions()
 FSharp.Compiler.Symbols.FSharpExpr: System.String ToString()
-FSharp.Compiler.Symbols.FSharpExprPatterns
 FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpExpr] |AddressOf|_|(FSharp.Compiler.Symbols.FSharpExpr)
 FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpExpr] |Quote|_|(FSharp.Compiler.Symbols.FSharpExpr)
 FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue] |Value|_|(FSharp.Compiler.Symbols.FSharpExpr)
@@ -4682,7 +4590,6 @@ FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1
 FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`6[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpType],System.String,FSharp.Compiler.Syntax.SynMemberFlags,Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpType],Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpType],Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpExpr]]] |TraitCall|_|(FSharp.Compiler.Symbols.FSharpExpr)
 FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`6[Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpExpr],FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue,Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpType],Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpType],Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpExpr],Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpExpr]]] |CallWithWitnesses|_|(FSharp.Compiler.Symbols.FSharpExpr)
 FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`7[FSharp.Compiler.Symbols.FSharpExpr,FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue,FSharp.Compiler.Symbols.FSharpExpr,FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue,FSharp.Compiler.Symbols.FSharpExpr,FSharp.Compiler.Syntax.DebugPointAtTry,FSharp.Compiler.Syntax.DebugPointAtWith]] |TryWith|_|(FSharp.Compiler.Symbols.FSharpExpr)
-FSharp.Compiler.Symbols.FSharpField
 FSharp.Compiler.Symbols.FSharpField: Boolean Equals(System.Object)
 FSharp.Compiler.Symbols.FSharpField: Boolean IsAnonRecordField
 FSharp.Compiler.Symbols.FSharpField: Boolean IsCompilerGenerated
@@ -4730,7 +4637,6 @@ FSharp.Compiler.Symbols.FSharpField: System.String get_Name()
 FSharp.Compiler.Symbols.FSharpField: System.String get_XmlDocSig()
 FSharp.Compiler.Symbols.FSharpField: System.Tuple`3[FSharp.Compiler.Symbols.FSharpAnonRecordTypeDetails,FSharp.Compiler.Symbols.FSharpType[],System.Int32] AnonRecordFieldDetails
 FSharp.Compiler.Symbols.FSharpField: System.Tuple`3[FSharp.Compiler.Symbols.FSharpAnonRecordTypeDetails,FSharp.Compiler.Symbols.FSharpType[],System.Int32] get_AnonRecordFieldDetails()
-FSharp.Compiler.Symbols.FSharpGenericParameter
 FSharp.Compiler.Symbols.FSharpGenericParameter: Boolean Equals(System.Object)
 FSharp.Compiler.Symbols.FSharpGenericParameter: Boolean IsCompilerGenerated
 FSharp.Compiler.Symbols.FSharpGenericParameter: Boolean IsMeasure
@@ -4750,7 +4656,6 @@ FSharp.Compiler.Symbols.FSharpGenericParameter: System.Collections.Generic.IList
 FSharp.Compiler.Symbols.FSharpGenericParameter: System.String Name
 FSharp.Compiler.Symbols.FSharpGenericParameter: System.String ToString()
 FSharp.Compiler.Symbols.FSharpGenericParameter: System.String get_Name()
-FSharp.Compiler.Symbols.FSharpGenericParameterConstraint
 FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean IsCoercesToConstraint
 FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean IsComparisonConstraint
 FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean IsDefaultsToConstraint
@@ -4790,19 +4695,16 @@ FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: FSharp.Compiler.Symbol
 FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpType] SimpleChoices
 FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpType] get_SimpleChoices()
 FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: System.String ToString()
-FSharp.Compiler.Symbols.FSharpGenericParameterDefaultsToConstraint
 FSharp.Compiler.Symbols.FSharpGenericParameterDefaultsToConstraint: FSharp.Compiler.Symbols.FSharpType DefaultsToTarget
 FSharp.Compiler.Symbols.FSharpGenericParameterDefaultsToConstraint: FSharp.Compiler.Symbols.FSharpType get_DefaultsToTarget()
 FSharp.Compiler.Symbols.FSharpGenericParameterDefaultsToConstraint: Int32 DefaultsToPriority
 FSharp.Compiler.Symbols.FSharpGenericParameterDefaultsToConstraint: Int32 get_DefaultsToPriority()
 FSharp.Compiler.Symbols.FSharpGenericParameterDefaultsToConstraint: System.String ToString()
-FSharp.Compiler.Symbols.FSharpGenericParameterDelegateConstraint
 FSharp.Compiler.Symbols.FSharpGenericParameterDelegateConstraint: FSharp.Compiler.Symbols.FSharpType DelegateReturnType
 FSharp.Compiler.Symbols.FSharpGenericParameterDelegateConstraint: FSharp.Compiler.Symbols.FSharpType DelegateTupledArgumentType
 FSharp.Compiler.Symbols.FSharpGenericParameterDelegateConstraint: FSharp.Compiler.Symbols.FSharpType get_DelegateReturnType()
 FSharp.Compiler.Symbols.FSharpGenericParameterDelegateConstraint: FSharp.Compiler.Symbols.FSharpType get_DelegateTupledArgumentType()
 FSharp.Compiler.Symbols.FSharpGenericParameterDelegateConstraint: System.String ToString()
-FSharp.Compiler.Symbols.FSharpGenericParameterMemberConstraint
 FSharp.Compiler.Symbols.FSharpGenericParameterMemberConstraint: Boolean MemberIsStatic
 FSharp.Compiler.Symbols.FSharpGenericParameterMemberConstraint: Boolean get_MemberIsStatic()
 FSharp.Compiler.Symbols.FSharpGenericParameterMemberConstraint: FSharp.Compiler.Symbols.FSharpType MemberReturnType
@@ -4814,7 +4716,6 @@ FSharp.Compiler.Symbols.FSharpGenericParameterMemberConstraint: System.Collectio
 FSharp.Compiler.Symbols.FSharpGenericParameterMemberConstraint: System.String MemberName
 FSharp.Compiler.Symbols.FSharpGenericParameterMemberConstraint: System.String ToString()
 FSharp.Compiler.Symbols.FSharpGenericParameterMemberConstraint: System.String get_MemberName()
-FSharp.Compiler.Symbols.FSharpImplementationFileContents
 FSharp.Compiler.Symbols.FSharpImplementationFileContents: Boolean HasExplicitEntryPoint
 FSharp.Compiler.Symbols.FSharpImplementationFileContents: Boolean IsScript
 FSharp.Compiler.Symbols.FSharpImplementationFileContents: Boolean get_HasExplicitEntryPoint()
@@ -4825,7 +4726,6 @@ FSharp.Compiler.Symbols.FSharpImplementationFileContents: System.String FileName
 FSharp.Compiler.Symbols.FSharpImplementationFileContents: System.String QualifiedName
 FSharp.Compiler.Symbols.FSharpImplementationFileContents: System.String get_FileName()
 FSharp.Compiler.Symbols.FSharpImplementationFileContents: System.String get_QualifiedName()
-FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration
 FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration+Entity: FSharp.Compiler.Symbols.FSharpEntity entity
 FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration+Entity: FSharp.Compiler.Symbols.FSharpEntity get_entity()
 FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration+Entity: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration] declarations
@@ -4862,7 +4762,6 @@ FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration: Int32 GetHashCode(S
 FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration: Int32 Tag
 FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration: Int32 get_Tag()
 FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration: System.String ToString()
-FSharp.Compiler.Symbols.FSharpInlineAnnotation
 FSharp.Compiler.Symbols.FSharpInlineAnnotation+Tags: Int32 AggressiveInline
 FSharp.Compiler.Symbols.FSharpInlineAnnotation+Tags: Int32 AlwaysInline
 FSharp.Compiler.Symbols.FSharpInlineAnnotation+Tags: Int32 NeverInline
@@ -4895,11 +4794,11 @@ FSharp.Compiler.Symbols.FSharpInlineAnnotation: Int32 GetHashCode(System.Collect
 FSharp.Compiler.Symbols.FSharpInlineAnnotation: Int32 Tag
 FSharp.Compiler.Symbols.FSharpInlineAnnotation: Int32 get_Tag()
 FSharp.Compiler.Symbols.FSharpInlineAnnotation: System.String ToString()
-FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue
 FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean Equals(System.Object)
 FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean EventIsStandard
 FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean HasGetterMethod
 FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean HasSetterMethod
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean HasSignatureFile
 FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsActivePattern
 FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsBaseValue
 FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsCompilerGenerated
@@ -4932,6 +4831,7 @@ FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsValue
 FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_EventIsStandard()
 FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_HasGetterMethod()
 FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_HasSetterMethod()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_HasSignatureFile()
 FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsActivePattern()
 FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsBaseValue()
 FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsCompilerGenerated()
@@ -5017,7 +4917,6 @@ FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: System.String get_Compile
 FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: System.String get_DisplayName()
 FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: System.String get_LogicalName()
 FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: System.String get_XmlDocSig()
-FSharp.Compiler.Symbols.FSharpObjectExprOverride
 FSharp.Compiler.Symbols.FSharpObjectExprOverride: FSharp.Compiler.Symbols.FSharpAbstractSignature Signature
 FSharp.Compiler.Symbols.FSharpObjectExprOverride: FSharp.Compiler.Symbols.FSharpAbstractSignature get_Signature()
 FSharp.Compiler.Symbols.FSharpObjectExprOverride: FSharp.Compiler.Symbols.FSharpExpr Body
@@ -5026,7 +4925,6 @@ FSharp.Compiler.Symbols.FSharpObjectExprOverride: Microsoft.FSharp.Collections.F
 FSharp.Compiler.Symbols.FSharpObjectExprOverride: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpGenericParameter] get_GenericParameters()
 FSharp.Compiler.Symbols.FSharpObjectExprOverride: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue]] CurriedParameterGroups
 FSharp.Compiler.Symbols.FSharpObjectExprOverride: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue]] get_CurriedParameterGroups()
-FSharp.Compiler.Symbols.FSharpOpenDeclaration
 FSharp.Compiler.Symbols.FSharpOpenDeclaration: Boolean IsOwnNamespace
 FSharp.Compiler.Symbols.FSharpOpenDeclaration: Boolean get_IsOwnNamespace()
 FSharp.Compiler.Symbols.FSharpOpenDeclaration: FSharp.Compiler.Syntax.SynOpenDeclTarget Target
@@ -5041,7 +4939,6 @@ FSharp.Compiler.Symbols.FSharpOpenDeclaration: Microsoft.FSharp.Collections.FSha
 FSharp.Compiler.Symbols.FSharpOpenDeclaration: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] get_LongId()
 FSharp.Compiler.Symbols.FSharpOpenDeclaration: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] Range
 FSharp.Compiler.Symbols.FSharpOpenDeclaration: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_Range()
-FSharp.Compiler.Symbols.FSharpParameter
 FSharp.Compiler.Symbols.FSharpParameter: Boolean Equals(System.Object)
 FSharp.Compiler.Symbols.FSharpParameter: Boolean IsInArg
 FSharp.Compiler.Symbols.FSharpParameter: Boolean IsOptionalArg
@@ -5061,7 +4958,6 @@ FSharp.Compiler.Symbols.FSharpParameter: Microsoft.FSharp.Core.FSharpOption`1[Sy
 FSharp.Compiler.Symbols.FSharpParameter: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAttribute] Attributes
 FSharp.Compiler.Symbols.FSharpParameter: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAttribute] get_Attributes()
 FSharp.Compiler.Symbols.FSharpParameter: System.String ToString()
-FSharp.Compiler.Symbols.FSharpStaticParameter
 FSharp.Compiler.Symbols.FSharpStaticParameter: Boolean Equals(System.Object)
 FSharp.Compiler.Symbols.FSharpStaticParameter: Boolean HasDefaultValue
 FSharp.Compiler.Symbols.FSharpStaticParameter: Boolean IsOptional
@@ -5079,7 +4975,6 @@ FSharp.Compiler.Symbols.FSharpStaticParameter: System.Object get_DefaultValue()
 FSharp.Compiler.Symbols.FSharpStaticParameter: System.String Name
 FSharp.Compiler.Symbols.FSharpStaticParameter: System.String ToString()
 FSharp.Compiler.Symbols.FSharpStaticParameter: System.String get_Name()
-FSharp.Compiler.Symbols.FSharpSymbol
 FSharp.Compiler.Symbols.FSharpSymbol: Boolean Equals(System.Object)
 FSharp.Compiler.Symbols.FSharpSymbol: Boolean HasAttribute[T]()
 FSharp.Compiler.Symbols.FSharpSymbol: Boolean IsAccessible(FSharp.Compiler.Symbols.FSharpAccessibilityRights)
@@ -5108,7 +5003,6 @@ FSharp.Compiler.Symbols.FSharpSymbol: System.String ToString()
 FSharp.Compiler.Symbols.FSharpSymbol: System.String get_DisplayName()
 FSharp.Compiler.Symbols.FSharpSymbol: System.String get_DisplayNameCore()
 FSharp.Compiler.Symbols.FSharpSymbol: System.String get_FullName()
-FSharp.Compiler.Symbols.FSharpSymbolPatterns
 FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpActivePatternCase] |ActivePatternCase|_|(FSharp.Compiler.Symbols.FSharpSymbol)
 FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpEntity] |Constructor|_|(FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue)
 FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpEntity] |TypeWithDefinition|_|(FSharp.Compiler.Symbols.FSharpType)
@@ -5144,7 +5038,6 @@ FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption
 FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |ValueType|_|(FSharp.Compiler.Symbols.FSharpEntity)
 FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpField,FSharp.Compiler.Symbols.FSharpType]] |Field|_|(FSharp.Compiler.Symbols.FSharpSymbol)
 FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[FSharp.Compiler.Symbols.FSharpEntity,FSharp.Compiler.Symbols.FSharpEntity,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpType]]] |FSharpEntity|_|(FSharp.Compiler.Symbols.FSharpSymbol)
-FSharp.Compiler.Symbols.FSharpType
 FSharp.Compiler.Symbols.FSharpType: Boolean Equals(System.Object)
 FSharp.Compiler.Symbols.FSharpType: Boolean HasTypeDefinition
 FSharp.Compiler.Symbols.FSharpType: Boolean IsAbbreviation
@@ -5194,7 +5087,6 @@ FSharp.Compiler.Symbols.FSharpType: System.String FormatWithConstraints(FSharp.C
 FSharp.Compiler.Symbols.FSharpType: System.String ToString()
 FSharp.Compiler.Symbols.FSharpType: System.String get_BasicQualifiedName()
 FSharp.Compiler.Symbols.FSharpType: System.Tuple`2[System.Collections.Generic.IList`1[System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpParameter]],FSharp.Compiler.Symbols.FSharpParameter] Prettify(System.Collections.Generic.IList`1[System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpParameter]], FSharp.Compiler.Symbols.FSharpParameter)
-FSharp.Compiler.Symbols.FSharpUnionCase
 FSharp.Compiler.Symbols.FSharpUnionCase: Boolean Equals(System.Object)
 FSharp.Compiler.Symbols.FSharpUnionCase: Boolean HasFields
 FSharp.Compiler.Symbols.FSharpUnionCase: Boolean IsUnresolved
@@ -5220,7 +5112,6 @@ FSharp.Compiler.Symbols.FSharpUnionCase: System.String XmlDocSig
 FSharp.Compiler.Symbols.FSharpUnionCase: System.String get_CompiledName()
 FSharp.Compiler.Symbols.FSharpUnionCase: System.String get_Name()
 FSharp.Compiler.Symbols.FSharpUnionCase: System.String get_XmlDocSig()
-FSharp.Compiler.Symbols.FSharpXmlDoc
 FSharp.Compiler.Symbols.FSharpXmlDoc+FromXmlFile: System.String dllName
 FSharp.Compiler.Symbols.FSharpXmlDoc+FromXmlFile: System.String get_dllName()
 FSharp.Compiler.Symbols.FSharpXmlDoc+FromXmlFile: System.String get_xmlSig()
@@ -5251,7 +5142,6 @@ FSharp.Compiler.Symbols.FSharpXmlDoc: Int32 GetHashCode(System.Collections.IEqua
 FSharp.Compiler.Symbols.FSharpXmlDoc: Int32 Tag
 FSharp.Compiler.Symbols.FSharpXmlDoc: Int32 get_Tag()
 FSharp.Compiler.Symbols.FSharpXmlDoc: System.String ToString()
-FSharp.Compiler.Syntax.DebugPointAtBinding
 FSharp.Compiler.Syntax.DebugPointAtBinding+Tags: Int32 NoneAtDo
 FSharp.Compiler.Syntax.DebugPointAtBinding+Tags: Int32 NoneAtInvisible
 FSharp.Compiler.Syntax.DebugPointAtBinding+Tags: Int32 NoneAtLet
@@ -5289,7 +5179,6 @@ FSharp.Compiler.Syntax.DebugPointAtBinding: Int32 GetHashCode(System.Collections
 FSharp.Compiler.Syntax.DebugPointAtBinding: Int32 Tag
 FSharp.Compiler.Syntax.DebugPointAtBinding: Int32 get_Tag()
 FSharp.Compiler.Syntax.DebugPointAtBinding: System.String ToString()
-FSharp.Compiler.Syntax.DebugPointAtFinally
 FSharp.Compiler.Syntax.DebugPointAtFinally+Tags: Int32 No
 FSharp.Compiler.Syntax.DebugPointAtFinally+Tags: Int32 Yes
 FSharp.Compiler.Syntax.DebugPointAtFinally+Yes: FSharp.Compiler.Text.Range get_range()
@@ -5311,7 +5200,6 @@ FSharp.Compiler.Syntax.DebugPointAtFinally: Int32 GetHashCode(System.Collections
 FSharp.Compiler.Syntax.DebugPointAtFinally: Int32 Tag
 FSharp.Compiler.Syntax.DebugPointAtFinally: Int32 get_Tag()
 FSharp.Compiler.Syntax.DebugPointAtFinally: System.String ToString()
-FSharp.Compiler.Syntax.DebugPointAtFor
 FSharp.Compiler.Syntax.DebugPointAtFor+Tags: Int32 No
 FSharp.Compiler.Syntax.DebugPointAtFor+Tags: Int32 Yes
 FSharp.Compiler.Syntax.DebugPointAtFor+Yes: FSharp.Compiler.Text.Range get_range()
@@ -5333,7 +5221,6 @@ FSharp.Compiler.Syntax.DebugPointAtFor: Int32 GetHashCode(System.Collections.IEq
 FSharp.Compiler.Syntax.DebugPointAtFor: Int32 Tag
 FSharp.Compiler.Syntax.DebugPointAtFor: Int32 get_Tag()
 FSharp.Compiler.Syntax.DebugPointAtFor: System.String ToString()
-FSharp.Compiler.Syntax.DebugPointAtInOrTo
 FSharp.Compiler.Syntax.DebugPointAtInOrTo+Tags: Int32 No
 FSharp.Compiler.Syntax.DebugPointAtInOrTo+Tags: Int32 Yes
 FSharp.Compiler.Syntax.DebugPointAtInOrTo+Yes: FSharp.Compiler.Text.Range get_range()
@@ -5355,7 +5242,6 @@ FSharp.Compiler.Syntax.DebugPointAtInOrTo: Int32 GetHashCode(System.Collections.
 FSharp.Compiler.Syntax.DebugPointAtInOrTo: Int32 Tag
 FSharp.Compiler.Syntax.DebugPointAtInOrTo: Int32 get_Tag()
 FSharp.Compiler.Syntax.DebugPointAtInOrTo: System.String ToString()
-FSharp.Compiler.Syntax.DebugPointAtLeafExpr
 FSharp.Compiler.Syntax.DebugPointAtLeafExpr: Boolean Equals(FSharp.Compiler.Syntax.DebugPointAtLeafExpr)
 FSharp.Compiler.Syntax.DebugPointAtLeafExpr: Boolean Equals(System.Object)
 FSharp.Compiler.Syntax.DebugPointAtLeafExpr: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
@@ -5367,7 +5253,6 @@ FSharp.Compiler.Syntax.DebugPointAtLeafExpr: Int32 GetHashCode(System.Collection
 FSharp.Compiler.Syntax.DebugPointAtLeafExpr: Int32 Tag
 FSharp.Compiler.Syntax.DebugPointAtLeafExpr: Int32 get_Tag()
 FSharp.Compiler.Syntax.DebugPointAtLeafExpr: System.String ToString()
-FSharp.Compiler.Syntax.DebugPointAtSequential
 FSharp.Compiler.Syntax.DebugPointAtSequential+Tags: Int32 SuppressBoth
 FSharp.Compiler.Syntax.DebugPointAtSequential+Tags: Int32 SuppressExpr
 FSharp.Compiler.Syntax.DebugPointAtSequential+Tags: Int32 SuppressNeither
@@ -5400,7 +5285,6 @@ FSharp.Compiler.Syntax.DebugPointAtSequential: Int32 GetHashCode(System.Collecti
 FSharp.Compiler.Syntax.DebugPointAtSequential: Int32 Tag
 FSharp.Compiler.Syntax.DebugPointAtSequential: Int32 get_Tag()
 FSharp.Compiler.Syntax.DebugPointAtSequential: System.String ToString()
-FSharp.Compiler.Syntax.DebugPointAtTarget
 FSharp.Compiler.Syntax.DebugPointAtTarget+Tags: Int32 No
 FSharp.Compiler.Syntax.DebugPointAtTarget+Tags: Int32 Yes
 FSharp.Compiler.Syntax.DebugPointAtTarget: Boolean Equals(FSharp.Compiler.Syntax.DebugPointAtTarget)
@@ -5423,7 +5307,6 @@ FSharp.Compiler.Syntax.DebugPointAtTarget: Int32 GetHashCode(System.Collections.
 FSharp.Compiler.Syntax.DebugPointAtTarget: Int32 Tag
 FSharp.Compiler.Syntax.DebugPointAtTarget: Int32 get_Tag()
 FSharp.Compiler.Syntax.DebugPointAtTarget: System.String ToString()
-FSharp.Compiler.Syntax.DebugPointAtTry
 FSharp.Compiler.Syntax.DebugPointAtTry+Tags: Int32 No
 FSharp.Compiler.Syntax.DebugPointAtTry+Tags: Int32 Yes
 FSharp.Compiler.Syntax.DebugPointAtTry+Yes: FSharp.Compiler.Text.Range get_range()
@@ -5445,7 +5328,6 @@ FSharp.Compiler.Syntax.DebugPointAtTry: Int32 GetHashCode(System.Collections.IEq
 FSharp.Compiler.Syntax.DebugPointAtTry: Int32 Tag
 FSharp.Compiler.Syntax.DebugPointAtTry: Int32 get_Tag()
 FSharp.Compiler.Syntax.DebugPointAtTry: System.String ToString()
-FSharp.Compiler.Syntax.DebugPointAtWhile
 FSharp.Compiler.Syntax.DebugPointAtWhile+Tags: Int32 No
 FSharp.Compiler.Syntax.DebugPointAtWhile+Tags: Int32 Yes
 FSharp.Compiler.Syntax.DebugPointAtWhile+Yes: FSharp.Compiler.Text.Range get_range()
@@ -5467,7 +5349,6 @@ FSharp.Compiler.Syntax.DebugPointAtWhile: Int32 GetHashCode(System.Collections.I
 FSharp.Compiler.Syntax.DebugPointAtWhile: Int32 Tag
 FSharp.Compiler.Syntax.DebugPointAtWhile: Int32 get_Tag()
 FSharp.Compiler.Syntax.DebugPointAtWhile: System.String ToString()
-FSharp.Compiler.Syntax.DebugPointAtWith
 FSharp.Compiler.Syntax.DebugPointAtWith+Tags: Int32 No
 FSharp.Compiler.Syntax.DebugPointAtWith+Tags: Int32 Yes
 FSharp.Compiler.Syntax.DebugPointAtWith+Yes: FSharp.Compiler.Text.Range get_range()
@@ -5489,18 +5370,15 @@ FSharp.Compiler.Syntax.DebugPointAtWith: Int32 GetHashCode(System.Collections.IE
 FSharp.Compiler.Syntax.DebugPointAtWith: Int32 Tag
 FSharp.Compiler.Syntax.DebugPointAtWith: Int32 get_Tag()
 FSharp.Compiler.Syntax.DebugPointAtWith: System.String ToString()
-FSharp.Compiler.Syntax.ExprAtomicFlag
 FSharp.Compiler.Syntax.ExprAtomicFlag: FSharp.Compiler.Syntax.ExprAtomicFlag Atomic
 FSharp.Compiler.Syntax.ExprAtomicFlag: FSharp.Compiler.Syntax.ExprAtomicFlag NonAtomic
 FSharp.Compiler.Syntax.ExprAtomicFlag: Int32 value__
-FSharp.Compiler.Syntax.Ident
 FSharp.Compiler.Syntax.Ident: FSharp.Compiler.Text.Range get_idRange()
 FSharp.Compiler.Syntax.Ident: FSharp.Compiler.Text.Range idRange
 FSharp.Compiler.Syntax.Ident: System.String ToString()
 FSharp.Compiler.Syntax.Ident: System.String get_idText()
 FSharp.Compiler.Syntax.Ident: System.String idText
 FSharp.Compiler.Syntax.Ident: Void .ctor(System.String, FSharp.Compiler.Text.Range)
-FSharp.Compiler.Syntax.ParsedHashDirective
 FSharp.Compiler.Syntax.ParsedHashDirective: FSharp.Compiler.Syntax.ParsedHashDirective NewParsedHashDirective(System.String, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedHashDirectiveArgument], FSharp.Compiler.Text.Range)
 FSharp.Compiler.Syntax.ParsedHashDirective: FSharp.Compiler.Text.Range get_range()
 FSharp.Compiler.Syntax.ParsedHashDirective: FSharp.Compiler.Text.Range range
@@ -5511,7 +5389,6 @@ FSharp.Compiler.Syntax.ParsedHashDirective: Microsoft.FSharp.Collections.FSharpL
 FSharp.Compiler.Syntax.ParsedHashDirective: System.String ToString()
 FSharp.Compiler.Syntax.ParsedHashDirective: System.String get_ident()
 FSharp.Compiler.Syntax.ParsedHashDirective: System.String ident
-FSharp.Compiler.Syntax.ParsedHashDirectiveArgument
 FSharp.Compiler.Syntax.ParsedHashDirectiveArgument+SourceIdentifier: FSharp.Compiler.Text.Range get_range()
 FSharp.Compiler.Syntax.ParsedHashDirectiveArgument+SourceIdentifier: FSharp.Compiler.Text.Range range
 FSharp.Compiler.Syntax.ParsedHashDirectiveArgument+SourceIdentifier: System.String constant
@@ -5540,7 +5417,6 @@ FSharp.Compiler.Syntax.ParsedHashDirectiveArgument: FSharp.Compiler.Text.Range g
 FSharp.Compiler.Syntax.ParsedHashDirectiveArgument: Int32 Tag
 FSharp.Compiler.Syntax.ParsedHashDirectiveArgument: Int32 get_Tag()
 FSharp.Compiler.Syntax.ParsedHashDirectiveArgument: System.String ToString()
-FSharp.Compiler.Syntax.ParsedImplFile
 FSharp.Compiler.Syntax.ParsedImplFile: FSharp.Compiler.Syntax.ParsedImplFile NewParsedImplFile(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedHashDirective], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedImplFileFragment])
 FSharp.Compiler.Syntax.ParsedImplFile: Int32 Tag
 FSharp.Compiler.Syntax.ParsedImplFile: Int32 get_Tag()
@@ -5549,7 +5425,6 @@ FSharp.Compiler.Syntax.ParsedImplFile: Microsoft.FSharp.Collections.FSharpList`1
 FSharp.Compiler.Syntax.ParsedImplFile: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedImplFileFragment] fragments
 FSharp.Compiler.Syntax.ParsedImplFile: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedImplFileFragment] get_fragments()
 FSharp.Compiler.Syntax.ParsedImplFile: System.String ToString()
-FSharp.Compiler.Syntax.ParsedImplFileFragment
 FSharp.Compiler.Syntax.ParsedImplFileFragment+AnonModule: FSharp.Compiler.Text.Range get_range()
 FSharp.Compiler.Syntax.ParsedImplFileFragment+AnonModule: FSharp.Compiler.Text.Range range
 FSharp.Compiler.Syntax.ParsedImplFileFragment+AnonModule: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleDecl] decls
@@ -5591,7 +5466,6 @@ FSharp.Compiler.Syntax.ParsedImplFileFragment: FSharp.Compiler.Syntax.ParsedImpl
 FSharp.Compiler.Syntax.ParsedImplFileFragment: Int32 Tag
 FSharp.Compiler.Syntax.ParsedImplFileFragment: Int32 get_Tag()
 FSharp.Compiler.Syntax.ParsedImplFileFragment: System.String ToString()
-FSharp.Compiler.Syntax.ParsedImplFileInput
 FSharp.Compiler.Syntax.ParsedImplFileInput: Boolean IsExe
 FSharp.Compiler.Syntax.ParsedImplFileInput: Boolean IsLastCompiland
 FSharp.Compiler.Syntax.ParsedImplFileInput: Boolean IsScript
@@ -5632,7 +5506,6 @@ FSharp.Compiler.Syntax.ParsedImplFileInput: System.String get_FileName()
 FSharp.Compiler.Syntax.ParsedImplFileInput: System.String get_fileName()
 FSharp.Compiler.Syntax.ParsedImplFileInput: System.Tuple`2[System.Boolean,System.Boolean] flags
 FSharp.Compiler.Syntax.ParsedImplFileInput: System.Tuple`2[System.Boolean,System.Boolean] get_flags()
-FSharp.Compiler.Syntax.ParsedInput
 FSharp.Compiler.Syntax.ParsedInput+ImplFile: FSharp.Compiler.Syntax.ParsedImplFileInput Item
 FSharp.Compiler.Syntax.ParsedInput+ImplFile: FSharp.Compiler.Syntax.ParsedImplFileInput get_Item()
 FSharp.Compiler.Syntax.ParsedInput+SigFile: FSharp.Compiler.Syntax.ParsedSigFileInput Item
@@ -5661,7 +5534,6 @@ FSharp.Compiler.Syntax.ParsedInput: Microsoft.FSharp.Collections.FSharpSet`1[Sys
 FSharp.Compiler.Syntax.ParsedInput: System.String FileName
 FSharp.Compiler.Syntax.ParsedInput: System.String ToString()
 FSharp.Compiler.Syntax.ParsedInput: System.String get_FileName()
-FSharp.Compiler.Syntax.ParsedScriptInteraction
 FSharp.Compiler.Syntax.ParsedScriptInteraction: FSharp.Compiler.Syntax.ParsedScriptInteraction NewDefinitions(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleDecl], FSharp.Compiler.Text.Range)
 FSharp.Compiler.Syntax.ParsedScriptInteraction: FSharp.Compiler.Text.Range get_range()
 FSharp.Compiler.Syntax.ParsedScriptInteraction: FSharp.Compiler.Text.Range range
@@ -5670,7 +5542,6 @@ FSharp.Compiler.Syntax.ParsedScriptInteraction: Int32 get_Tag()
 FSharp.Compiler.Syntax.ParsedScriptInteraction: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleDecl] defns
 FSharp.Compiler.Syntax.ParsedScriptInteraction: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleDecl] get_defns()
 FSharp.Compiler.Syntax.ParsedScriptInteraction: System.String ToString()
-FSharp.Compiler.Syntax.ParsedSigFile
 FSharp.Compiler.Syntax.ParsedSigFile: FSharp.Compiler.Syntax.ParsedSigFile NewParsedSigFile(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedHashDirective], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedSigFileFragment])
 FSharp.Compiler.Syntax.ParsedSigFile: Int32 Tag
 FSharp.Compiler.Syntax.ParsedSigFile: Int32 get_Tag()
@@ -5679,7 +5550,6 @@ FSharp.Compiler.Syntax.ParsedSigFile: Microsoft.FSharp.Collections.FSharpList`1[
 FSharp.Compiler.Syntax.ParsedSigFile: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedSigFileFragment] fragments
 FSharp.Compiler.Syntax.ParsedSigFile: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedSigFileFragment] get_fragments()
 FSharp.Compiler.Syntax.ParsedSigFile: System.String ToString()
-FSharp.Compiler.Syntax.ParsedSigFileFragment
 FSharp.Compiler.Syntax.ParsedSigFileFragment+AnonModule: FSharp.Compiler.Text.Range get_range()
 FSharp.Compiler.Syntax.ParsedSigFileFragment+AnonModule: FSharp.Compiler.Text.Range range
 FSharp.Compiler.Syntax.ParsedSigFileFragment+AnonModule: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleSigDecl] decls
@@ -5721,7 +5591,6 @@ FSharp.Compiler.Syntax.ParsedSigFileFragment: FSharp.Compiler.Syntax.ParsedSigFi
 FSharp.Compiler.Syntax.ParsedSigFileFragment: Int32 Tag
 FSharp.Compiler.Syntax.ParsedSigFileFragment: Int32 get_Tag()
 FSharp.Compiler.Syntax.ParsedSigFileFragment: System.String ToString()
-FSharp.Compiler.Syntax.ParsedSigFileInput
 FSharp.Compiler.Syntax.ParsedSigFileInput: FSharp.Compiler.Syntax.ParsedSigFileInput NewParsedSigFileInput(System.String, FSharp.Compiler.Syntax.QualifiedNameOfFile, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ScopedPragma], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedHashDirective], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleOrNamespaceSig], FSharp.Compiler.SyntaxTrivia.ParsedSigFileInputTrivia, Microsoft.FSharp.Collections.FSharpSet`1[System.String])
 FSharp.Compiler.Syntax.ParsedSigFileInput: FSharp.Compiler.Syntax.QualifiedNameOfFile QualifiedName
 FSharp.Compiler.Syntax.ParsedSigFileInput: FSharp.Compiler.Syntax.QualifiedNameOfFile get_QualifiedName()
@@ -5752,7 +5621,6 @@ FSharp.Compiler.Syntax.ParsedSigFileInput: System.String ToString()
 FSharp.Compiler.Syntax.ParsedSigFileInput: System.String fileName
 FSharp.Compiler.Syntax.ParsedSigFileInput: System.String get_FileName()
 FSharp.Compiler.Syntax.ParsedSigFileInput: System.String get_fileName()
-FSharp.Compiler.Syntax.ParserDetail
 FSharp.Compiler.Syntax.ParserDetail+Tags: Int32 ErrorRecovery
 FSharp.Compiler.Syntax.ParserDetail+Tags: Int32 Ok
 FSharp.Compiler.Syntax.ParserDetail: Boolean Equals(FSharp.Compiler.Syntax.ParserDetail)
@@ -5775,7 +5643,6 @@ FSharp.Compiler.Syntax.ParserDetail: Int32 GetHashCode(System.Collections.IEqual
 FSharp.Compiler.Syntax.ParserDetail: Int32 Tag
 FSharp.Compiler.Syntax.ParserDetail: Int32 get_Tag()
 FSharp.Compiler.Syntax.ParserDetail: System.String ToString()
-FSharp.Compiler.Syntax.PrettyNaming
 FSharp.Compiler.Syntax.PrettyNaming: Boolean IsActivePatternName(System.String)
 FSharp.Compiler.Syntax.PrettyNaming: Boolean IsCompilerGeneratedName(System.String)
 FSharp.Compiler.Syntax.PrettyNaming: Boolean IsIdentifierFirstCharacter(Char)
@@ -5796,7 +5663,6 @@ FSharp.Compiler.Syntax.PrettyNaming: System.String FormatAndOtherOverloadsString
 FSharp.Compiler.Syntax.PrettyNaming: System.String FsiDynamicModulePrefix
 FSharp.Compiler.Syntax.PrettyNaming: System.String NormalizeIdentifierBackticks(System.String)
 FSharp.Compiler.Syntax.PrettyNaming: System.String get_FsiDynamicModulePrefix()
-FSharp.Compiler.Syntax.QualifiedNameOfFile
 FSharp.Compiler.Syntax.QualifiedNameOfFile: FSharp.Compiler.Syntax.Ident Id
 FSharp.Compiler.Syntax.QualifiedNameOfFile: FSharp.Compiler.Syntax.Ident Item
 FSharp.Compiler.Syntax.QualifiedNameOfFile: FSharp.Compiler.Syntax.Ident get_Id()
@@ -5809,7 +5675,6 @@ FSharp.Compiler.Syntax.QualifiedNameOfFile: Int32 get_Tag()
 FSharp.Compiler.Syntax.QualifiedNameOfFile: System.String Text
 FSharp.Compiler.Syntax.QualifiedNameOfFile: System.String ToString()
 FSharp.Compiler.Syntax.QualifiedNameOfFile: System.String get_Text()
-FSharp.Compiler.Syntax.ScopedPragma
 FSharp.Compiler.Syntax.ScopedPragma: Boolean Equals(FSharp.Compiler.Syntax.ScopedPragma)
 FSharp.Compiler.Syntax.ScopedPragma: Boolean Equals(System.Object)
 FSharp.Compiler.Syntax.ScopedPragma: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
@@ -5823,7 +5688,6 @@ FSharp.Compiler.Syntax.ScopedPragma: Int32 get_Tag()
 FSharp.Compiler.Syntax.ScopedPragma: Int32 get_warningNumber()
 FSharp.Compiler.Syntax.ScopedPragma: Int32 warningNumber
 FSharp.Compiler.Syntax.ScopedPragma: System.String ToString()
-FSharp.Compiler.Syntax.SeqExprOnly
 FSharp.Compiler.Syntax.SeqExprOnly: Boolean Equals(FSharp.Compiler.Syntax.SeqExprOnly)
 FSharp.Compiler.Syntax.SeqExprOnly: Boolean Equals(System.Object)
 FSharp.Compiler.Syntax.SeqExprOnly: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
@@ -5838,7 +5702,6 @@ FSharp.Compiler.Syntax.SeqExprOnly: Int32 GetHashCode(System.Collections.IEquali
 FSharp.Compiler.Syntax.SeqExprOnly: Int32 Tag
 FSharp.Compiler.Syntax.SeqExprOnly: Int32 get_Tag()
 FSharp.Compiler.Syntax.SeqExprOnly: System.String ToString()
-FSharp.Compiler.Syntax.SynAccess
 FSharp.Compiler.Syntax.SynAccess+Internal: FSharp.Compiler.Text.Range get_range()
 FSharp.Compiler.Syntax.SynAccess+Internal: FSharp.Compiler.Text.Range range
 FSharp.Compiler.Syntax.SynAccess+Private: FSharp.Compiler.Text.Range get_range()
@@ -5871,7 +5734,6 @@ FSharp.Compiler.Syntax.SynAccess: Int32 GetHashCode(System.Collections.IEquality
 FSharp.Compiler.Syntax.SynAccess: Int32 Tag
 FSharp.Compiler.Syntax.SynAccess: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynAccess: System.String ToString()
-FSharp.Compiler.Syntax.SynArgInfo
 FSharp.Compiler.Syntax.SynArgInfo: Boolean get_optional()
 FSharp.Compiler.Syntax.SynArgInfo: Boolean optional
 FSharp.Compiler.Syntax.SynArgInfo: FSharp.Compiler.Syntax.SynArgInfo NewSynArgInfo(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], Boolean, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident])
@@ -5886,7 +5748,6 @@ FSharp.Compiler.Syntax.SynArgInfo: Microsoft.FSharp.Core.FSharpOption`1[FSharp.C
 FSharp.Compiler.Syntax.SynArgInfo: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] get_ident()
 FSharp.Compiler.Syntax.SynArgInfo: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] ident
 FSharp.Compiler.Syntax.SynArgInfo: System.String ToString()
-FSharp.Compiler.Syntax.SynArgPats
 FSharp.Compiler.Syntax.SynArgPats+NamePatPairs: FSharp.Compiler.SyntaxTrivia.SynArgPatsNamePatPairsTrivia get_trivia()
 FSharp.Compiler.Syntax.SynArgPats+NamePatPairs: FSharp.Compiler.SyntaxTrivia.SynArgPatsNamePatPairsTrivia trivia
 FSharp.Compiler.Syntax.SynArgPats+NamePatPairs: FSharp.Compiler.Text.Range get_range()
@@ -5911,7 +5772,6 @@ FSharp.Compiler.Syntax.SynArgPats: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynArgPats: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynPat] Patterns
 FSharp.Compiler.Syntax.SynArgPats: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynPat] get_Patterns()
 FSharp.Compiler.Syntax.SynArgPats: System.String ToString()
-FSharp.Compiler.Syntax.SynAttribute
 FSharp.Compiler.Syntax.SynAttribute: Boolean AppliesToGetterAndSetter
 FSharp.Compiler.Syntax.SynAttribute: Boolean get_AppliesToGetterAndSetter()
 FSharp.Compiler.Syntax.SynAttribute: FSharp.Compiler.Syntax.SynExpr ArgExpr
@@ -5924,14 +5784,12 @@ FSharp.Compiler.Syntax.SynAttribute: Microsoft.FSharp.Core.FSharpOption`1[FSharp
 FSharp.Compiler.Syntax.SynAttribute: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] get_Target()
 FSharp.Compiler.Syntax.SynAttribute: System.String ToString()
 FSharp.Compiler.Syntax.SynAttribute: Void .ctor(FSharp.Compiler.Syntax.SynLongIdent, FSharp.Compiler.Syntax.SynExpr, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident], Boolean, FSharp.Compiler.Text.Range)
-FSharp.Compiler.Syntax.SynAttributeList
 FSharp.Compiler.Syntax.SynAttributeList: FSharp.Compiler.Text.Range Range
 FSharp.Compiler.Syntax.SynAttributeList: FSharp.Compiler.Text.Range get_Range()
 FSharp.Compiler.Syntax.SynAttributeList: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttribute] Attributes
 FSharp.Compiler.Syntax.SynAttributeList: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttribute] get_Attributes()
 FSharp.Compiler.Syntax.SynAttributeList: System.String ToString()
 FSharp.Compiler.Syntax.SynAttributeList: Void .ctor(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttribute], FSharp.Compiler.Text.Range)
-FSharp.Compiler.Syntax.SynBinding
 FSharp.Compiler.Syntax.SynBinding: Boolean get_isInline()
 FSharp.Compiler.Syntax.SynBinding: Boolean get_isMutable()
 FSharp.Compiler.Syntax.SynBinding: Boolean isInline
@@ -5968,7 +5826,6 @@ FSharp.Compiler.Syntax.SynBinding: Microsoft.FSharp.Core.FSharpOption`1[FSharp.C
 FSharp.Compiler.Syntax.SynBinding: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynBindingReturnInfo] get_returnInfo()
 FSharp.Compiler.Syntax.SynBinding: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynBindingReturnInfo] returnInfo
 FSharp.Compiler.Syntax.SynBinding: System.String ToString()
-FSharp.Compiler.Syntax.SynBindingKind
 FSharp.Compiler.Syntax.SynBindingKind+Tags: Int32 Do
 FSharp.Compiler.Syntax.SynBindingKind+Tags: Int32 Normal
 FSharp.Compiler.Syntax.SynBindingKind+Tags: Int32 StandaloneExpression
@@ -5996,7 +5853,6 @@ FSharp.Compiler.Syntax.SynBindingKind: Int32 GetHashCode(System.Collections.IEqu
 FSharp.Compiler.Syntax.SynBindingKind: Int32 Tag
 FSharp.Compiler.Syntax.SynBindingKind: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynBindingKind: System.String ToString()
-FSharp.Compiler.Syntax.SynBindingReturnInfo
 FSharp.Compiler.Syntax.SynBindingReturnInfo: FSharp.Compiler.Syntax.SynBindingReturnInfo NewSynBindingReturnInfo(FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], FSharp.Compiler.SyntaxTrivia.SynBindingReturnInfoTrivia)
 FSharp.Compiler.Syntax.SynBindingReturnInfo: FSharp.Compiler.Syntax.SynType get_typeName()
 FSharp.Compiler.Syntax.SynBindingReturnInfo: FSharp.Compiler.Syntax.SynType typeName
@@ -6009,7 +5865,6 @@ FSharp.Compiler.Syntax.SynBindingReturnInfo: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynBindingReturnInfo: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] attributes
 FSharp.Compiler.Syntax.SynBindingReturnInfo: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] get_attributes()
 FSharp.Compiler.Syntax.SynBindingReturnInfo: System.String ToString()
-FSharp.Compiler.Syntax.SynByteStringKind
 FSharp.Compiler.Syntax.SynByteStringKind+Tags: Int32 Regular
 FSharp.Compiler.Syntax.SynByteStringKind+Tags: Int32 Verbatim
 FSharp.Compiler.Syntax.SynByteStringKind: Boolean Equals(FSharp.Compiler.Syntax.SynByteStringKind)
@@ -6032,7 +5887,6 @@ FSharp.Compiler.Syntax.SynByteStringKind: Int32 GetHashCode(System.Collections.I
 FSharp.Compiler.Syntax.SynByteStringKind: Int32 Tag
 FSharp.Compiler.Syntax.SynByteStringKind: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynByteStringKind: System.String ToString()
-FSharp.Compiler.Syntax.SynComponentInfo
 FSharp.Compiler.Syntax.SynComponentInfo: Boolean get_preferPostfix()
 FSharp.Compiler.Syntax.SynComponentInfo: Boolean preferPostfix
 FSharp.Compiler.Syntax.SynComponentInfo: FSharp.Compiler.Syntax.SynComponentInfo NewSynComponentInfo(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynTyparDecls], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTypeConstraint], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident], FSharp.Compiler.Xml.PreXmlDoc, Boolean, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess], FSharp.Compiler.Text.Range)
@@ -6055,7 +5909,6 @@ FSharp.Compiler.Syntax.SynComponentInfo: Microsoft.FSharp.Core.FSharpOption`1[FS
 FSharp.Compiler.Syntax.SynComponentInfo: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynTyparDecls] get_typeParams()
 FSharp.Compiler.Syntax.SynComponentInfo: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynTyparDecls] typeParams
 FSharp.Compiler.Syntax.SynComponentInfo: System.String ToString()
-FSharp.Compiler.Syntax.SynConst
 FSharp.Compiler.Syntax.SynConst+Bool: Boolean Item
 FSharp.Compiler.Syntax.SynConst+Bool: Boolean get_Item()
 FSharp.Compiler.Syntax.SynConst+Byte: Byte Item
@@ -6231,10 +6084,9 @@ FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Text.Range Range(FSharp.Compile
 FSharp.Compiler.Syntax.SynConst: Int32 Tag
 FSharp.Compiler.Syntax.SynConst: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynConst: System.String ToString()
-FSharp.Compiler.Syntax.SynEnumCase
-FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Syntax.SynConst get_value()
-FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Syntax.SynConst value
-FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Syntax.SynEnumCase NewSynEnumCase(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], FSharp.Compiler.Syntax.SynIdent, FSharp.Compiler.Syntax.SynConst, FSharp.Compiler.Text.Range, FSharp.Compiler.Xml.PreXmlDoc, FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynEnumCaseTrivia)
+FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Syntax.SynEnumCase NewSynEnumCase(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], FSharp.Compiler.Syntax.SynIdent, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Xml.PreXmlDoc, FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynEnumCaseTrivia)
+FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Syntax.SynExpr get_valueExpr()
+FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Syntax.SynExpr valueExpr
 FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Syntax.SynIdent get_ident()
 FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Syntax.SynIdent ident
 FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.SyntaxTrivia.SynEnumCaseTrivia get_trivia()
@@ -6242,9 +6094,7 @@ FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.SyntaxTrivia.SynEnumCaseTriv
 FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Text.Range Range
 FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Text.Range get_Range()
 FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Text.Range get_range()
-FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Text.Range get_valueRange()
 FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Text.Range range
-FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Text.Range valueRange
 FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Xml.PreXmlDoc get_xmlDoc()
 FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Xml.PreXmlDoc xmlDoc
 FSharp.Compiler.Syntax.SynEnumCase: Int32 Tag
@@ -6252,7 +6102,6 @@ FSharp.Compiler.Syntax.SynEnumCase: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynEnumCase: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] attributes
 FSharp.Compiler.Syntax.SynEnumCase: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] get_attributes()
 FSharp.Compiler.Syntax.SynEnumCase: System.String ToString()
-FSharp.Compiler.Syntax.SynExceptionDefn
 FSharp.Compiler.Syntax.SynExceptionDefn: FSharp.Compiler.Syntax.SynExceptionDefn NewSynExceptionDefn(FSharp.Compiler.Syntax.SynExceptionDefnRepr, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn], FSharp.Compiler.Text.Range)
 FSharp.Compiler.Syntax.SynExceptionDefn: FSharp.Compiler.Syntax.SynExceptionDefnRepr exnRepr
 FSharp.Compiler.Syntax.SynExceptionDefn: FSharp.Compiler.Syntax.SynExceptionDefnRepr get_exnRepr()
@@ -6267,7 +6116,6 @@ FSharp.Compiler.Syntax.SynExceptionDefn: Microsoft.FSharp.Collections.FSharpList
 FSharp.Compiler.Syntax.SynExceptionDefn: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_withKeyword()
 FSharp.Compiler.Syntax.SynExceptionDefn: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] withKeyword
 FSharp.Compiler.Syntax.SynExceptionDefn: System.String ToString()
-FSharp.Compiler.Syntax.SynExceptionDefnRepr
 FSharp.Compiler.Syntax.SynExceptionDefnRepr: FSharp.Compiler.Syntax.SynExceptionDefnRepr NewSynExceptionDefnRepr(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], FSharp.Compiler.Syntax.SynUnionCase, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident]], FSharp.Compiler.Xml.PreXmlDoc, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess], FSharp.Compiler.Text.Range)
 FSharp.Compiler.Syntax.SynExceptionDefnRepr: FSharp.Compiler.Syntax.SynUnionCase caseName
 FSharp.Compiler.Syntax.SynExceptionDefnRepr: FSharp.Compiler.Syntax.SynUnionCase get_caseName()
@@ -6286,7 +6134,6 @@ FSharp.Compiler.Syntax.SynExceptionDefnRepr: Microsoft.FSharp.Core.FSharpOption`
 FSharp.Compiler.Syntax.SynExceptionDefnRepr: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident]] get_longId()
 FSharp.Compiler.Syntax.SynExceptionDefnRepr: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident]] longId
 FSharp.Compiler.Syntax.SynExceptionDefnRepr: System.String ToString()
-FSharp.Compiler.Syntax.SynExceptionSig
 FSharp.Compiler.Syntax.SynExceptionSig: FSharp.Compiler.Syntax.SynExceptionDefnRepr exnRepr
 FSharp.Compiler.Syntax.SynExceptionSig: FSharp.Compiler.Syntax.SynExceptionDefnRepr get_exnRepr()
 FSharp.Compiler.Syntax.SynExceptionSig: FSharp.Compiler.Syntax.SynExceptionSig NewSynExceptionSig(FSharp.Compiler.Syntax.SynExceptionDefnRepr, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberSig], FSharp.Compiler.Text.Range)
@@ -6299,7 +6146,6 @@ FSharp.Compiler.Syntax.SynExceptionSig: Microsoft.FSharp.Collections.FSharpList`
 FSharp.Compiler.Syntax.SynExceptionSig: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_withKeyword()
 FSharp.Compiler.Syntax.SynExceptionSig: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] withKeyword
 FSharp.Compiler.Syntax.SynExceptionSig: System.String ToString()
-FSharp.Compiler.Syntax.SynExpr
 FSharp.Compiler.Syntax.SynExpr+AddressOf: Boolean get_isByref()
 FSharp.Compiler.Syntax.SynExpr+AddressOf: Boolean isByref
 FSharp.Compiler.Syntax.SynExpr+AddressOf: FSharp.Compiler.Syntax.SynExpr expr
@@ -7194,7 +7040,6 @@ FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Text.Range get_RangeWithoutAnyEx
 FSharp.Compiler.Syntax.SynExpr: Int32 Tag
 FSharp.Compiler.Syntax.SynExpr: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynExpr: System.String ToString()
-FSharp.Compiler.Syntax.SynExprAndBang
 FSharp.Compiler.Syntax.SynExprAndBang: Boolean get_isFromSource()
 FSharp.Compiler.Syntax.SynExprAndBang: Boolean get_isUse()
 FSharp.Compiler.Syntax.SynExprAndBang: Boolean isFromSource
@@ -7213,7 +7058,6 @@ FSharp.Compiler.Syntax.SynExprAndBang: FSharp.Compiler.Text.Range range
 FSharp.Compiler.Syntax.SynExprAndBang: Int32 Tag
 FSharp.Compiler.Syntax.SynExprAndBang: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynExprAndBang: System.String ToString()
-FSharp.Compiler.Syntax.SynExprRecordField
 FSharp.Compiler.Syntax.SynExprRecordField: FSharp.Compiler.Syntax.SynExprRecordField NewSynExprRecordField(System.Tuple`2[FSharp.Compiler.Syntax.SynLongIdent,System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynExpr], Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Text.Range,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Position]]])
 FSharp.Compiler.Syntax.SynExprRecordField: Int32 Tag
 FSharp.Compiler.Syntax.SynExprRecordField: Int32 get_Tag()
@@ -7226,7 +7070,6 @@ FSharp.Compiler.Syntax.SynExprRecordField: Microsoft.FSharp.Core.FSharpOption`1[
 FSharp.Compiler.Syntax.SynExprRecordField: System.String ToString()
 FSharp.Compiler.Syntax.SynExprRecordField: System.Tuple`2[FSharp.Compiler.Syntax.SynLongIdent,System.Boolean] fieldName
 FSharp.Compiler.Syntax.SynExprRecordField: System.Tuple`2[FSharp.Compiler.Syntax.SynLongIdent,System.Boolean] get_fieldName()
-FSharp.Compiler.Syntax.SynField
 FSharp.Compiler.Syntax.SynField: Boolean get_isMutable()
 FSharp.Compiler.Syntax.SynField: Boolean get_isStatic()
 FSharp.Compiler.Syntax.SynField: Boolean isMutable
@@ -7249,7 +7092,6 @@ FSharp.Compiler.Syntax.SynField: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Com
 FSharp.Compiler.Syntax.SynField: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] accessibility
 FSharp.Compiler.Syntax.SynField: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] get_accessibility()
 FSharp.Compiler.Syntax.SynField: System.String ToString()
-FSharp.Compiler.Syntax.SynIdent
 FSharp.Compiler.Syntax.SynIdent: FSharp.Compiler.Syntax.Ident get_ident()
 FSharp.Compiler.Syntax.SynIdent: FSharp.Compiler.Syntax.Ident ident
 FSharp.Compiler.Syntax.SynIdent: FSharp.Compiler.Syntax.SynIdent NewSynIdent(FSharp.Compiler.Syntax.Ident, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.IdentTrivia])
@@ -7258,7 +7100,6 @@ FSharp.Compiler.Syntax.SynIdent: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynIdent: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.IdentTrivia] get_trivia()
 FSharp.Compiler.Syntax.SynIdent: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.IdentTrivia] trivia
 FSharp.Compiler.Syntax.SynIdent: System.String ToString()
-FSharp.Compiler.Syntax.SynInterfaceImpl
 FSharp.Compiler.Syntax.SynInterfaceImpl: FSharp.Compiler.Syntax.SynInterfaceImpl NewSynInterfaceImpl(FSharp.Compiler.Syntax.SynType, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynBinding], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn], FSharp.Compiler.Text.Range)
 FSharp.Compiler.Syntax.SynInterfaceImpl: FSharp.Compiler.Syntax.SynType get_interfaceTy()
 FSharp.Compiler.Syntax.SynInterfaceImpl: FSharp.Compiler.Syntax.SynType interfaceTy
@@ -7273,7 +7114,6 @@ FSharp.Compiler.Syntax.SynInterfaceImpl: Microsoft.FSharp.Collections.FSharpList
 FSharp.Compiler.Syntax.SynInterfaceImpl: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_withKeyword()
 FSharp.Compiler.Syntax.SynInterfaceImpl: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] withKeyword
 FSharp.Compiler.Syntax.SynInterfaceImpl: System.String ToString()
-FSharp.Compiler.Syntax.SynInterpolatedStringPart
 FSharp.Compiler.Syntax.SynInterpolatedStringPart+FillExpr: FSharp.Compiler.Syntax.SynExpr fillExpr
 FSharp.Compiler.Syntax.SynInterpolatedStringPart+FillExpr: FSharp.Compiler.Syntax.SynExpr get_fillExpr()
 FSharp.Compiler.Syntax.SynInterpolatedStringPart+FillExpr: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] get_qualifiers()
@@ -7296,7 +7136,6 @@ FSharp.Compiler.Syntax.SynInterpolatedStringPart: FSharp.Compiler.Syntax.SynInte
 FSharp.Compiler.Syntax.SynInterpolatedStringPart: Int32 Tag
 FSharp.Compiler.Syntax.SynInterpolatedStringPart: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynInterpolatedStringPart: System.String ToString()
-FSharp.Compiler.Syntax.SynLongIdent
 FSharp.Compiler.Syntax.SynLongIdent: Boolean ThereIsAnExtraDotAtTheEnd
 FSharp.Compiler.Syntax.SynLongIdent: Boolean get_ThereIsAnExtraDotAtTheEnd()
 FSharp.Compiler.Syntax.SynLongIdent: FSharp.Compiler.Syntax.SynLongIdent NewSynLongIdent(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.IdentTrivia]])
@@ -7321,10 +7160,8 @@ FSharp.Compiler.Syntax.SynLongIdent: Microsoft.FSharp.Collections.FSharpList`1[F
 FSharp.Compiler.Syntax.SynLongIdent: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.IdentTrivia]] get_trivia()
 FSharp.Compiler.Syntax.SynLongIdent: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.IdentTrivia]] trivia
 FSharp.Compiler.Syntax.SynLongIdent: System.String ToString()
-FSharp.Compiler.Syntax.SynLongIdentHelpers
 FSharp.Compiler.Syntax.SynLongIdentHelpers: FSharp.Compiler.Syntax.SynLongIdent LongIdentWithDots(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.Range])
 FSharp.Compiler.Syntax.SynLongIdentHelpers: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident],Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.Range]] |LongIdentWithDots|(FSharp.Compiler.Syntax.SynLongIdent)
-FSharp.Compiler.Syntax.SynMatchClause
 FSharp.Compiler.Syntax.SynMatchClause: FSharp.Compiler.Syntax.DebugPointAtTarget debugPoint
 FSharp.Compiler.Syntax.SynMatchClause: FSharp.Compiler.Syntax.DebugPointAtTarget get_debugPoint()
 FSharp.Compiler.Syntax.SynMatchClause: FSharp.Compiler.Syntax.SynExpr get_resultExpr()
@@ -7345,7 +7182,6 @@ FSharp.Compiler.Syntax.SynMatchClause: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynMatchClause: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynExpr] get_whenExpr()
 FSharp.Compiler.Syntax.SynMatchClause: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynExpr] whenExpr
 FSharp.Compiler.Syntax.SynMatchClause: System.String ToString()
-FSharp.Compiler.Syntax.SynMeasure
 FSharp.Compiler.Syntax.SynMeasure+Anon: FSharp.Compiler.Text.Range get_range()
 FSharp.Compiler.Syntax.SynMeasure+Anon: FSharp.Compiler.Text.Range range
 FSharp.Compiler.Syntax.SynMeasure+Divide: FSharp.Compiler.Syntax.SynMeasure get_measure1()
@@ -7431,7 +7267,6 @@ FSharp.Compiler.Syntax.SynMeasure: FSharp.Compiler.Syntax.SynMeasure+Var
 FSharp.Compiler.Syntax.SynMeasure: Int32 Tag
 FSharp.Compiler.Syntax.SynMeasure: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynMeasure: System.String ToString()
-FSharp.Compiler.Syntax.SynMemberDefn
 FSharp.Compiler.Syntax.SynMemberDefn+AbstractSlot: FSharp.Compiler.Syntax.SynMemberFlags flags
 FSharp.Compiler.Syntax.SynMemberDefn+AbstractSlot: FSharp.Compiler.Syntax.SynMemberFlags get_flags()
 FSharp.Compiler.Syntax.SynMemberDefn+AbstractSlot: FSharp.Compiler.Syntax.SynValSig get_slotSig()
@@ -7598,7 +7433,6 @@ FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Text.Range get_Range()
 FSharp.Compiler.Syntax.SynMemberDefn: Int32 Tag
 FSharp.Compiler.Syntax.SynMemberDefn: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynMemberDefn: System.String ToString()
-FSharp.Compiler.Syntax.SynMemberFlags
 FSharp.Compiler.Syntax.SynMemberFlags: Boolean Equals(System.Object)
 FSharp.Compiler.Syntax.SynMemberFlags: Boolean GetterOrSetterIsCompilerGenerated
 FSharp.Compiler.Syntax.SynMemberFlags: Boolean IsDispatchSlot
@@ -7615,7 +7449,6 @@ FSharp.Compiler.Syntax.SynMemberFlags: FSharp.Compiler.Syntax.SynMemberKind get_
 FSharp.Compiler.Syntax.SynMemberFlags: Int32 GetHashCode()
 FSharp.Compiler.Syntax.SynMemberFlags: System.String ToString()
 FSharp.Compiler.Syntax.SynMemberFlags: Void .ctor(Boolean, Boolean, Boolean, Boolean, Boolean, FSharp.Compiler.Syntax.SynMemberKind)
-FSharp.Compiler.Syntax.SynMemberKind
 FSharp.Compiler.Syntax.SynMemberKind+Tags: Int32 ClassConstructor
 FSharp.Compiler.Syntax.SynMemberKind+Tags: Int32 Constructor
 FSharp.Compiler.Syntax.SynMemberKind+Tags: Int32 Member
@@ -7655,7 +7488,6 @@ FSharp.Compiler.Syntax.SynMemberKind: Int32 GetHashCode(System.Collections.IEqua
 FSharp.Compiler.Syntax.SynMemberKind: Int32 Tag
 FSharp.Compiler.Syntax.SynMemberKind: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynMemberKind: System.String ToString()
-FSharp.Compiler.Syntax.SynMemberSig
 FSharp.Compiler.Syntax.SynMemberSig+Inherit: FSharp.Compiler.Syntax.SynType get_inheritedType()
 FSharp.Compiler.Syntax.SynMemberSig+Inherit: FSharp.Compiler.Syntax.SynType inheritedType
 FSharp.Compiler.Syntax.SynMemberSig+Inherit: FSharp.Compiler.Text.Range get_range()
@@ -7711,7 +7543,6 @@ FSharp.Compiler.Syntax.SynMemberSig: FSharp.Compiler.Text.Range get_Range()
 FSharp.Compiler.Syntax.SynMemberSig: Int32 Tag
 FSharp.Compiler.Syntax.SynMemberSig: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynMemberSig: System.String ToString()
-FSharp.Compiler.Syntax.SynModuleDecl
 FSharp.Compiler.Syntax.SynModuleDecl+Attributes: FSharp.Compiler.Text.Range get_range()
 FSharp.Compiler.Syntax.SynModuleDecl+Attributes: FSharp.Compiler.Text.Range range
 FSharp.Compiler.Syntax.SynModuleDecl+Attributes: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] attributes
@@ -7818,7 +7649,6 @@ FSharp.Compiler.Syntax.SynModuleDecl: FSharp.Compiler.Text.Range get_Range()
 FSharp.Compiler.Syntax.SynModuleDecl: Int32 Tag
 FSharp.Compiler.Syntax.SynModuleDecl: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynModuleDecl: System.String ToString()
-FSharp.Compiler.Syntax.SynModuleOrNamespace
 FSharp.Compiler.Syntax.SynModuleOrNamespace: Boolean get_isRecursive()
 FSharp.Compiler.Syntax.SynModuleOrNamespace: Boolean isRecursive
 FSharp.Compiler.Syntax.SynModuleOrNamespace: FSharp.Compiler.Syntax.SynModuleOrNamespace NewSynModuleOrNamespace(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident], Boolean, FSharp.Compiler.Syntax.SynModuleOrNamespaceKind, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleDecl], FSharp.Compiler.Xml.PreXmlDoc, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess], FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceTrivia)
@@ -7843,7 +7673,6 @@ FSharp.Compiler.Syntax.SynModuleOrNamespace: Microsoft.FSharp.Collections.FSharp
 FSharp.Compiler.Syntax.SynModuleOrNamespace: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] accessibility
 FSharp.Compiler.Syntax.SynModuleOrNamespace: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] get_accessibility()
 FSharp.Compiler.Syntax.SynModuleOrNamespace: System.String ToString()
-FSharp.Compiler.Syntax.SynModuleOrNamespaceKind
 FSharp.Compiler.Syntax.SynModuleOrNamespaceKind+Tags: Int32 AnonModule
 FSharp.Compiler.Syntax.SynModuleOrNamespaceKind+Tags: Int32 DeclaredNamespace
 FSharp.Compiler.Syntax.SynModuleOrNamespaceKind+Tags: Int32 GlobalNamespace
@@ -7878,7 +7707,6 @@ FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: Int32 GetHashCode(System.Collec
 FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: Int32 Tag
 FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: System.String ToString()
-FSharp.Compiler.Syntax.SynModuleOrNamespaceSig
 FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: Boolean get_isRecursive()
 FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: Boolean isRecursive
 FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: FSharp.Compiler.Syntax.SynModuleOrNamespaceKind get_kind()
@@ -7903,7 +7731,6 @@ FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: Microsoft.FSharp.Collections.FSh
 FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] accessibility
 FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] get_accessibility()
 FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: System.String ToString()
-FSharp.Compiler.Syntax.SynModuleSigDecl
 FSharp.Compiler.Syntax.SynModuleSigDecl+Exception: FSharp.Compiler.Syntax.SynExceptionSig exnSig
 FSharp.Compiler.Syntax.SynModuleSigDecl+Exception: FSharp.Compiler.Syntax.SynExceptionSig get_exnSig()
 FSharp.Compiler.Syntax.SynModuleSigDecl+Exception: FSharp.Compiler.Text.Range get_range()
@@ -7988,7 +7815,6 @@ FSharp.Compiler.Syntax.SynModuleSigDecl: FSharp.Compiler.Text.Range get_Range()
 FSharp.Compiler.Syntax.SynModuleSigDecl: Int32 Tag
 FSharp.Compiler.Syntax.SynModuleSigDecl: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynModuleSigDecl: System.String ToString()
-FSharp.Compiler.Syntax.SynOpenDeclTarget
 FSharp.Compiler.Syntax.SynOpenDeclTarget+ModuleOrNamespace: FSharp.Compiler.Syntax.SynLongIdent get_longId()
 FSharp.Compiler.Syntax.SynOpenDeclTarget+ModuleOrNamespace: FSharp.Compiler.Syntax.SynLongIdent longId
 FSharp.Compiler.Syntax.SynOpenDeclTarget+ModuleOrNamespace: FSharp.Compiler.Text.Range get_range()
@@ -8013,7 +7839,6 @@ FSharp.Compiler.Syntax.SynOpenDeclTarget: FSharp.Compiler.Text.Range get_Range()
 FSharp.Compiler.Syntax.SynOpenDeclTarget: Int32 Tag
 FSharp.Compiler.Syntax.SynOpenDeclTarget: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynOpenDeclTarget: System.String ToString()
-FSharp.Compiler.Syntax.SynPat
 FSharp.Compiler.Syntax.SynPat+Ands: FSharp.Compiler.Text.Range get_range()
 FSharp.Compiler.Syntax.SynPat+Ands: FSharp.Compiler.Text.Range range
 FSharp.Compiler.Syntax.SynPat+Ands: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynPat] get_pats()
@@ -8243,7 +8068,6 @@ FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Text.Range get_Range()
 FSharp.Compiler.Syntax.SynPat: Int32 Tag
 FSharp.Compiler.Syntax.SynPat: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynPat: System.String ToString()
-FSharp.Compiler.Syntax.SynRationalConst
 FSharp.Compiler.Syntax.SynRationalConst+Integer: Int32 get_value()
 FSharp.Compiler.Syntax.SynRationalConst+Integer: Int32 value
 FSharp.Compiler.Syntax.SynRationalConst+Negate: FSharp.Compiler.Syntax.SynRationalConst Item
@@ -8273,7 +8097,6 @@ FSharp.Compiler.Syntax.SynRationalConst: FSharp.Compiler.Syntax.SynRationalConst
 FSharp.Compiler.Syntax.SynRationalConst: Int32 Tag
 FSharp.Compiler.Syntax.SynRationalConst: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynRationalConst: System.String ToString()
-FSharp.Compiler.Syntax.SynReturnInfo
 FSharp.Compiler.Syntax.SynReturnInfo: FSharp.Compiler.Syntax.SynReturnInfo NewSynReturnInfo(System.Tuple`2[FSharp.Compiler.Syntax.SynType,FSharp.Compiler.Syntax.SynArgInfo], FSharp.Compiler.Text.Range)
 FSharp.Compiler.Syntax.SynReturnInfo: FSharp.Compiler.Text.Range get_range()
 FSharp.Compiler.Syntax.SynReturnInfo: FSharp.Compiler.Text.Range range
@@ -8282,7 +8105,6 @@ FSharp.Compiler.Syntax.SynReturnInfo: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynReturnInfo: System.String ToString()
 FSharp.Compiler.Syntax.SynReturnInfo: System.Tuple`2[FSharp.Compiler.Syntax.SynType,FSharp.Compiler.Syntax.SynArgInfo] get_returnType()
 FSharp.Compiler.Syntax.SynReturnInfo: System.Tuple`2[FSharp.Compiler.Syntax.SynType,FSharp.Compiler.Syntax.SynArgInfo] returnType
-FSharp.Compiler.Syntax.SynSimplePat
 FSharp.Compiler.Syntax.SynSimplePat+Attrib: FSharp.Compiler.Syntax.SynSimplePat get_pat()
 FSharp.Compiler.Syntax.SynSimplePat+Attrib: FSharp.Compiler.Syntax.SynSimplePat pat
 FSharp.Compiler.Syntax.SynSimplePat+Attrib: FSharp.Compiler.Text.Range get_range()
@@ -8328,7 +8150,6 @@ FSharp.Compiler.Syntax.SynSimplePat: FSharp.Compiler.Text.Range get_Range()
 FSharp.Compiler.Syntax.SynSimplePat: Int32 Tag
 FSharp.Compiler.Syntax.SynSimplePat: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynSimplePat: System.String ToString()
-FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo
 FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo+Decided: FSharp.Compiler.Syntax.Ident Item
 FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo+Decided: FSharp.Compiler.Syntax.Ident get_Item()
 FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo+Tags: Int32 Decided
@@ -8347,7 +8168,6 @@ FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo: FSharp.Compiler.Syntax.Syn
 FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo: Int32 Tag
 FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo: System.String ToString()
-FSharp.Compiler.Syntax.SynSimplePats
 FSharp.Compiler.Syntax.SynSimplePats+SimplePats: FSharp.Compiler.Text.Range get_range()
 FSharp.Compiler.Syntax.SynSimplePats+SimplePats: FSharp.Compiler.Text.Range range
 FSharp.Compiler.Syntax.SynSimplePats+SimplePats: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynSimplePat] get_pats()
@@ -8374,7 +8194,6 @@ FSharp.Compiler.Syntax.SynSimplePats: FSharp.Compiler.Text.Range get_Range()
 FSharp.Compiler.Syntax.SynSimplePats: Int32 Tag
 FSharp.Compiler.Syntax.SynSimplePats: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynSimplePats: System.String ToString()
-FSharp.Compiler.Syntax.SynStaticOptimizationConstraint
 FSharp.Compiler.Syntax.SynStaticOptimizationConstraint+Tags: Int32 WhenTyparIsStruct
 FSharp.Compiler.Syntax.SynStaticOptimizationConstraint+Tags: Int32 WhenTyparTyconEqualsTycon
 FSharp.Compiler.Syntax.SynStaticOptimizationConstraint+WhenTyparIsStruct: FSharp.Compiler.Syntax.SynTypar get_typar()
@@ -8399,7 +8218,6 @@ FSharp.Compiler.Syntax.SynStaticOptimizationConstraint: FSharp.Compiler.Syntax.S
 FSharp.Compiler.Syntax.SynStaticOptimizationConstraint: Int32 Tag
 FSharp.Compiler.Syntax.SynStaticOptimizationConstraint: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynStaticOptimizationConstraint: System.String ToString()
-FSharp.Compiler.Syntax.SynStringKind
 FSharp.Compiler.Syntax.SynStringKind+Tags: Int32 Regular
 FSharp.Compiler.Syntax.SynStringKind+Tags: Int32 TripleQuote
 FSharp.Compiler.Syntax.SynStringKind+Tags: Int32 Verbatim
@@ -8427,7 +8245,6 @@ FSharp.Compiler.Syntax.SynStringKind: Int32 GetHashCode(System.Collections.IEqua
 FSharp.Compiler.Syntax.SynStringKind: Int32 Tag
 FSharp.Compiler.Syntax.SynStringKind: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynStringKind: System.String ToString()
-FSharp.Compiler.Syntax.SynTupleTypeSegment
 FSharp.Compiler.Syntax.SynTupleTypeSegment+Slash: FSharp.Compiler.Text.Range get_range()
 FSharp.Compiler.Syntax.SynTupleTypeSegment+Slash: FSharp.Compiler.Text.Range range
 FSharp.Compiler.Syntax.SynTupleTypeSegment+Star: FSharp.Compiler.Text.Range get_range()
@@ -8455,7 +8272,6 @@ FSharp.Compiler.Syntax.SynTupleTypeSegment: FSharp.Compiler.Text.Range get_Range
 FSharp.Compiler.Syntax.SynTupleTypeSegment: Int32 Tag
 FSharp.Compiler.Syntax.SynTupleTypeSegment: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynTupleTypeSegment: System.String ToString()
-FSharp.Compiler.Syntax.SynTypar
 FSharp.Compiler.Syntax.SynTypar: Boolean get_isCompGen()
 FSharp.Compiler.Syntax.SynTypar: Boolean isCompGen
 FSharp.Compiler.Syntax.SynTypar: FSharp.Compiler.Syntax.Ident get_ident()
@@ -8468,7 +8284,6 @@ FSharp.Compiler.Syntax.SynTypar: FSharp.Compiler.Text.Range get_Range()
 FSharp.Compiler.Syntax.SynTypar: Int32 Tag
 FSharp.Compiler.Syntax.SynTypar: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynTypar: System.String ToString()
-FSharp.Compiler.Syntax.SynTyparDecl
 FSharp.Compiler.Syntax.SynTyparDecl: FSharp.Compiler.Syntax.SynTypar Item2
 FSharp.Compiler.Syntax.SynTyparDecl: FSharp.Compiler.Syntax.SynTypar get_Item2()
 FSharp.Compiler.Syntax.SynTyparDecl: FSharp.Compiler.Syntax.SynTyparDecl NewSynTyparDecl(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], FSharp.Compiler.Syntax.SynTypar)
@@ -8477,7 +8292,6 @@ FSharp.Compiler.Syntax.SynTyparDecl: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynTyparDecl: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] attributes
 FSharp.Compiler.Syntax.SynTyparDecl: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] get_attributes()
 FSharp.Compiler.Syntax.SynTyparDecl: System.String ToString()
-FSharp.Compiler.Syntax.SynTyparDecls
 FSharp.Compiler.Syntax.SynTyparDecls+PostfixList: FSharp.Compiler.Text.Range get_range()
 FSharp.Compiler.Syntax.SynTyparDecls+PostfixList: FSharp.Compiler.Text.Range range
 FSharp.Compiler.Syntax.SynTyparDecls+PostfixList: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTyparDecl] decls
@@ -8517,7 +8331,6 @@ FSharp.Compiler.Syntax.SynTyparDecls: Microsoft.FSharp.Collections.FSharpList`1[
 FSharp.Compiler.Syntax.SynTyparDecls: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTypeConstraint] Constraints
 FSharp.Compiler.Syntax.SynTyparDecls: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTypeConstraint] get_Constraints()
 FSharp.Compiler.Syntax.SynTyparDecls: System.String ToString()
-FSharp.Compiler.Syntax.SynType
 FSharp.Compiler.Syntax.SynType+Anon: FSharp.Compiler.Text.Range get_range()
 FSharp.Compiler.Syntax.SynType+Anon: FSharp.Compiler.Text.Range range
 FSharp.Compiler.Syntax.SynType+AnonRecd: Boolean get_isStruct()
@@ -8728,7 +8541,6 @@ FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Text.Range get_Range()
 FSharp.Compiler.Syntax.SynType: Int32 Tag
 FSharp.Compiler.Syntax.SynType: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynType: System.String ToString()
-FSharp.Compiler.Syntax.SynTypeConstraint
 FSharp.Compiler.Syntax.SynTypeConstraint+Tags: Int32 WhereSelfConstrained
 FSharp.Compiler.Syntax.SynTypeConstraint+Tags: Int32 WhereTyparDefaultsToType
 FSharp.Compiler.Syntax.SynTypeConstraint+Tags: Int32 WhereTyparIsComparable
@@ -8853,7 +8665,6 @@ FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Text.Range get_Range()
 FSharp.Compiler.Syntax.SynTypeConstraint: Int32 Tag
 FSharp.Compiler.Syntax.SynTypeConstraint: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynTypeConstraint: System.String ToString()
-FSharp.Compiler.Syntax.SynTypeDefn
 FSharp.Compiler.Syntax.SynTypeDefn: FSharp.Compiler.Syntax.SynComponentInfo get_typeInfo()
 FSharp.Compiler.Syntax.SynTypeDefn: FSharp.Compiler.Syntax.SynComponentInfo typeInfo
 FSharp.Compiler.Syntax.SynTypeDefn: FSharp.Compiler.Syntax.SynTypeDefn NewSynTypeDefn(FSharp.Compiler.Syntax.SynComponentInfo, FSharp.Compiler.Syntax.SynTypeDefnRepr, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynMemberDefn], FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynTypeDefnTrivia)
@@ -8872,7 +8683,6 @@ FSharp.Compiler.Syntax.SynTypeDefn: Microsoft.FSharp.Collections.FSharpList`1[FS
 FSharp.Compiler.Syntax.SynTypeDefn: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynMemberDefn] get_implicitConstructor()
 FSharp.Compiler.Syntax.SynTypeDefn: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynMemberDefn] implicitConstructor
 FSharp.Compiler.Syntax.SynTypeDefn: System.String ToString()
-FSharp.Compiler.Syntax.SynTypeDefnKind
 FSharp.Compiler.Syntax.SynTypeDefnKind+Augmentation: FSharp.Compiler.Text.Range get_withKeyword()
 FSharp.Compiler.Syntax.SynTypeDefnKind+Augmentation: FSharp.Compiler.Text.Range withKeyword
 FSharp.Compiler.Syntax.SynTypeDefnKind+Delegate: FSharp.Compiler.Syntax.SynType get_signature()
@@ -8938,7 +8748,6 @@ FSharp.Compiler.Syntax.SynTypeDefnKind: FSharp.Compiler.Syntax.SynTypeDefnKind+T
 FSharp.Compiler.Syntax.SynTypeDefnKind: Int32 Tag
 FSharp.Compiler.Syntax.SynTypeDefnKind: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynTypeDefnKind: System.String ToString()
-FSharp.Compiler.Syntax.SynTypeDefnRepr
 FSharp.Compiler.Syntax.SynTypeDefnRepr+Exception: FSharp.Compiler.Syntax.SynExceptionDefnRepr exnRepr
 FSharp.Compiler.Syntax.SynTypeDefnRepr+Exception: FSharp.Compiler.Syntax.SynExceptionDefnRepr get_exnRepr()
 FSharp.Compiler.Syntax.SynTypeDefnRepr+ObjectModel: FSharp.Compiler.Syntax.SynTypeDefnKind get_kind()
@@ -8972,7 +8781,6 @@ FSharp.Compiler.Syntax.SynTypeDefnRepr: FSharp.Compiler.Text.Range get_Range()
 FSharp.Compiler.Syntax.SynTypeDefnRepr: Int32 Tag
 FSharp.Compiler.Syntax.SynTypeDefnRepr: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynTypeDefnRepr: System.String ToString()
-FSharp.Compiler.Syntax.SynTypeDefnSig
 FSharp.Compiler.Syntax.SynTypeDefnSig: FSharp.Compiler.Syntax.SynComponentInfo get_typeInfo()
 FSharp.Compiler.Syntax.SynTypeDefnSig: FSharp.Compiler.Syntax.SynComponentInfo typeInfo
 FSharp.Compiler.Syntax.SynTypeDefnSig: FSharp.Compiler.Syntax.SynTypeDefnSig NewSynTypeDefnSig(FSharp.Compiler.Syntax.SynComponentInfo, FSharp.Compiler.Syntax.SynTypeDefnSigRepr, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberSig], FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynTypeDefnSigTrivia)
@@ -8989,7 +8797,6 @@ FSharp.Compiler.Syntax.SynTypeDefnSig: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynTypeDefnSig: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberSig] get_members()
 FSharp.Compiler.Syntax.SynTypeDefnSig: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberSig] members
 FSharp.Compiler.Syntax.SynTypeDefnSig: System.String ToString()
-FSharp.Compiler.Syntax.SynTypeDefnSigRepr
 FSharp.Compiler.Syntax.SynTypeDefnSigRepr+Exception: FSharp.Compiler.Syntax.SynExceptionDefnRepr get_repr()
 FSharp.Compiler.Syntax.SynTypeDefnSigRepr+Exception: FSharp.Compiler.Syntax.SynExceptionDefnRepr repr
 FSharp.Compiler.Syntax.SynTypeDefnSigRepr+ObjectModel: FSharp.Compiler.Syntax.SynTypeDefnKind get_kind()
@@ -9023,7 +8830,6 @@ FSharp.Compiler.Syntax.SynTypeDefnSigRepr: FSharp.Compiler.Text.Range get_Range(
 FSharp.Compiler.Syntax.SynTypeDefnSigRepr: Int32 Tag
 FSharp.Compiler.Syntax.SynTypeDefnSigRepr: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynTypeDefnSigRepr: System.String ToString()
-FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr
 FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Enum: FSharp.Compiler.Text.Range get_range()
 FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Enum: FSharp.Compiler.Text.Range range
 FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Enum: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynEnumCase] cases
@@ -9116,7 +8922,6 @@ FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: FSharp.Compiler.Text.Range get_Ran
 FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: Int32 Tag
 FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: System.String ToString()
-FSharp.Compiler.Syntax.SynUnionCase
 FSharp.Compiler.Syntax.SynUnionCase: FSharp.Compiler.Syntax.SynIdent get_ident()
 FSharp.Compiler.Syntax.SynUnionCase: FSharp.Compiler.Syntax.SynIdent ident
 FSharp.Compiler.Syntax.SynUnionCase: FSharp.Compiler.Syntax.SynUnionCase NewSynUnionCase(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], FSharp.Compiler.Syntax.SynIdent, FSharp.Compiler.Syntax.SynUnionCaseKind, FSharp.Compiler.Xml.PreXmlDoc, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess], FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynUnionCaseTrivia)
@@ -9137,7 +8942,6 @@ FSharp.Compiler.Syntax.SynUnionCase: Microsoft.FSharp.Collections.FSharpList`1[F
 FSharp.Compiler.Syntax.SynUnionCase: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] accessibility
 FSharp.Compiler.Syntax.SynUnionCase: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] get_accessibility()
 FSharp.Compiler.Syntax.SynUnionCase: System.String ToString()
-FSharp.Compiler.Syntax.SynUnionCaseKind
 FSharp.Compiler.Syntax.SynUnionCaseKind+Fields: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynField] cases
 FSharp.Compiler.Syntax.SynUnionCaseKind+Fields: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynField] get_cases()
 FSharp.Compiler.Syntax.SynUnionCaseKind+FullType: FSharp.Compiler.Syntax.SynType fullType
@@ -9158,7 +8962,6 @@ FSharp.Compiler.Syntax.SynUnionCaseKind: FSharp.Compiler.Syntax.SynUnionCaseKind
 FSharp.Compiler.Syntax.SynUnionCaseKind: Int32 Tag
 FSharp.Compiler.Syntax.SynUnionCaseKind: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynUnionCaseKind: System.String ToString()
-FSharp.Compiler.Syntax.SynValData
 FSharp.Compiler.Syntax.SynValData: FSharp.Compiler.Syntax.SynValData NewSynValData(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynMemberFlags], FSharp.Compiler.Syntax.SynValInfo, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident])
 FSharp.Compiler.Syntax.SynValData: FSharp.Compiler.Syntax.SynValInfo SynValInfo
 FSharp.Compiler.Syntax.SynValData: FSharp.Compiler.Syntax.SynValInfo get_SynValInfo()
@@ -9171,7 +8974,6 @@ FSharp.Compiler.Syntax.SynValData: Microsoft.FSharp.Core.FSharpOption`1[FSharp.C
 FSharp.Compiler.Syntax.SynValData: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynMemberFlags] get_memberFlags()
 FSharp.Compiler.Syntax.SynValData: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynMemberFlags] memberFlags
 FSharp.Compiler.Syntax.SynValData: System.String ToString()
-FSharp.Compiler.Syntax.SynValInfo
 FSharp.Compiler.Syntax.SynValInfo: FSharp.Compiler.Syntax.SynArgInfo get_returnInfo()
 FSharp.Compiler.Syntax.SynValInfo: FSharp.Compiler.Syntax.SynArgInfo returnInfo
 FSharp.Compiler.Syntax.SynValInfo: FSharp.Compiler.Syntax.SynValInfo NewSynValInfo(Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynArgInfo]], FSharp.Compiler.Syntax.SynArgInfo)
@@ -9184,7 +8986,6 @@ FSharp.Compiler.Syntax.SynValInfo: Microsoft.FSharp.Collections.FSharpList`1[Mic
 FSharp.Compiler.Syntax.SynValInfo: Microsoft.FSharp.Collections.FSharpList`1[System.String] ArgNames
 FSharp.Compiler.Syntax.SynValInfo: Microsoft.FSharp.Collections.FSharpList`1[System.String] get_ArgNames()
 FSharp.Compiler.Syntax.SynValInfo: System.String ToString()
-FSharp.Compiler.Syntax.SynValSig
 FSharp.Compiler.Syntax.SynValSig: Boolean get_isInline()
 FSharp.Compiler.Syntax.SynValSig: Boolean get_isMutable()
 FSharp.Compiler.Syntax.SynValSig: Boolean isInline
@@ -9219,7 +9020,6 @@ FSharp.Compiler.Syntax.SynValSig: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Co
 FSharp.Compiler.Syntax.SynValSig: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynExpr] get_synExpr()
 FSharp.Compiler.Syntax.SynValSig: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynExpr] synExpr
 FSharp.Compiler.Syntax.SynValSig: System.String ToString()
-FSharp.Compiler.Syntax.SynValTyparDecls
 FSharp.Compiler.Syntax.SynValTyparDecls: Boolean canInfer
 FSharp.Compiler.Syntax.SynValTyparDecls: Boolean get_canInfer()
 FSharp.Compiler.Syntax.SynValTyparDecls: FSharp.Compiler.Syntax.SynValTyparDecls NewSynValTyparDecls(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynTyparDecls], Boolean)
@@ -9228,7 +9028,6 @@ FSharp.Compiler.Syntax.SynValTyparDecls: Int32 get_Tag()
 FSharp.Compiler.Syntax.SynValTyparDecls: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynTyparDecls] get_typars()
 FSharp.Compiler.Syntax.SynValTyparDecls: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynTyparDecls] typars
 FSharp.Compiler.Syntax.SynValTyparDecls: System.String ToString()
-FSharp.Compiler.Syntax.SyntaxNode
 FSharp.Compiler.Syntax.SyntaxNode+SynBinding: FSharp.Compiler.Syntax.SynBinding Item
 FSharp.Compiler.Syntax.SyntaxNode+SynBinding: FSharp.Compiler.Syntax.SynBinding get_Item()
 FSharp.Compiler.Syntax.SyntaxNode+SynExpr: FSharp.Compiler.Syntax.SynExpr Item
@@ -9296,9 +9095,7 @@ FSharp.Compiler.Syntax.SyntaxNode: FSharp.Compiler.Syntax.SyntaxNode+Tags
 FSharp.Compiler.Syntax.SyntaxNode: Int32 Tag
 FSharp.Compiler.Syntax.SyntaxNode: Int32 get_Tag()
 FSharp.Compiler.Syntax.SyntaxNode: System.String ToString()
-FSharp.Compiler.Syntax.SyntaxTraversal
 FSharp.Compiler.Syntax.SyntaxTraversal: Microsoft.FSharp.Core.FSharpOption`1[T] Traverse[T](FSharp.Compiler.Text.Position, FSharp.Compiler.Syntax.ParsedInput, FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T])
-FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]
 FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitBinding(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.Syntax.SynBinding,Microsoft.FSharp.Core.FSharpOption`1[T]], FSharp.Compiler.Syntax.SynBinding)
 FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitComponentInfo(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], FSharp.Compiler.Syntax.SynComponentInfo)
 FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitEnumDefn(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynEnumCase], FSharp.Compiler.Text.Range)
@@ -9319,7 +9116,6 @@ FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOptio
 FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitTypeAbbrev(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range)
 FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitUnionDefn(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynUnionCase], FSharp.Compiler.Text.Range)
 FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Void .ctor()
-FSharp.Compiler.Syntax.TyparStaticReq
 FSharp.Compiler.Syntax.TyparStaticReq+Tags: Int32 HeadType
 FSharp.Compiler.Syntax.TyparStaticReq+Tags: Int32 None
 FSharp.Compiler.Syntax.TyparStaticReq: Boolean Equals(FSharp.Compiler.Syntax.TyparStaticReq)
@@ -9342,7 +9138,6 @@ FSharp.Compiler.Syntax.TyparStaticReq: Int32 GetHashCode(System.Collections.IEqu
 FSharp.Compiler.Syntax.TyparStaticReq: Int32 Tag
 FSharp.Compiler.Syntax.TyparStaticReq: Int32 get_Tag()
 FSharp.Compiler.Syntax.TyparStaticReq: System.String ToString()
-FSharp.Compiler.SyntaxTrivia.CommentTrivia
 FSharp.Compiler.SyntaxTrivia.CommentTrivia+BlockComment: FSharp.Compiler.Text.Range get_range()
 FSharp.Compiler.SyntaxTrivia.CommentTrivia+BlockComment: FSharp.Compiler.Text.Range range
 FSharp.Compiler.SyntaxTrivia.CommentTrivia+LineComment: FSharp.Compiler.Text.Range get_range()
@@ -9361,7 +9156,6 @@ FSharp.Compiler.SyntaxTrivia.CommentTrivia: FSharp.Compiler.SyntaxTrivia.Comment
 FSharp.Compiler.SyntaxTrivia.CommentTrivia: Int32 Tag
 FSharp.Compiler.SyntaxTrivia.CommentTrivia: Int32 get_Tag()
 FSharp.Compiler.SyntaxTrivia.CommentTrivia: System.String ToString()
-FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia
 FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia+Else: FSharp.Compiler.Text.Range get_range()
 FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia+Else: FSharp.Compiler.Text.Range range
 FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia+EndIf: FSharp.Compiler.Text.Range get_range()
@@ -9389,7 +9183,6 @@ FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia: FSharp.Compiler.SyntaxT
 FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia: Int32 Tag
 FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia: Int32 get_Tag()
 FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia: System.String ToString()
-FSharp.Compiler.SyntaxTrivia.GetSetKeywords
 FSharp.Compiler.SyntaxTrivia.GetSetKeywords+Get: FSharp.Compiler.Text.Range Item
 FSharp.Compiler.SyntaxTrivia.GetSetKeywords+Get: FSharp.Compiler.Text.Range get_Item()
 FSharp.Compiler.SyntaxTrivia.GetSetKeywords+GetSet: FSharp.Compiler.Text.Range get
@@ -9419,7 +9212,6 @@ FSharp.Compiler.SyntaxTrivia.GetSetKeywords: FSharp.Compiler.Text.Range get_Rang
 FSharp.Compiler.SyntaxTrivia.GetSetKeywords: Int32 Tag
 FSharp.Compiler.SyntaxTrivia.GetSetKeywords: Int32 get_Tag()
 FSharp.Compiler.SyntaxTrivia.GetSetKeywords: System.String ToString()
-FSharp.Compiler.SyntaxTrivia.IdentTrivia
 FSharp.Compiler.SyntaxTrivia.IdentTrivia+HasParenthesis: FSharp.Compiler.Text.Range get_leftParenRange()
 FSharp.Compiler.SyntaxTrivia.IdentTrivia+HasParenthesis: FSharp.Compiler.Text.Range get_rightParenRange()
 FSharp.Compiler.SyntaxTrivia.IdentTrivia+HasParenthesis: FSharp.Compiler.Text.Range leftParenRange
@@ -9451,7 +9243,6 @@ FSharp.Compiler.SyntaxTrivia.IdentTrivia: FSharp.Compiler.SyntaxTrivia.IdentTriv
 FSharp.Compiler.SyntaxTrivia.IdentTrivia: Int32 Tag
 FSharp.Compiler.SyntaxTrivia.IdentTrivia: Int32 get_Tag()
 FSharp.Compiler.SyntaxTrivia.IdentTrivia: System.String ToString()
-FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression
 FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression+And: FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression Item1
 FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression+And: FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression Item2
 FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression+And: FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression get_Item1()
@@ -9488,54 +9279,48 @@ FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression: FSharp.Compiler.SyntaxTrivia
 FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression: Int32 Tag
 FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression: Int32 get_Tag()
 FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression: System.String ToString()
-FSharp.Compiler.SyntaxTrivia.ParsedImplFileInputTrivia
 FSharp.Compiler.SyntaxTrivia.ParsedImplFileInputTrivia: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.CommentTrivia] CodeComments
 FSharp.Compiler.SyntaxTrivia.ParsedImplFileInputTrivia: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.CommentTrivia] get_CodeComments()
 FSharp.Compiler.SyntaxTrivia.ParsedImplFileInputTrivia: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia] ConditionalDirectives
 FSharp.Compiler.SyntaxTrivia.ParsedImplFileInputTrivia: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia] get_ConditionalDirectives()
 FSharp.Compiler.SyntaxTrivia.ParsedImplFileInputTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.ParsedImplFileInputTrivia: Void .ctor(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.CommentTrivia])
-FSharp.Compiler.SyntaxTrivia.ParsedSigFileInputTrivia
 FSharp.Compiler.SyntaxTrivia.ParsedSigFileInputTrivia: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.CommentTrivia] CodeComments
 FSharp.Compiler.SyntaxTrivia.ParsedSigFileInputTrivia: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.CommentTrivia] get_CodeComments()
 FSharp.Compiler.SyntaxTrivia.ParsedSigFileInputTrivia: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia] ConditionalDirectives
 FSharp.Compiler.SyntaxTrivia.ParsedSigFileInputTrivia: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia] get_ConditionalDirectives()
 FSharp.Compiler.SyntaxTrivia.ParsedSigFileInputTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.ParsedSigFileInputTrivia: Void .ctor(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.CommentTrivia])
-FSharp.Compiler.SyntaxTrivia.SynArgPatsNamePatPairsTrivia
 FSharp.Compiler.SyntaxTrivia.SynArgPatsNamePatPairsTrivia: FSharp.Compiler.Text.Range ParenRange
 FSharp.Compiler.SyntaxTrivia.SynArgPatsNamePatPairsTrivia: FSharp.Compiler.Text.Range get_ParenRange()
 FSharp.Compiler.SyntaxTrivia.SynArgPatsNamePatPairsTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynArgPatsNamePatPairsTrivia: Void .ctor(FSharp.Compiler.Text.Range)
-FSharp.Compiler.SyntaxTrivia.SynBindingReturnInfoTrivia
 FSharp.Compiler.SyntaxTrivia.SynBindingReturnInfoTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] ColonRange
 FSharp.Compiler.SyntaxTrivia.SynBindingReturnInfoTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_ColonRange()
 FSharp.Compiler.SyntaxTrivia.SynBindingReturnInfoTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynBindingReturnInfoTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
-FSharp.Compiler.SyntaxTrivia.SynBindingTrivia
 FSharp.Compiler.SyntaxTrivia.SynBindingTrivia: FSharp.Compiler.SyntaxTrivia.SynBindingTrivia Zero
 FSharp.Compiler.SyntaxTrivia.SynBindingTrivia: FSharp.Compiler.SyntaxTrivia.SynBindingTrivia get_Zero()
 FSharp.Compiler.SyntaxTrivia.SynBindingTrivia: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword LeadingKeyword
 FSharp.Compiler.SyntaxTrivia.SynBindingTrivia: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword get_LeadingKeyword()
 FSharp.Compiler.SyntaxTrivia.SynBindingTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] EqualsRange
+FSharp.Compiler.SyntaxTrivia.SynBindingTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] InlineKeyword
 FSharp.Compiler.SyntaxTrivia.SynBindingTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_EqualsRange()
+FSharp.Compiler.SyntaxTrivia.SynBindingTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_InlineKeyword()
 FSharp.Compiler.SyntaxTrivia.SynBindingTrivia: System.String ToString()
-FSharp.Compiler.SyntaxTrivia.SynBindingTrivia: Void .ctor(FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
-FSharp.Compiler.SyntaxTrivia.SynEnumCaseTrivia
+FSharp.Compiler.SyntaxTrivia.SynBindingTrivia: Void .ctor(FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
 FSharp.Compiler.SyntaxTrivia.SynEnumCaseTrivia: FSharp.Compiler.Text.Range EqualsRange
 FSharp.Compiler.SyntaxTrivia.SynEnumCaseTrivia: FSharp.Compiler.Text.Range get_EqualsRange()
 FSharp.Compiler.SyntaxTrivia.SynEnumCaseTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] BarRange
 FSharp.Compiler.SyntaxTrivia.SynEnumCaseTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_BarRange()
 FSharp.Compiler.SyntaxTrivia.SynEnumCaseTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynEnumCaseTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], FSharp.Compiler.Text.Range)
-FSharp.Compiler.SyntaxTrivia.SynExprAndBangTrivia
 FSharp.Compiler.SyntaxTrivia.SynExprAndBangTrivia: FSharp.Compiler.Text.Range EqualsRange
 FSharp.Compiler.SyntaxTrivia.SynExprAndBangTrivia: FSharp.Compiler.Text.Range get_EqualsRange()
 FSharp.Compiler.SyntaxTrivia.SynExprAndBangTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] InKeyword
 FSharp.Compiler.SyntaxTrivia.SynExprAndBangTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_InKeyword()
 FSharp.Compiler.SyntaxTrivia.SynExprAndBangTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynExprAndBangTrivia: Void .ctor(FSharp.Compiler.Text.Range, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
-FSharp.Compiler.SyntaxTrivia.SynExprIfThenElseTrivia
 FSharp.Compiler.SyntaxTrivia.SynExprIfThenElseTrivia: Boolean IsElif
 FSharp.Compiler.SyntaxTrivia.SynExprIfThenElseTrivia: Boolean get_IsElif()
 FSharp.Compiler.SyntaxTrivia.SynExprIfThenElseTrivia: FSharp.Compiler.Text.Range IfKeyword
@@ -9548,47 +9333,40 @@ FSharp.Compiler.SyntaxTrivia.SynExprIfThenElseTrivia: Microsoft.FSharp.Core.FSha
 FSharp.Compiler.SyntaxTrivia.SynExprIfThenElseTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_ElseKeyword()
 FSharp.Compiler.SyntaxTrivia.SynExprIfThenElseTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynExprIfThenElseTrivia: Void .ctor(FSharp.Compiler.Text.Range, Boolean, FSharp.Compiler.Text.Range, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], FSharp.Compiler.Text.Range)
-FSharp.Compiler.SyntaxTrivia.SynExprLambdaTrivia
 FSharp.Compiler.SyntaxTrivia.SynExprLambdaTrivia: FSharp.Compiler.SyntaxTrivia.SynExprLambdaTrivia Zero
 FSharp.Compiler.SyntaxTrivia.SynExprLambdaTrivia: FSharp.Compiler.SyntaxTrivia.SynExprLambdaTrivia get_Zero()
 FSharp.Compiler.SyntaxTrivia.SynExprLambdaTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] ArrowRange
 FSharp.Compiler.SyntaxTrivia.SynExprLambdaTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_ArrowRange()
 FSharp.Compiler.SyntaxTrivia.SynExprLambdaTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynExprLambdaTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
-FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseBangTrivia
 FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseBangTrivia: FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseBangTrivia Zero
 FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseBangTrivia: FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseBangTrivia get_Zero()
 FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseBangTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] EqualsRange
 FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseBangTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_EqualsRange()
 FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseBangTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseBangTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
-FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseTrivia
 FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] InKeyword
 FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_InKeyword()
 FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
-FSharp.Compiler.SyntaxTrivia.SynExprMatchBangTrivia
 FSharp.Compiler.SyntaxTrivia.SynExprMatchBangTrivia: FSharp.Compiler.Text.Range MatchBangKeyword
 FSharp.Compiler.SyntaxTrivia.SynExprMatchBangTrivia: FSharp.Compiler.Text.Range WithKeyword
 FSharp.Compiler.SyntaxTrivia.SynExprMatchBangTrivia: FSharp.Compiler.Text.Range get_MatchBangKeyword()
 FSharp.Compiler.SyntaxTrivia.SynExprMatchBangTrivia: FSharp.Compiler.Text.Range get_WithKeyword()
 FSharp.Compiler.SyntaxTrivia.SynExprMatchBangTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynExprMatchBangTrivia: Void .ctor(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
-FSharp.Compiler.SyntaxTrivia.SynExprMatchTrivia
 FSharp.Compiler.SyntaxTrivia.SynExprMatchTrivia: FSharp.Compiler.Text.Range MatchKeyword
 FSharp.Compiler.SyntaxTrivia.SynExprMatchTrivia: FSharp.Compiler.Text.Range WithKeyword
 FSharp.Compiler.SyntaxTrivia.SynExprMatchTrivia: FSharp.Compiler.Text.Range get_MatchKeyword()
 FSharp.Compiler.SyntaxTrivia.SynExprMatchTrivia: FSharp.Compiler.Text.Range get_WithKeyword()
 FSharp.Compiler.SyntaxTrivia.SynExprMatchTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynExprMatchTrivia: Void .ctor(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
-FSharp.Compiler.SyntaxTrivia.SynExprTryFinallyTrivia
 FSharp.Compiler.SyntaxTrivia.SynExprTryFinallyTrivia: FSharp.Compiler.Text.Range FinallyKeyword
 FSharp.Compiler.SyntaxTrivia.SynExprTryFinallyTrivia: FSharp.Compiler.Text.Range TryKeyword
 FSharp.Compiler.SyntaxTrivia.SynExprTryFinallyTrivia: FSharp.Compiler.Text.Range get_FinallyKeyword()
 FSharp.Compiler.SyntaxTrivia.SynExprTryFinallyTrivia: FSharp.Compiler.Text.Range get_TryKeyword()
 FSharp.Compiler.SyntaxTrivia.SynExprTryFinallyTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynExprTryFinallyTrivia: Void .ctor(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
-FSharp.Compiler.SyntaxTrivia.SynExprTryWithTrivia
 FSharp.Compiler.SyntaxTrivia.SynExprTryWithTrivia: FSharp.Compiler.Text.Range TryKeyword
 FSharp.Compiler.SyntaxTrivia.SynExprTryWithTrivia: FSharp.Compiler.Text.Range TryToWithRange
 FSharp.Compiler.SyntaxTrivia.SynExprTryWithTrivia: FSharp.Compiler.Text.Range WithKeyword
@@ -9599,14 +9377,12 @@ FSharp.Compiler.SyntaxTrivia.SynExprTryWithTrivia: FSharp.Compiler.Text.Range ge
 FSharp.Compiler.SyntaxTrivia.SynExprTryWithTrivia: FSharp.Compiler.Text.Range get_WithToEndRange()
 FSharp.Compiler.SyntaxTrivia.SynExprTryWithTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynExprTryWithTrivia: Void .ctor(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
-FSharp.Compiler.SyntaxTrivia.SynFieldTrivia
 FSharp.Compiler.SyntaxTrivia.SynFieldTrivia: FSharp.Compiler.SyntaxTrivia.SynFieldTrivia Zero
 FSharp.Compiler.SyntaxTrivia.SynFieldTrivia: FSharp.Compiler.SyntaxTrivia.SynFieldTrivia get_Zero()
 FSharp.Compiler.SyntaxTrivia.SynFieldTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword] LeadingKeyword
 FSharp.Compiler.SyntaxTrivia.SynFieldTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword] get_LeadingKeyword()
 FSharp.Compiler.SyntaxTrivia.SynFieldTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynFieldTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword])
-FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword
 FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Abstract: FSharp.Compiler.Text.Range abstractRange
 FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Abstract: FSharp.Compiler.Text.Range get_abstractRange()
 FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+AbstractMember: FSharp.Compiler.Text.Range abstractRange
@@ -9827,7 +9603,6 @@ FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.Text.Range get_R
 FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Int32 Tag
 FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Int32 get_Tag()
 FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: System.String ToString()
-FSharp.Compiler.SyntaxTrivia.SynMatchClauseTrivia
 FSharp.Compiler.SyntaxTrivia.SynMatchClauseTrivia: FSharp.Compiler.SyntaxTrivia.SynMatchClauseTrivia Zero
 FSharp.Compiler.SyntaxTrivia.SynMatchClauseTrivia: FSharp.Compiler.SyntaxTrivia.SynMatchClauseTrivia get_Zero()
 FSharp.Compiler.SyntaxTrivia.SynMatchClauseTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] ArrowRange
@@ -9836,14 +9611,12 @@ FSharp.Compiler.SyntaxTrivia.SynMatchClauseTrivia: Microsoft.FSharp.Core.FSharpO
 FSharp.Compiler.SyntaxTrivia.SynMatchClauseTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_BarRange()
 FSharp.Compiler.SyntaxTrivia.SynMatchClauseTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynMatchClauseTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
-FSharp.Compiler.SyntaxTrivia.SynMemberDefnAbstractSlotTrivia
 FSharp.Compiler.SyntaxTrivia.SynMemberDefnAbstractSlotTrivia: FSharp.Compiler.SyntaxTrivia.SynMemberDefnAbstractSlotTrivia Zero
 FSharp.Compiler.SyntaxTrivia.SynMemberDefnAbstractSlotTrivia: FSharp.Compiler.SyntaxTrivia.SynMemberDefnAbstractSlotTrivia get_Zero()
 FSharp.Compiler.SyntaxTrivia.SynMemberDefnAbstractSlotTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.GetSetKeywords] GetSetKeywords
 FSharp.Compiler.SyntaxTrivia.SynMemberDefnAbstractSlotTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.GetSetKeywords] get_GetSetKeywords()
 FSharp.Compiler.SyntaxTrivia.SynMemberDefnAbstractSlotTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynMemberDefnAbstractSlotTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.GetSetKeywords])
-FSharp.Compiler.SyntaxTrivia.SynMemberDefnAutoPropertyTrivia
 FSharp.Compiler.SyntaxTrivia.SynMemberDefnAutoPropertyTrivia: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword LeadingKeyword
 FSharp.Compiler.SyntaxTrivia.SynMemberDefnAutoPropertyTrivia: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword get_LeadingKeyword()
 FSharp.Compiler.SyntaxTrivia.SynMemberDefnAutoPropertyTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.GetSetKeywords] GetSetKeywords
@@ -9854,25 +9627,24 @@ FSharp.Compiler.SyntaxTrivia.SynMemberDefnAutoPropertyTrivia: Microsoft.FSharp.C
 FSharp.Compiler.SyntaxTrivia.SynMemberDefnAutoPropertyTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_WithKeyword()
 FSharp.Compiler.SyntaxTrivia.SynMemberDefnAutoPropertyTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynMemberDefnAutoPropertyTrivia: Void .ctor(FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.GetSetKeywords])
-FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia
 FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia: FSharp.Compiler.Text.Range WithKeyword
 FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia: FSharp.Compiler.Text.Range get_WithKeyword()
 FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] AndKeyword
 FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] GetKeyword
+FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] InlineKeyword
 FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] SetKeyword
 FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_AndKeyword()
 FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_GetKeyword()
+FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_InlineKeyword()
 FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_SetKeyword()
 FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia: System.String ToString()
-FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia: Void .ctor(FSharp.Compiler.Text.Range, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
-FSharp.Compiler.SyntaxTrivia.SynMemberSigMemberTrivia
+FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], FSharp.Compiler.Text.Range, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
 FSharp.Compiler.SyntaxTrivia.SynMemberSigMemberTrivia: FSharp.Compiler.SyntaxTrivia.SynMemberSigMemberTrivia Zero
 FSharp.Compiler.SyntaxTrivia.SynMemberSigMemberTrivia: FSharp.Compiler.SyntaxTrivia.SynMemberSigMemberTrivia get_Zero()
 FSharp.Compiler.SyntaxTrivia.SynMemberSigMemberTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.GetSetKeywords] GetSetKeywords
 FSharp.Compiler.SyntaxTrivia.SynMemberSigMemberTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.GetSetKeywords] get_GetSetKeywords()
 FSharp.Compiler.SyntaxTrivia.SynMemberSigMemberTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynMemberSigMemberTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.GetSetKeywords])
-FSharp.Compiler.SyntaxTrivia.SynModuleDeclNestedModuleTrivia
 FSharp.Compiler.SyntaxTrivia.SynModuleDeclNestedModuleTrivia: FSharp.Compiler.SyntaxTrivia.SynModuleDeclNestedModuleTrivia Zero
 FSharp.Compiler.SyntaxTrivia.SynModuleDeclNestedModuleTrivia: FSharp.Compiler.SyntaxTrivia.SynModuleDeclNestedModuleTrivia get_Zero()
 FSharp.Compiler.SyntaxTrivia.SynModuleDeclNestedModuleTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] EqualsRange
@@ -9881,7 +9653,6 @@ FSharp.Compiler.SyntaxTrivia.SynModuleDeclNestedModuleTrivia: Microsoft.FSharp.C
 FSharp.Compiler.SyntaxTrivia.SynModuleDeclNestedModuleTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_ModuleKeyword()
 FSharp.Compiler.SyntaxTrivia.SynModuleDeclNestedModuleTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynModuleDeclNestedModuleTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
-FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword
 FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword+Module: FSharp.Compiler.Text.Range get_moduleRange()
 FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword+Module: FSharp.Compiler.Text.Range moduleRange
 FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword+Namespace: FSharp.Compiler.Text.Range get_namespaceRange()
@@ -9905,17 +9676,14 @@ FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword: FSharp.Compiler
 FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword: Int32 Tag
 FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword: Int32 get_Tag()
 FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword: System.String ToString()
-FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceSigTrivia
 FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceSigTrivia: FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword LeadingKeyword
 FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceSigTrivia: FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword get_LeadingKeyword()
 FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceSigTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceSigTrivia: Void .ctor(FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword)
-FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceTrivia
 FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceTrivia: FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword LeadingKeyword
 FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceTrivia: FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword get_LeadingKeyword()
 FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceTrivia: Void .ctor(FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword)
-FSharp.Compiler.SyntaxTrivia.SynModuleSigDeclNestedModuleTrivia
 FSharp.Compiler.SyntaxTrivia.SynModuleSigDeclNestedModuleTrivia: FSharp.Compiler.SyntaxTrivia.SynModuleSigDeclNestedModuleTrivia Zero
 FSharp.Compiler.SyntaxTrivia.SynModuleSigDeclNestedModuleTrivia: FSharp.Compiler.SyntaxTrivia.SynModuleSigDeclNestedModuleTrivia get_Zero()
 FSharp.Compiler.SyntaxTrivia.SynModuleSigDeclNestedModuleTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] EqualsRange
@@ -9924,17 +9692,14 @@ FSharp.Compiler.SyntaxTrivia.SynModuleSigDeclNestedModuleTrivia: Microsoft.FShar
 FSharp.Compiler.SyntaxTrivia.SynModuleSigDeclNestedModuleTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_ModuleKeyword()
 FSharp.Compiler.SyntaxTrivia.SynModuleSigDeclNestedModuleTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynModuleSigDeclNestedModuleTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
-FSharp.Compiler.SyntaxTrivia.SynPatListConsTrivia
 FSharp.Compiler.SyntaxTrivia.SynPatListConsTrivia: FSharp.Compiler.Text.Range ColonColonRange
 FSharp.Compiler.SyntaxTrivia.SynPatListConsTrivia: FSharp.Compiler.Text.Range get_ColonColonRange()
 FSharp.Compiler.SyntaxTrivia.SynPatListConsTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynPatListConsTrivia: Void .ctor(FSharp.Compiler.Text.Range)
-FSharp.Compiler.SyntaxTrivia.SynPatOrTrivia
 FSharp.Compiler.SyntaxTrivia.SynPatOrTrivia: FSharp.Compiler.Text.Range BarRange
 FSharp.Compiler.SyntaxTrivia.SynPatOrTrivia: FSharp.Compiler.Text.Range get_BarRange()
 FSharp.Compiler.SyntaxTrivia.SynPatOrTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynPatOrTrivia: Void .ctor(FSharp.Compiler.Text.Range)
-FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword
 FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword+And: FSharp.Compiler.Text.Range Item
 FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword+And: FSharp.Compiler.Text.Range get_Item()
 FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword+StaticType: FSharp.Compiler.Text.Range get_staticRange()
@@ -9967,7 +9732,6 @@ FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword: FSharp.Compiler.SyntaxTr
 FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword: Int32 Tag
 FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword: Int32 get_Tag()
 FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword: System.String ToString()
-FSharp.Compiler.SyntaxTrivia.SynTypeDefnSigTrivia
 FSharp.Compiler.SyntaxTrivia.SynTypeDefnSigTrivia: FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword LeadingKeyword
 FSharp.Compiler.SyntaxTrivia.SynTypeDefnSigTrivia: FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword get_LeadingKeyword()
 FSharp.Compiler.SyntaxTrivia.SynTypeDefnSigTrivia: FSharp.Compiler.SyntaxTrivia.SynTypeDefnSigTrivia Zero
@@ -9978,7 +9742,6 @@ FSharp.Compiler.SyntaxTrivia.SynTypeDefnSigTrivia: Microsoft.FSharp.Core.FSharpO
 FSharp.Compiler.SyntaxTrivia.SynTypeDefnSigTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_WithKeyword()
 FSharp.Compiler.SyntaxTrivia.SynTypeDefnSigTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynTypeDefnSigTrivia: Void .ctor(FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
-FSharp.Compiler.SyntaxTrivia.SynTypeDefnTrivia
 FSharp.Compiler.SyntaxTrivia.SynTypeDefnTrivia: FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword LeadingKeyword
 FSharp.Compiler.SyntaxTrivia.SynTypeDefnTrivia: FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword get_LeadingKeyword()
 FSharp.Compiler.SyntaxTrivia.SynTypeDefnTrivia: FSharp.Compiler.SyntaxTrivia.SynTypeDefnTrivia Zero
@@ -9989,33 +9752,30 @@ FSharp.Compiler.SyntaxTrivia.SynTypeDefnTrivia: Microsoft.FSharp.Core.FSharpOpti
 FSharp.Compiler.SyntaxTrivia.SynTypeDefnTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_WithKeyword()
 FSharp.Compiler.SyntaxTrivia.SynTypeDefnTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynTypeDefnTrivia: Void .ctor(FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
-FSharp.Compiler.SyntaxTrivia.SynTypeFunTrivia
 FSharp.Compiler.SyntaxTrivia.SynTypeFunTrivia: FSharp.Compiler.Text.Range ArrowRange
 FSharp.Compiler.SyntaxTrivia.SynTypeFunTrivia: FSharp.Compiler.Text.Range get_ArrowRange()
 FSharp.Compiler.SyntaxTrivia.SynTypeFunTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynTypeFunTrivia: Void .ctor(FSharp.Compiler.Text.Range)
-FSharp.Compiler.SyntaxTrivia.SynTypeOrTrivia
 FSharp.Compiler.SyntaxTrivia.SynTypeOrTrivia: FSharp.Compiler.Text.Range OrKeyword
 FSharp.Compiler.SyntaxTrivia.SynTypeOrTrivia: FSharp.Compiler.Text.Range get_OrKeyword()
 FSharp.Compiler.SyntaxTrivia.SynTypeOrTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynTypeOrTrivia: Void .ctor(FSharp.Compiler.Text.Range)
-FSharp.Compiler.SyntaxTrivia.SynUnionCaseTrivia
 FSharp.Compiler.SyntaxTrivia.SynUnionCaseTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] BarRange
 FSharp.Compiler.SyntaxTrivia.SynUnionCaseTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_BarRange()
 FSharp.Compiler.SyntaxTrivia.SynUnionCaseTrivia: System.String ToString()
 FSharp.Compiler.SyntaxTrivia.SynUnionCaseTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
-FSharp.Compiler.SyntaxTrivia.SynValSigTrivia
 FSharp.Compiler.SyntaxTrivia.SynValSigTrivia: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword LeadingKeyword
 FSharp.Compiler.SyntaxTrivia.SynValSigTrivia: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword get_LeadingKeyword()
 FSharp.Compiler.SyntaxTrivia.SynValSigTrivia: FSharp.Compiler.SyntaxTrivia.SynValSigTrivia Zero
 FSharp.Compiler.SyntaxTrivia.SynValSigTrivia: FSharp.Compiler.SyntaxTrivia.SynValSigTrivia get_Zero()
 FSharp.Compiler.SyntaxTrivia.SynValSigTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] EqualsRange
+FSharp.Compiler.SyntaxTrivia.SynValSigTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] InlineKeyword
 FSharp.Compiler.SyntaxTrivia.SynValSigTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] WithKeyword
 FSharp.Compiler.SyntaxTrivia.SynValSigTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_EqualsRange()
+FSharp.Compiler.SyntaxTrivia.SynValSigTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_InlineKeyword()
 FSharp.Compiler.SyntaxTrivia.SynValSigTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_WithKeyword()
 FSharp.Compiler.SyntaxTrivia.SynValSigTrivia: System.String ToString()
-FSharp.Compiler.SyntaxTrivia.SynValSigTrivia: Void .ctor(FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
-FSharp.Compiler.Text.ISourceText
+FSharp.Compiler.SyntaxTrivia.SynValSigTrivia: Void .ctor(FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
 FSharp.Compiler.Text.ISourceText: Boolean ContentEquals(FSharp.Compiler.Text.ISourceText)
 FSharp.Compiler.Text.ISourceText: Boolean SubTextEquals(System.String, Int32)
 FSharp.Compiler.Text.ISourceText: Char Item [Int32]
@@ -10027,13 +9787,10 @@ FSharp.Compiler.Text.ISourceText: System.String GetLineString(Int32)
 FSharp.Compiler.Text.ISourceText: System.String GetSubTextString(Int32, Int32)
 FSharp.Compiler.Text.ISourceText: System.Tuple`2[System.Int32,System.Int32] GetLastCharacterPosition()
 FSharp.Compiler.Text.ISourceText: Void CopyTo(Int32, Char[], Int32, Int32)
-FSharp.Compiler.Text.Line
 FSharp.Compiler.Text.Line: Int32 fromZ(Int32)
 FSharp.Compiler.Text.Line: Int32 toZ(Int32)
-FSharp.Compiler.Text.NavigableTaggedText
 FSharp.Compiler.Text.NavigableTaggedText: FSharp.Compiler.Text.Range Range
 FSharp.Compiler.Text.NavigableTaggedText: FSharp.Compiler.Text.Range get_Range()
-FSharp.Compiler.Text.Position
 FSharp.Compiler.Text.Position: Boolean Equals(System.Object)
 FSharp.Compiler.Text.Position: Int32 Column
 FSharp.Compiler.Text.Position: Int32 GetHashCode()
@@ -10041,7 +9798,6 @@ FSharp.Compiler.Text.Position: Int32 Line
 FSharp.Compiler.Text.Position: Int32 get_Column()
 FSharp.Compiler.Text.Position: Int32 get_Line()
 FSharp.Compiler.Text.Position: System.String ToString()
-FSharp.Compiler.Text.PositionModule
 FSharp.Compiler.Text.PositionModule: Boolean posEq(FSharp.Compiler.Text.Position, FSharp.Compiler.Text.Position)
 FSharp.Compiler.Text.PositionModule: Boolean posGeq(FSharp.Compiler.Text.Position, FSharp.Compiler.Text.Position)
 FSharp.Compiler.Text.PositionModule: Boolean posGt(FSharp.Compiler.Text.Position, FSharp.Compiler.Text.Position)
@@ -10053,7 +9809,6 @@ FSharp.Compiler.Text.PositionModule: FSharp.Compiler.Text.Position pos0
 FSharp.Compiler.Text.PositionModule: System.String stringOfPos(FSharp.Compiler.Text.Position)
 FSharp.Compiler.Text.PositionModule: System.Tuple`2[System.Int32,System.Int32] toZ(FSharp.Compiler.Text.Position)
 FSharp.Compiler.Text.PositionModule: Void outputPos(System.IO.TextWriter, FSharp.Compiler.Text.Position)
-FSharp.Compiler.Text.Range
 FSharp.Compiler.Text.Range: Boolean Equals(System.Object)
 FSharp.Compiler.Text.Range: Boolean IsSynthetic
 FSharp.Compiler.Text.Range: Boolean get_IsSynthetic()
@@ -10079,7 +9834,6 @@ FSharp.Compiler.Text.Range: Int32 get_StartLine()
 FSharp.Compiler.Text.Range: System.String FileName
 FSharp.Compiler.Text.Range: System.String ToString()
 FSharp.Compiler.Text.Range: System.String get_FileName()
-FSharp.Compiler.Text.RangeModule
 FSharp.Compiler.Text.RangeModule: Boolean equals(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
 FSharp.Compiler.Text.RangeModule: Boolean rangeBeforePos(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Position)
 FSharp.Compiler.Text.RangeModule: Boolean rangeContainsPos(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Position)
@@ -10106,16 +9860,13 @@ FSharp.Compiler.Text.RangeModule: System.String stringOfRange(FSharp.Compiler.Te
 FSharp.Compiler.Text.RangeModule: System.Tuple`2[System.String,System.Tuple`2[System.Tuple`2[System.Int32,System.Int32],System.Tuple`2[System.Int32,System.Int32]]] toFileZ(FSharp.Compiler.Text.Range)
 FSharp.Compiler.Text.RangeModule: System.Tuple`2[System.Tuple`2[System.Int32,System.Int32],System.Tuple`2[System.Int32,System.Int32]] toZ(FSharp.Compiler.Text.Range)
 FSharp.Compiler.Text.RangeModule: Void outputRange(System.IO.TextWriter, FSharp.Compiler.Text.Range)
-FSharp.Compiler.Text.SourceText
 FSharp.Compiler.Text.SourceText: FSharp.Compiler.Text.ISourceText ofString(System.String)
-FSharp.Compiler.Text.TaggedText
 FSharp.Compiler.Text.TaggedText: FSharp.Compiler.Text.TextTag Tag
 FSharp.Compiler.Text.TaggedText: FSharp.Compiler.Text.TextTag get_Tag()
 FSharp.Compiler.Text.TaggedText: System.String Text
 FSharp.Compiler.Text.TaggedText: System.String ToString()
 FSharp.Compiler.Text.TaggedText: System.String get_Text()
 FSharp.Compiler.Text.TaggedText: Void .ctor(FSharp.Compiler.Text.TextTag, System.String)
-FSharp.Compiler.Text.TaggedTextModule
 FSharp.Compiler.Text.TaggedTextModule: FSharp.Compiler.Text.TaggedText colon
 FSharp.Compiler.Text.TaggedTextModule: FSharp.Compiler.Text.TaggedText comma
 FSharp.Compiler.Text.TaggedTextModule: FSharp.Compiler.Text.TaggedText dot
@@ -10133,7 +9884,6 @@ FSharp.Compiler.Text.TaggedTextModule: FSharp.Compiler.Text.TaggedText tagNamesp
 FSharp.Compiler.Text.TaggedTextModule: FSharp.Compiler.Text.TaggedText tagParameter(System.String)
 FSharp.Compiler.Text.TaggedTextModule: FSharp.Compiler.Text.TaggedText tagSpace(System.String)
 FSharp.Compiler.Text.TaggedTextModule: FSharp.Compiler.Text.TaggedText tagText(System.String)
-FSharp.Compiler.Text.TextTag
 FSharp.Compiler.Text.TextTag+Tags: Int32 ActivePatternCase
 FSharp.Compiler.Text.TextTag+Tags: Int32 ActivePatternResult
 FSharp.Compiler.Text.TextTag+Tags: Int32 Alias
@@ -10313,15 +10063,12 @@ FSharp.Compiler.Text.TextTag: Int32 GetHashCode(System.Collections.IEqualityComp
 FSharp.Compiler.Text.TextTag: Int32 Tag
 FSharp.Compiler.Text.TextTag: Int32 get_Tag()
 FSharp.Compiler.Text.TextTag: System.String ToString()
-FSharp.Compiler.Tokenization.FSharpKeywords
 FSharp.Compiler.Tokenization.FSharpKeywords: Microsoft.FSharp.Collections.FSharpList`1[System.String] KeywordNames
 FSharp.Compiler.Tokenization.FSharpKeywords: Microsoft.FSharp.Collections.FSharpList`1[System.String] get_KeywordNames()
 FSharp.Compiler.Tokenization.FSharpKeywords: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[System.String,System.String]] KeywordsWithDescription
 FSharp.Compiler.Tokenization.FSharpKeywords: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[System.String,System.String]] get_KeywordsWithDescription()
 FSharp.Compiler.Tokenization.FSharpKeywords: System.String NormalizeIdentifierBackticks(System.String)
-FSharp.Compiler.Tokenization.FSharpLexer
 FSharp.Compiler.Tokenization.FSharpLexer: Void Tokenize(FSharp.Compiler.Text.ISourceText, Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.Tokenization.FSharpToken,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.String], Microsoft.FSharp.Core.FSharpOption`1[System.String], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[System.String]], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Tokenization.FSharpLexerFlags], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpMap`2[System.String,System.String]], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
-FSharp.Compiler.Tokenization.FSharpLexerFlags
 FSharp.Compiler.Tokenization.FSharpLexerFlags: FSharp.Compiler.Tokenization.FSharpLexerFlags Compiling
 FSharp.Compiler.Tokenization.FSharpLexerFlags: FSharp.Compiler.Tokenization.FSharpLexerFlags CompilingFSharpCore
 FSharp.Compiler.Tokenization.FSharpLexerFlags: FSharp.Compiler.Tokenization.FSharpLexerFlags Default
@@ -10329,15 +10076,12 @@ FSharp.Compiler.Tokenization.FSharpLexerFlags: FSharp.Compiler.Tokenization.FSha
 FSharp.Compiler.Tokenization.FSharpLexerFlags: FSharp.Compiler.Tokenization.FSharpLexerFlags SkipTrivia
 FSharp.Compiler.Tokenization.FSharpLexerFlags: FSharp.Compiler.Tokenization.FSharpLexerFlags UseLexFilter
 FSharp.Compiler.Tokenization.FSharpLexerFlags: Int32 value__
-FSharp.Compiler.Tokenization.FSharpLineTokenizer
 FSharp.Compiler.Tokenization.FSharpLineTokenizer: FSharp.Compiler.Tokenization.FSharpTokenizerColorState ColorStateOfLexState(FSharp.Compiler.Tokenization.FSharpTokenizerLexState)
 FSharp.Compiler.Tokenization.FSharpLineTokenizer: FSharp.Compiler.Tokenization.FSharpTokenizerLexState LexStateOfColorState(FSharp.Compiler.Tokenization.FSharpTokenizerColorState)
 FSharp.Compiler.Tokenization.FSharpLineTokenizer: System.Tuple`2[Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Tokenization.FSharpTokenInfo],FSharp.Compiler.Tokenization.FSharpTokenizerLexState] ScanToken(FSharp.Compiler.Tokenization.FSharpTokenizerLexState)
-FSharp.Compiler.Tokenization.FSharpSourceTokenizer
 FSharp.Compiler.Tokenization.FSharpSourceTokenizer: FSharp.Compiler.Tokenization.FSharpLineTokenizer CreateBufferTokenizer(Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[System.Char[],System.Int32,System.Int32],System.Int32])
 FSharp.Compiler.Tokenization.FSharpSourceTokenizer: FSharp.Compiler.Tokenization.FSharpLineTokenizer CreateLineTokenizer(System.String)
 FSharp.Compiler.Tokenization.FSharpSourceTokenizer: Void .ctor(Microsoft.FSharp.Collections.FSharpList`1[System.String], Microsoft.FSharp.Core.FSharpOption`1[System.String])
-FSharp.Compiler.Tokenization.FSharpToken
 FSharp.Compiler.Tokenization.FSharpToken: Boolean IsCommentTrivia
 FSharp.Compiler.Tokenization.FSharpToken: Boolean IsIdentifier
 FSharp.Compiler.Tokenization.FSharpToken: Boolean IsKeyword
@@ -10352,7 +10096,6 @@ FSharp.Compiler.Tokenization.FSharpToken: FSharp.Compiler.Text.Range Range
 FSharp.Compiler.Tokenization.FSharpToken: FSharp.Compiler.Text.Range get_Range()
 FSharp.Compiler.Tokenization.FSharpToken: FSharp.Compiler.Tokenization.FSharpTokenKind Kind
 FSharp.Compiler.Tokenization.FSharpToken: FSharp.Compiler.Tokenization.FSharpTokenKind get_Kind()
-FSharp.Compiler.Tokenization.FSharpTokenCharKind
 FSharp.Compiler.Tokenization.FSharpTokenCharKind: FSharp.Compiler.Tokenization.FSharpTokenCharKind Comment
 FSharp.Compiler.Tokenization.FSharpTokenCharKind: FSharp.Compiler.Tokenization.FSharpTokenCharKind Default
 FSharp.Compiler.Tokenization.FSharpTokenCharKind: FSharp.Compiler.Tokenization.FSharpTokenCharKind Delimiter
@@ -10365,7 +10108,6 @@ FSharp.Compiler.Tokenization.FSharpTokenCharKind: FSharp.Compiler.Tokenization.F
 FSharp.Compiler.Tokenization.FSharpTokenCharKind: FSharp.Compiler.Tokenization.FSharpTokenCharKind Text
 FSharp.Compiler.Tokenization.FSharpTokenCharKind: FSharp.Compiler.Tokenization.FSharpTokenCharKind WhiteSpace
 FSharp.Compiler.Tokenization.FSharpTokenCharKind: Int32 value__
-FSharp.Compiler.Tokenization.FSharpTokenColorKind
 FSharp.Compiler.Tokenization.FSharpTokenColorKind: FSharp.Compiler.Tokenization.FSharpTokenColorKind Comment
 FSharp.Compiler.Tokenization.FSharpTokenColorKind: FSharp.Compiler.Tokenization.FSharpTokenColorKind Default
 FSharp.Compiler.Tokenization.FSharpTokenColorKind: FSharp.Compiler.Tokenization.FSharpTokenColorKind Identifier
@@ -10379,7 +10121,6 @@ FSharp.Compiler.Tokenization.FSharpTokenColorKind: FSharp.Compiler.Tokenization.
 FSharp.Compiler.Tokenization.FSharpTokenColorKind: FSharp.Compiler.Tokenization.FSharpTokenColorKind Text
 FSharp.Compiler.Tokenization.FSharpTokenColorKind: FSharp.Compiler.Tokenization.FSharpTokenColorKind UpperIdentifier
 FSharp.Compiler.Tokenization.FSharpTokenColorKind: Int32 value__
-FSharp.Compiler.Tokenization.FSharpTokenInfo
 FSharp.Compiler.Tokenization.FSharpTokenInfo: Boolean Equals(FSharp.Compiler.Tokenization.FSharpTokenInfo)
 FSharp.Compiler.Tokenization.FSharpTokenInfo: Boolean Equals(System.Object)
 FSharp.Compiler.Tokenization.FSharpTokenInfo: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
@@ -10406,7 +10147,6 @@ FSharp.Compiler.Tokenization.FSharpTokenInfo: System.String ToString()
 FSharp.Compiler.Tokenization.FSharpTokenInfo: System.String TokenName
 FSharp.Compiler.Tokenization.FSharpTokenInfo: System.String get_TokenName()
 FSharp.Compiler.Tokenization.FSharpTokenInfo: Void .ctor(Int32, Int32, FSharp.Compiler.Tokenization.FSharpTokenColorKind, FSharp.Compiler.Tokenization.FSharpTokenCharKind, FSharp.Compiler.Tokenization.FSharpTokenTriggerClass, Int32, System.String, Int32)
-FSharp.Compiler.Tokenization.FSharpTokenKind
 FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Abstract
 FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 AdjacentPrefixOperator
 FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Ampersand
@@ -11369,7 +11109,6 @@ FSharp.Compiler.Tokenization.FSharpTokenKind: Int32 GetHashCode(System.Collectio
 FSharp.Compiler.Tokenization.FSharpTokenKind: Int32 Tag
 FSharp.Compiler.Tokenization.FSharpTokenKind: Int32 get_Tag()
 FSharp.Compiler.Tokenization.FSharpTokenKind: System.String ToString()
-FSharp.Compiler.Tokenization.FSharpTokenTag
 FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 AMP_AMP
 FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 BAR
 FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 BAR_BAR
@@ -11498,7 +11237,6 @@ FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_TRY()
 FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_UNDERSCORE()
 FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_WHITESPACE()
 FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_WITH()
-FSharp.Compiler.Tokenization.FSharpTokenTriggerClass
 FSharp.Compiler.Tokenization.FSharpTokenTriggerClass: FSharp.Compiler.Tokenization.FSharpTokenTriggerClass ChoiceSelect
 FSharp.Compiler.Tokenization.FSharpTokenTriggerClass: FSharp.Compiler.Tokenization.FSharpTokenTriggerClass MatchBraces
 FSharp.Compiler.Tokenization.FSharpTokenTriggerClass: FSharp.Compiler.Tokenization.FSharpTokenTriggerClass MemberSelect
@@ -11508,7 +11246,6 @@ FSharp.Compiler.Tokenization.FSharpTokenTriggerClass: FSharp.Compiler.Tokenizati
 FSharp.Compiler.Tokenization.FSharpTokenTriggerClass: FSharp.Compiler.Tokenization.FSharpTokenTriggerClass ParamNext
 FSharp.Compiler.Tokenization.FSharpTokenTriggerClass: FSharp.Compiler.Tokenization.FSharpTokenTriggerClass ParamStart
 FSharp.Compiler.Tokenization.FSharpTokenTriggerClass: Int32 value__
-FSharp.Compiler.Tokenization.FSharpTokenizerColorState
 FSharp.Compiler.Tokenization.FSharpTokenizerColorState: FSharp.Compiler.Tokenization.FSharpTokenizerColorState CamlOnly
 FSharp.Compiler.Tokenization.FSharpTokenizerColorState: FSharp.Compiler.Tokenization.FSharpTokenizerColorState Comment
 FSharp.Compiler.Tokenization.FSharpTokenizerColorState: FSharp.Compiler.Tokenization.FSharpTokenizerColorState EndLineThenSkip
@@ -11524,7 +11261,6 @@ FSharp.Compiler.Tokenization.FSharpTokenizerColorState: FSharp.Compiler.Tokeniza
 FSharp.Compiler.Tokenization.FSharpTokenizerColorState: FSharp.Compiler.Tokenization.FSharpTokenizerColorState VerbatimString
 FSharp.Compiler.Tokenization.FSharpTokenizerColorState: FSharp.Compiler.Tokenization.FSharpTokenizerColorState VerbatimStringInComment
 FSharp.Compiler.Tokenization.FSharpTokenizerColorState: Int32 value__
-FSharp.Compiler.Tokenization.FSharpTokenizerLexState
 FSharp.Compiler.Tokenization.FSharpTokenizerLexState: Boolean Equals(FSharp.Compiler.Tokenization.FSharpTokenizerLexState)
 FSharp.Compiler.Tokenization.FSharpTokenizerLexState: Boolean Equals(System.Object)
 FSharp.Compiler.Tokenization.FSharpTokenizerLexState: FSharp.Compiler.Tokenization.FSharpTokenizerLexState Initial
@@ -11536,7 +11272,6 @@ FSharp.Compiler.Tokenization.FSharpTokenizerLexState: Int64 get_OtherBits()
 FSharp.Compiler.Tokenization.FSharpTokenizerLexState: Int64 get_PosBits()
 FSharp.Compiler.Tokenization.FSharpTokenizerLexState: System.String ToString()
 FSharp.Compiler.Tokenization.FSharpTokenizerLexState: Void .ctor(Int64, Int64)
-FSharp.Compiler.Xml.PreXmlDoc
 FSharp.Compiler.Xml.PreXmlDoc: Boolean Equals(FSharp.Compiler.Xml.PreXmlDoc)
 FSharp.Compiler.Xml.PreXmlDoc: Boolean Equals(System.Object)
 FSharp.Compiler.Xml.PreXmlDoc: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
@@ -11550,7 +11285,6 @@ FSharp.Compiler.Xml.PreXmlDoc: FSharp.Compiler.Xml.XmlDoc ToXmlDoc(Boolean, Micr
 FSharp.Compiler.Xml.PreXmlDoc: Int32 GetHashCode()
 FSharp.Compiler.Xml.PreXmlDoc: Int32 GetHashCode(System.Collections.IEqualityComparer)
 FSharp.Compiler.Xml.PreXmlDoc: System.String ToString()
-FSharp.Compiler.Xml.XmlDoc
 FSharp.Compiler.Xml.XmlDoc: Boolean IsEmpty
 FSharp.Compiler.Xml.XmlDoc: Boolean NonEmpty
 FSharp.Compiler.Xml.XmlDoc: Boolean get_IsEmpty()
diff --git a/tests/FSharp.Compiler.Service.Tests/FSharp.Compiler.Service.SurfaceArea.netstandard20.release.bsl b/tests/FSharp.Compiler.Service.Tests/FSharp.Compiler.Service.SurfaceArea.netstandard20.release.bsl
new file mode 100644
index 00000000000..8ce003becdf
--- /dev/null
+++ b/tests/FSharp.Compiler.Service.Tests/FSharp.Compiler.Service.SurfaceArea.netstandard20.release.bsl
@@ -0,0 +1,11301 @@
+! AssemblyReference: FSharp.Core
+! AssemblyReference: System.Buffers
+! AssemblyReference: System.Collections.Immutable
+! AssemblyReference: System.Diagnostics.DiagnosticSource
+! AssemblyReference: System.Memory
+! AssemblyReference: System.Reflection.Emit
+! AssemblyReference: System.Reflection.Emit.ILGeneration
+! AssemblyReference: System.Reflection.Metadata
+! AssemblyReference: netstandard
+FSharp.Compiler.AbstractIL.IL+ILArgConvention+Tags: Int32 CDecl
+FSharp.Compiler.AbstractIL.IL+ILArgConvention+Tags: Int32 Default
+FSharp.Compiler.AbstractIL.IL+ILArgConvention+Tags: Int32 FastCall
+FSharp.Compiler.AbstractIL.IL+ILArgConvention+Tags: Int32 StdCall
+FSharp.Compiler.AbstractIL.IL+ILArgConvention+Tags: Int32 ThisCall
+FSharp.Compiler.AbstractIL.IL+ILArgConvention+Tags: Int32 VarArg
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: Boolean Equals(ILArgConvention)
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: Boolean IsCDecl
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: Boolean IsDefault
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: Boolean IsFastCall
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: Boolean IsStdCall
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: Boolean IsThisCall
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: Boolean IsVarArg
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: Boolean get_IsCDecl()
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: Boolean get_IsDefault()
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: Boolean get_IsFastCall()
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: Boolean get_IsStdCall()
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: Boolean get_IsThisCall()
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: Boolean get_IsVarArg()
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: FSharp.Compiler.AbstractIL.IL+ILArgConvention+Tags
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: ILArgConvention CDecl
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: ILArgConvention Default
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: ILArgConvention FastCall
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: ILArgConvention StdCall
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: ILArgConvention ThisCall
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: ILArgConvention VarArg
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: ILArgConvention get_CDecl()
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: ILArgConvention get_Default()
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: ILArgConvention get_FastCall()
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: ILArgConvention get_StdCall()
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: ILArgConvention get_ThisCall()
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: ILArgConvention get_VarArg()
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: Int32 CompareTo(ILArgConvention)
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: Int32 Tag
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: Int32 get_Tag()
+FSharp.Compiler.AbstractIL.IL+ILArgConvention: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILArrayShape: Boolean Equals(ILArrayShape)
+FSharp.Compiler.AbstractIL.IL+ILArrayShape: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILArrayShape: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILArrayShape: ILArrayShape FromRank(Int32)
+FSharp.Compiler.AbstractIL.IL+ILArrayShape: ILArrayShape SingleDimensional
+FSharp.Compiler.AbstractIL.IL+ILArrayShape: ILArrayShape get_SingleDimensional()
+FSharp.Compiler.AbstractIL.IL+ILArrayShape: Int32 CompareTo(ILArrayShape)
+FSharp.Compiler.AbstractIL.IL+ILArrayShape: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILArrayShape: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILArrayShape: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILArrayShape: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILArrayShape: Int32 Rank
+FSharp.Compiler.AbstractIL.IL+ILArrayShape: Int32 get_Rank()
+FSharp.Compiler.AbstractIL.IL+ILArrayShape: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyLongevity: Boolean Equals(ILAssemblyLongevity)
+FSharp.Compiler.AbstractIL.IL+ILAssemblyLongevity: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILAssemblyLongevity: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILAssemblyLongevity: ILAssemblyLongevity Default
+FSharp.Compiler.AbstractIL.IL+ILAssemblyLongevity: ILAssemblyLongevity get_Default()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyLongevity: Int32 CompareTo(ILAssemblyLongevity)
+FSharp.Compiler.AbstractIL.IL+ILAssemblyLongevity: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILAssemblyLongevity: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILAssemblyLongevity: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyLongevity: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILAssemblyLongevity: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: Boolean DisableJitOptimizations
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: Boolean IgnoreSymbolStoreSequencePoints
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: Boolean JitTracking
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: Boolean Retargetable
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: Boolean get_DisableJitOptimizations()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: Boolean get_IgnoreSymbolStoreSequencePoints()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: Boolean get_JitTracking()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: Boolean get_Retargetable()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: ILAssemblyLongevity AssemblyLongevity
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: ILAssemblyLongevity get_AssemblyLongevity()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: ILAttributes CustomAttrs
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: ILAttributes get_CustomAttrs()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: ILAttributesStored CustomAttrsStored
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: ILAttributesStored get_CustomAttrsStored()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: ILExportedTypesAndForwarders ExportedTypes
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: ILExportedTypesAndForwarders get_ExportedTypes()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: ILSecurityDecls SecurityDecls
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: ILSecurityDecls get_SecurityDecls()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: ILSecurityDeclsStored SecurityDeclsStored
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: ILSecurityDeclsStored get_SecurityDeclsStored()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: Int32 AuxModuleHashAlgorithm
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: Int32 MetadataIndex
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: Int32 get_AuxModuleHashAlgorithm()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: Int32 get_MetadataIndex()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILModuleRef] EntrypointElsewhere
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILModuleRef] get_EntrypointElsewhere()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILVersionInfo] Version
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILVersionInfo] get_Version()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: Microsoft.FSharp.Core.FSharpOption`1[System.Byte[]] PublicKey
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: Microsoft.FSharp.Core.FSharpOption`1[System.Byte[]] get_PublicKey()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: Microsoft.FSharp.Core.FSharpOption`1[System.String] Locale
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: Microsoft.FSharp.Core.FSharpOption`1[System.String] get_Locale()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: System.String Name
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: System.String get_Name()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest: Void .ctor(System.String, Int32, ILSecurityDeclsStored, Microsoft.FSharp.Core.FSharpOption`1[System.Byte[]], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILVersionInfo], Microsoft.FSharp.Core.FSharpOption`1[System.String], ILAttributesStored, ILAssemblyLongevity, Boolean, Boolean, Boolean, Boolean, ILExportedTypesAndForwarders, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILModuleRef], Int32)
+FSharp.Compiler.AbstractIL.IL+ILAssemblyRef: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILAssemblyRef: Boolean EqualsIgnoringVersion(ILAssemblyRef)
+FSharp.Compiler.AbstractIL.IL+ILAssemblyRef: Boolean Retargetable
+FSharp.Compiler.AbstractIL.IL+ILAssemblyRef: Boolean get_Retargetable()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyRef: ILAssemblyRef Create(System.String, Microsoft.FSharp.Core.FSharpOption`1[System.Byte[]], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+PublicKey], Boolean, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILVersionInfo], Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.AbstractIL.IL+ILAssemblyRef: ILAssemblyRef FromAssemblyName(System.Reflection.AssemblyName)
+FSharp.Compiler.AbstractIL.IL+ILAssemblyRef: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyRef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILVersionInfo] Version
+FSharp.Compiler.AbstractIL.IL+ILAssemblyRef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILVersionInfo] get_Version()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyRef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+PublicKey] PublicKey
+FSharp.Compiler.AbstractIL.IL+ILAssemblyRef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+PublicKey] get_PublicKey()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyRef: Microsoft.FSharp.Core.FSharpOption`1[System.Byte[]] Hash
+FSharp.Compiler.AbstractIL.IL+ILAssemblyRef: Microsoft.FSharp.Core.FSharpOption`1[System.Byte[]] get_Hash()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyRef: Microsoft.FSharp.Core.FSharpOption`1[System.String] Locale
+FSharp.Compiler.AbstractIL.IL+ILAssemblyRef: Microsoft.FSharp.Core.FSharpOption`1[System.String] get_Locale()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyRef: System.String Name
+FSharp.Compiler.AbstractIL.IL+ILAssemblyRef: System.String QualifiedName
+FSharp.Compiler.AbstractIL.IL+ILAssemblyRef: System.String get_Name()
+FSharp.Compiler.AbstractIL.IL+ILAssemblyRef: System.String get_QualifiedName()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Array: ILType Item1
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Array: ILType get_Item1()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Array: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILAttribElem] Item2
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Array: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILAttribElem] get_Item2()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Bool: Boolean Item
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Bool: Boolean get_Item()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Byte: Byte Item
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Byte: Byte get_Item()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Char: Char Item
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Char: Char get_Item()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Double: Double Item
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Double: Double get_Item()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Int16: Int16 Item
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Int16: Int16 get_Item()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Int32: Int32 Item
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Int32: Int32 get_Item()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Int64: Int64 Item
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Int64: Int64 get_Item()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+SByte: SByte Item
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+SByte: SByte get_Item()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Single: Single Item
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Single: Single get_Item()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+String: Microsoft.FSharp.Core.FSharpOption`1[System.String] Item
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+String: Microsoft.FSharp.Core.FSharpOption`1[System.String] get_Item()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Tags: Int32 Array
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Tags: Int32 Bool
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Tags: Int32 Byte
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Tags: Int32 Char
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Tags: Int32 Double
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Tags: Int32 Int16
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Tags: Int32 Int32
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Tags: Int32 Int64
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Tags: Int32 Null
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Tags: Int32 SByte
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Tags: Int32 Single
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Tags: Int32 String
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Tags: Int32 Type
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Tags: Int32 TypeRef
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Tags: Int32 UInt16
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Tags: Int32 UInt32
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Tags: Int32 UInt64
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Type: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILType] Item
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+Type: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILType] get_Item()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+TypeRef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILTypeRef] Item
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+TypeRef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILTypeRef] get_Item()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+UInt16: UInt16 Item
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+UInt16: UInt16 get_Item()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+UInt32: UInt32 Item
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+UInt32: UInt32 get_Item()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+UInt64: UInt64 Item
+FSharp.Compiler.AbstractIL.IL+ILAttribElem+UInt64: UInt64 get_Item()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean Equals(ILAttribElem)
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean IsArray
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean IsBool
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean IsByte
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean IsChar
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean IsDouble
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean IsInt16
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean IsInt32
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean IsInt64
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean IsNull
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean IsSByte
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean IsSingle
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean IsString
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean IsType
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean IsTypeRef
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean IsUInt16
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean IsUInt32
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean IsUInt64
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean get_IsArray()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean get_IsBool()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean get_IsByte()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean get_IsChar()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean get_IsDouble()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean get_IsInt16()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean get_IsInt32()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean get_IsInt64()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean get_IsNull()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean get_IsSByte()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean get_IsSingle()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean get_IsString()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean get_IsType()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean get_IsTypeRef()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean get_IsUInt16()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean get_IsUInt32()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Boolean get_IsUInt64()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: FSharp.Compiler.AbstractIL.IL+ILAttribElem+Array
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: FSharp.Compiler.AbstractIL.IL+ILAttribElem+Bool
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: FSharp.Compiler.AbstractIL.IL+ILAttribElem+Byte
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: FSharp.Compiler.AbstractIL.IL+ILAttribElem+Char
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: FSharp.Compiler.AbstractIL.IL+ILAttribElem+Double
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: FSharp.Compiler.AbstractIL.IL+ILAttribElem+Int16
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: FSharp.Compiler.AbstractIL.IL+ILAttribElem+Int32
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: FSharp.Compiler.AbstractIL.IL+ILAttribElem+Int64
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: FSharp.Compiler.AbstractIL.IL+ILAttribElem+SByte
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: FSharp.Compiler.AbstractIL.IL+ILAttribElem+Single
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: FSharp.Compiler.AbstractIL.IL+ILAttribElem+String
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: FSharp.Compiler.AbstractIL.IL+ILAttribElem+Tags
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: FSharp.Compiler.AbstractIL.IL+ILAttribElem+Type
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: FSharp.Compiler.AbstractIL.IL+ILAttribElem+TypeRef
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: FSharp.Compiler.AbstractIL.IL+ILAttribElem+UInt16
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: FSharp.Compiler.AbstractIL.IL+ILAttribElem+UInt32
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: FSharp.Compiler.AbstractIL.IL+ILAttribElem+UInt64
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: ILAttribElem NewArray(ILType, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILAttribElem])
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: ILAttribElem NewBool(Boolean)
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: ILAttribElem NewByte(Byte)
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: ILAttribElem NewChar(Char)
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: ILAttribElem NewDouble(Double)
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: ILAttribElem NewInt16(Int16)
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: ILAttribElem NewInt32(Int32)
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: ILAttribElem NewInt64(Int64)
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: ILAttribElem NewSByte(SByte)
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: ILAttribElem NewSingle(Single)
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: ILAttribElem NewString(Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: ILAttribElem NewType(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILType])
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: ILAttribElem NewTypeRef(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILTypeRef])
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: ILAttribElem NewUInt16(UInt16)
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: ILAttribElem NewUInt32(UInt32)
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: ILAttribElem NewUInt64(UInt64)
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: ILAttribElem Null
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: ILAttribElem get_Null()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Int32 CompareTo(ILAttribElem)
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Int32 Tag
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: Int32 get_Tag()
+FSharp.Compiler.AbstractIL.IL+ILAttribElem: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILAttribute+Decoded: ILMethodSpec get_method()
+FSharp.Compiler.AbstractIL.IL+ILAttribute+Decoded: ILMethodSpec method
+FSharp.Compiler.AbstractIL.IL+ILAttribute+Decoded: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILAttribElem] fixedArgs
+FSharp.Compiler.AbstractIL.IL+ILAttribute+Decoded: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILAttribElem] get_fixedArgs()
+FSharp.Compiler.AbstractIL.IL+ILAttribute+Decoded: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`4[System.String,FSharp.Compiler.AbstractIL.IL+ILType,System.Boolean,FSharp.Compiler.AbstractIL.IL+ILAttribElem]] get_namedArgs()
+FSharp.Compiler.AbstractIL.IL+ILAttribute+Decoded: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`4[System.String,FSharp.Compiler.AbstractIL.IL+ILType,System.Boolean,FSharp.Compiler.AbstractIL.IL+ILAttribElem]] namedArgs
+FSharp.Compiler.AbstractIL.IL+ILAttribute+Encoded: Byte[] data
+FSharp.Compiler.AbstractIL.IL+ILAttribute+Encoded: Byte[] get_data()
+FSharp.Compiler.AbstractIL.IL+ILAttribute+Encoded: ILMethodSpec get_method()
+FSharp.Compiler.AbstractIL.IL+ILAttribute+Encoded: ILMethodSpec method
+FSharp.Compiler.AbstractIL.IL+ILAttribute+Encoded: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILAttribElem] elements
+FSharp.Compiler.AbstractIL.IL+ILAttribute+Encoded: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILAttribElem] get_elements()
+FSharp.Compiler.AbstractIL.IL+ILAttribute+Tags: Int32 Decoded
+FSharp.Compiler.AbstractIL.IL+ILAttribute+Tags: Int32 Encoded
+FSharp.Compiler.AbstractIL.IL+ILAttribute: Boolean Equals(ILAttribute)
+FSharp.Compiler.AbstractIL.IL+ILAttribute: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILAttribute: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILAttribute: Boolean IsDecoded
+FSharp.Compiler.AbstractIL.IL+ILAttribute: Boolean IsEncoded
+FSharp.Compiler.AbstractIL.IL+ILAttribute: Boolean get_IsDecoded()
+FSharp.Compiler.AbstractIL.IL+ILAttribute: Boolean get_IsEncoded()
+FSharp.Compiler.AbstractIL.IL+ILAttribute: FSharp.Compiler.AbstractIL.IL+ILAttribute+Decoded
+FSharp.Compiler.AbstractIL.IL+ILAttribute: FSharp.Compiler.AbstractIL.IL+ILAttribute+Encoded
+FSharp.Compiler.AbstractIL.IL+ILAttribute: FSharp.Compiler.AbstractIL.IL+ILAttribute+Tags
+FSharp.Compiler.AbstractIL.IL+ILAttribute: ILAttribute NewDecoded(ILMethodSpec, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILAttribElem], Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`4[System.String,FSharp.Compiler.AbstractIL.IL+ILType,System.Boolean,FSharp.Compiler.AbstractIL.IL+ILAttribElem]])
+FSharp.Compiler.AbstractIL.IL+ILAttribute: ILAttribute NewEncoded(ILMethodSpec, Byte[], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILAttribElem])
+FSharp.Compiler.AbstractIL.IL+ILAttribute: Int32 CompareTo(ILAttribute)
+FSharp.Compiler.AbstractIL.IL+ILAttribute: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILAttribute: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILAttribute: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILAttribute: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILAttribute: Int32 Tag
+FSharp.Compiler.AbstractIL.IL+ILAttribute: Int32 get_Tag()
+FSharp.Compiler.AbstractIL.IL+ILAttribute: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILAttributes: ILAttribute[] AsArray()
+FSharp.Compiler.AbstractIL.IL+ILAttributes: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILAttribute] AsList()
+FSharp.Compiler.AbstractIL.IL+ILAttributesStored: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILCallingConv: Boolean Equals(ILCallingConv)
+FSharp.Compiler.AbstractIL.IL+ILCallingConv: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILCallingConv: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILCallingConv: ILArgConvention Item2
+FSharp.Compiler.AbstractIL.IL+ILCallingConv: ILArgConvention get_Item2()
+FSharp.Compiler.AbstractIL.IL+ILCallingConv: ILCallingConv Instance
+FSharp.Compiler.AbstractIL.IL+ILCallingConv: ILCallingConv NewCallconv(ILThisConvention, ILArgConvention)
+FSharp.Compiler.AbstractIL.IL+ILCallingConv: ILCallingConv Static
+FSharp.Compiler.AbstractIL.IL+ILCallingConv: ILCallingConv get_Instance()
+FSharp.Compiler.AbstractIL.IL+ILCallingConv: ILCallingConv get_Static()
+FSharp.Compiler.AbstractIL.IL+ILCallingConv: ILThisConvention Item1
+FSharp.Compiler.AbstractIL.IL+ILCallingConv: ILThisConvention get_Item1()
+FSharp.Compiler.AbstractIL.IL+ILCallingConv: Int32 CompareTo(ILCallingConv)
+FSharp.Compiler.AbstractIL.IL+ILCallingConv: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILCallingConv: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILCallingConv: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILCallingConv: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILCallingConv: Int32 Tag
+FSharp.Compiler.AbstractIL.IL+ILCallingConv: Int32 get_Tag()
+FSharp.Compiler.AbstractIL.IL+ILCallingConv: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILCallingSignature: Boolean Equals(ILCallingSignature)
+FSharp.Compiler.AbstractIL.IL+ILCallingSignature: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILCallingSignature: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILCallingSignature: ILCallingConv CallingConv
+FSharp.Compiler.AbstractIL.IL+ILCallingSignature: ILCallingConv get_CallingConv()
+FSharp.Compiler.AbstractIL.IL+ILCallingSignature: ILType ReturnType
+FSharp.Compiler.AbstractIL.IL+ILCallingSignature: ILType get_ReturnType()
+FSharp.Compiler.AbstractIL.IL+ILCallingSignature: Int32 CompareTo(ILCallingSignature)
+FSharp.Compiler.AbstractIL.IL+ILCallingSignature: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILCallingSignature: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILCallingSignature: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILCallingSignature: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILCallingSignature: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType] ArgTypes
+FSharp.Compiler.AbstractIL.IL+ILCallingSignature: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType] get_ArgTypes()
+FSharp.Compiler.AbstractIL.IL+ILCallingSignature: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILCallingSignature: Void .ctor(ILCallingConv, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType], ILType)
+FSharp.Compiler.AbstractIL.IL+ILDebugImport+ImportNamespace: System.String get_targetNamespace()
+FSharp.Compiler.AbstractIL.IL+ILDebugImport+ImportNamespace: System.String targetNamespace
+FSharp.Compiler.AbstractIL.IL+ILDebugImport+ImportType: ILType get_targetType()
+FSharp.Compiler.AbstractIL.IL+ILDebugImport+ImportType: ILType targetType
+FSharp.Compiler.AbstractIL.IL+ILDebugImport+Tags: Int32 ImportNamespace
+FSharp.Compiler.AbstractIL.IL+ILDebugImport+Tags: Int32 ImportType
+FSharp.Compiler.AbstractIL.IL+ILDebugImport: Boolean IsImportNamespace
+FSharp.Compiler.AbstractIL.IL+ILDebugImport: Boolean IsImportType
+FSharp.Compiler.AbstractIL.IL+ILDebugImport: Boolean get_IsImportNamespace()
+FSharp.Compiler.AbstractIL.IL+ILDebugImport: Boolean get_IsImportType()
+FSharp.Compiler.AbstractIL.IL+ILDebugImport: FSharp.Compiler.AbstractIL.IL+ILDebugImport+ImportNamespace
+FSharp.Compiler.AbstractIL.IL+ILDebugImport: FSharp.Compiler.AbstractIL.IL+ILDebugImport+ImportType
+FSharp.Compiler.AbstractIL.IL+ILDebugImport: FSharp.Compiler.AbstractIL.IL+ILDebugImport+Tags
+FSharp.Compiler.AbstractIL.IL+ILDebugImport: ILDebugImport NewImportNamespace(System.String)
+FSharp.Compiler.AbstractIL.IL+ILDebugImport: ILDebugImport NewImportType(ILType)
+FSharp.Compiler.AbstractIL.IL+ILDebugImport: Int32 Tag
+FSharp.Compiler.AbstractIL.IL+ILDebugImport: Int32 get_Tag()
+FSharp.Compiler.AbstractIL.IL+ILDebugImport: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILDebugImports: ILDebugImport[] Imports
+FSharp.Compiler.AbstractIL.IL+ILDebugImports: ILDebugImport[] get_Imports()
+FSharp.Compiler.AbstractIL.IL+ILDebugImports: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILDebugImports] Parent
+FSharp.Compiler.AbstractIL.IL+ILDebugImports: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILDebugImports] get_Parent()
+FSharp.Compiler.AbstractIL.IL+ILDebugImports: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILDebugImports: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILDebugImports], ILDebugImport[])
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding+Tags: Int32 Ansi
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding+Tags: Int32 Auto
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding+Tags: Int32 Unicode
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding: Boolean Equals(ILDefaultPInvokeEncoding)
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding: Boolean IsAnsi
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding: Boolean IsAuto
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding: Boolean IsUnicode
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding: Boolean get_IsAnsi()
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding: Boolean get_IsAuto()
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding: Boolean get_IsUnicode()
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding: FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding+Tags
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding: ILDefaultPInvokeEncoding Ansi
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding: ILDefaultPInvokeEncoding Auto
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding: ILDefaultPInvokeEncoding Unicode
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding: ILDefaultPInvokeEncoding get_Ansi()
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding: ILDefaultPInvokeEncoding get_Auto()
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding: ILDefaultPInvokeEncoding get_Unicode()
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding: Int32 CompareTo(ILDefaultPInvokeEncoding)
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding: Int32 Tag
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding: Int32 get_Tag()
+FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILEventDef: Boolean IsRTSpecialName
+FSharp.Compiler.AbstractIL.IL+ILEventDef: Boolean IsSpecialName
+FSharp.Compiler.AbstractIL.IL+ILEventDef: Boolean get_IsRTSpecialName()
+FSharp.Compiler.AbstractIL.IL+ILEventDef: Boolean get_IsSpecialName()
+FSharp.Compiler.AbstractIL.IL+ILEventDef: ILAttributes CustomAttrs
+FSharp.Compiler.AbstractIL.IL+ILEventDef: ILAttributes get_CustomAttrs()
+FSharp.Compiler.AbstractIL.IL+ILEventDef: ILMethodRef AddMethod
+FSharp.Compiler.AbstractIL.IL+ILEventDef: ILMethodRef RemoveMethod
+FSharp.Compiler.AbstractIL.IL+ILEventDef: ILMethodRef get_AddMethod()
+FSharp.Compiler.AbstractIL.IL+ILEventDef: ILMethodRef get_RemoveMethod()
+FSharp.Compiler.AbstractIL.IL+ILEventDef: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILMethodRef] OtherMethods
+FSharp.Compiler.AbstractIL.IL+ILEventDef: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILMethodRef] get_OtherMethods()
+FSharp.Compiler.AbstractIL.IL+ILEventDef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILMethodRef] FireMethod
+FSharp.Compiler.AbstractIL.IL+ILEventDef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILMethodRef] get_FireMethod()
+FSharp.Compiler.AbstractIL.IL+ILEventDef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILType] EventType
+FSharp.Compiler.AbstractIL.IL+ILEventDef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILType] get_EventType()
+FSharp.Compiler.AbstractIL.IL+ILEventDef: System.Reflection.EventAttributes Attributes
+FSharp.Compiler.AbstractIL.IL+ILEventDef: System.Reflection.EventAttributes get_Attributes()
+FSharp.Compiler.AbstractIL.IL+ILEventDef: System.String Name
+FSharp.Compiler.AbstractIL.IL+ILEventDef: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILEventDef: System.String get_Name()
+FSharp.Compiler.AbstractIL.IL+ILEventDef: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILType], System.String, System.Reflection.EventAttributes, ILMethodRef, ILMethodRef, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILMethodRef], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILMethodRef], ILAttributes)
+FSharp.Compiler.AbstractIL.IL+ILEventDefs: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILExportedTypeOrForwarder: Boolean IsForwarder
+FSharp.Compiler.AbstractIL.IL+ILExportedTypeOrForwarder: Boolean get_IsForwarder()
+FSharp.Compiler.AbstractIL.IL+ILExportedTypeOrForwarder: ILAttributes CustomAttrs
+FSharp.Compiler.AbstractIL.IL+ILExportedTypeOrForwarder: ILAttributes get_CustomAttrs()
+FSharp.Compiler.AbstractIL.IL+ILExportedTypeOrForwarder: ILAttributesStored CustomAttrsStored
+FSharp.Compiler.AbstractIL.IL+ILExportedTypeOrForwarder: ILAttributesStored get_CustomAttrsStored()
+FSharp.Compiler.AbstractIL.IL+ILExportedTypeOrForwarder: ILNestedExportedTypes Nested
+FSharp.Compiler.AbstractIL.IL+ILExportedTypeOrForwarder: ILNestedExportedTypes get_Nested()
+FSharp.Compiler.AbstractIL.IL+ILExportedTypeOrForwarder: ILScopeRef ScopeRef
+FSharp.Compiler.AbstractIL.IL+ILExportedTypeOrForwarder: ILScopeRef get_ScopeRef()
+FSharp.Compiler.AbstractIL.IL+ILExportedTypeOrForwarder: ILTypeDefAccess Access
+FSharp.Compiler.AbstractIL.IL+ILExportedTypeOrForwarder: ILTypeDefAccess get_Access()
+FSharp.Compiler.AbstractIL.IL+ILExportedTypeOrForwarder: Int32 MetadataIndex
+FSharp.Compiler.AbstractIL.IL+ILExportedTypeOrForwarder: Int32 get_MetadataIndex()
+FSharp.Compiler.AbstractIL.IL+ILExportedTypeOrForwarder: System.Reflection.TypeAttributes Attributes
+FSharp.Compiler.AbstractIL.IL+ILExportedTypeOrForwarder: System.Reflection.TypeAttributes get_Attributes()
+FSharp.Compiler.AbstractIL.IL+ILExportedTypeOrForwarder: System.String Name
+FSharp.Compiler.AbstractIL.IL+ILExportedTypeOrForwarder: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILExportedTypeOrForwarder: System.String get_Name()
+FSharp.Compiler.AbstractIL.IL+ILExportedTypeOrForwarder: Void .ctor(ILScopeRef, System.String, System.Reflection.TypeAttributes, ILNestedExportedTypes, ILAttributesStored, Int32)
+FSharp.Compiler.AbstractIL.IL+ILExportedTypesAndForwarders: Boolean Equals(ILExportedTypesAndForwarders)
+FSharp.Compiler.AbstractIL.IL+ILExportedTypesAndForwarders: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILExportedTypesAndForwarders: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILExportedTypesAndForwarders: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILExportedTypesAndForwarders: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILExportedTypesAndForwarders: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: Boolean IsInitOnly
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: Boolean IsLiteral
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: Boolean IsSpecialName
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: Boolean IsStatic
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: Boolean NotSerialized
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: Boolean get_IsInitOnly()
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: Boolean get_IsLiteral()
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: Boolean get_IsSpecialName()
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: Boolean get_IsStatic()
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: Boolean get_NotSerialized()
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: ILAttributes CustomAttrs
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: ILAttributes get_CustomAttrs()
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: ILMemberAccess Access
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: ILMemberAccess get_Access()
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: ILType FieldType
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: ILType get_FieldType()
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILFieldInit] LiteralValue
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILFieldInit] get_LiteralValue()
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILNativeType] Marshal
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILNativeType] get_Marshal()
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: Microsoft.FSharp.Core.FSharpOption`1[System.Byte[]] Data
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: Microsoft.FSharp.Core.FSharpOption`1[System.Byte[]] get_Data()
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] Offset
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] get_Offset()
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: System.Reflection.FieldAttributes Attributes
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: System.Reflection.FieldAttributes get_Attributes()
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: System.String Name
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: System.String get_Name()
+FSharp.Compiler.AbstractIL.IL+ILFieldDef: Void .ctor(System.String, ILType, System.Reflection.FieldAttributes, Microsoft.FSharp.Core.FSharpOption`1[System.Byte[]], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILFieldInit], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILNativeType], ILAttributes)
+FSharp.Compiler.AbstractIL.IL+ILFieldDefs: Boolean Equals(ILFieldDefs)
+FSharp.Compiler.AbstractIL.IL+ILFieldDefs: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILFieldDefs: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILFieldDefs: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILFieldDefs: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILFieldDefs: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Bool: Boolean Item
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Bool: Boolean get_Item()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Char: UInt16 Item
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Char: UInt16 get_Item()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Double: Double Item
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Double: Double get_Item()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Int16: Int16 Item
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Int16: Int16 get_Item()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Int32: Int32 Item
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Int32: Int32 get_Item()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Int64: Int64 Item
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Int64: Int64 get_Item()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Int8: SByte Item
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Int8: SByte get_Item()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Single: Single Item
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Single: Single get_Item()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+String: System.String Item
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+String: System.String get_Item()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Tags: Int32 Bool
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Tags: Int32 Char
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Tags: Int32 Double
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Tags: Int32 Int16
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Tags: Int32 Int32
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Tags: Int32 Int64
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Tags: Int32 Int8
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Tags: Int32 Null
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Tags: Int32 Single
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Tags: Int32 String
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Tags: Int32 UInt16
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Tags: Int32 UInt32
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Tags: Int32 UInt64
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+Tags: Int32 UInt8
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+UInt16: UInt16 Item
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+UInt16: UInt16 get_Item()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+UInt32: UInt32 Item
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+UInt32: UInt32 get_Item()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+UInt64: UInt64 Item
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+UInt64: UInt64 get_Item()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+UInt8: Byte Item
+FSharp.Compiler.AbstractIL.IL+ILFieldInit+UInt8: Byte get_Item()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean Equals(ILFieldInit)
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean IsBool
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean IsChar
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean IsDouble
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean IsInt16
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean IsInt32
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean IsInt64
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean IsInt8
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean IsNull
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean IsSingle
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean IsString
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean IsUInt16
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean IsUInt32
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean IsUInt64
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean IsUInt8
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean get_IsBool()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean get_IsChar()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean get_IsDouble()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean get_IsInt16()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean get_IsInt32()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean get_IsInt64()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean get_IsInt8()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean get_IsNull()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean get_IsSingle()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean get_IsString()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean get_IsUInt16()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean get_IsUInt32()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean get_IsUInt64()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Boolean get_IsUInt8()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: FSharp.Compiler.AbstractIL.IL+ILFieldInit+Bool
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: FSharp.Compiler.AbstractIL.IL+ILFieldInit+Char
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: FSharp.Compiler.AbstractIL.IL+ILFieldInit+Double
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: FSharp.Compiler.AbstractIL.IL+ILFieldInit+Int16
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: FSharp.Compiler.AbstractIL.IL+ILFieldInit+Int32
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: FSharp.Compiler.AbstractIL.IL+ILFieldInit+Int64
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: FSharp.Compiler.AbstractIL.IL+ILFieldInit+Int8
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: FSharp.Compiler.AbstractIL.IL+ILFieldInit+Single
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: FSharp.Compiler.AbstractIL.IL+ILFieldInit+String
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: FSharp.Compiler.AbstractIL.IL+ILFieldInit+Tags
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: FSharp.Compiler.AbstractIL.IL+ILFieldInit+UInt16
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: FSharp.Compiler.AbstractIL.IL+ILFieldInit+UInt32
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: FSharp.Compiler.AbstractIL.IL+ILFieldInit+UInt64
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: FSharp.Compiler.AbstractIL.IL+ILFieldInit+UInt8
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: ILFieldInit NewBool(Boolean)
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: ILFieldInit NewChar(UInt16)
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: ILFieldInit NewDouble(Double)
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: ILFieldInit NewInt16(Int16)
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: ILFieldInit NewInt32(Int32)
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: ILFieldInit NewInt64(Int64)
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: ILFieldInit NewInt8(SByte)
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: ILFieldInit NewSingle(Single)
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: ILFieldInit NewString(System.String)
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: ILFieldInit NewUInt16(UInt16)
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: ILFieldInit NewUInt32(UInt32)
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: ILFieldInit NewUInt64(UInt64)
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: ILFieldInit NewUInt8(Byte)
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: ILFieldInit Null
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: ILFieldInit get_Null()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Int32 CompareTo(ILFieldInit)
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Int32 Tag
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: Int32 get_Tag()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: System.Object AsObject()
+FSharp.Compiler.AbstractIL.IL+ILFieldInit: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILFieldRef: Boolean Equals(ILFieldRef)
+FSharp.Compiler.AbstractIL.IL+ILFieldRef: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILFieldRef: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILFieldRef: ILType Type
+FSharp.Compiler.AbstractIL.IL+ILFieldRef: ILType get_Type()
+FSharp.Compiler.AbstractIL.IL+ILFieldRef: ILTypeRef DeclaringTypeRef
+FSharp.Compiler.AbstractIL.IL+ILFieldRef: ILTypeRef get_DeclaringTypeRef()
+FSharp.Compiler.AbstractIL.IL+ILFieldRef: Int32 CompareTo(ILFieldRef)
+FSharp.Compiler.AbstractIL.IL+ILFieldRef: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILFieldRef: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILFieldRef: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILFieldRef: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILFieldRef: System.String Name
+FSharp.Compiler.AbstractIL.IL+ILFieldRef: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILFieldRef: System.String get_Name()
+FSharp.Compiler.AbstractIL.IL+ILFieldRef: Void .ctor(ILTypeRef, System.String, ILType)
+FSharp.Compiler.AbstractIL.IL+ILFieldSpec: Boolean Equals(ILFieldSpec)
+FSharp.Compiler.AbstractIL.IL+ILFieldSpec: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILFieldSpec: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILFieldSpec: ILFieldRef FieldRef
+FSharp.Compiler.AbstractIL.IL+ILFieldSpec: ILFieldRef get_FieldRef()
+FSharp.Compiler.AbstractIL.IL+ILFieldSpec: ILType ActualType
+FSharp.Compiler.AbstractIL.IL+ILFieldSpec: ILType DeclaringType
+FSharp.Compiler.AbstractIL.IL+ILFieldSpec: ILType FormalType
+FSharp.Compiler.AbstractIL.IL+ILFieldSpec: ILType get_ActualType()
+FSharp.Compiler.AbstractIL.IL+ILFieldSpec: ILType get_DeclaringType()
+FSharp.Compiler.AbstractIL.IL+ILFieldSpec: ILType get_FormalType()
+FSharp.Compiler.AbstractIL.IL+ILFieldSpec: ILTypeRef DeclaringTypeRef
+FSharp.Compiler.AbstractIL.IL+ILFieldSpec: ILTypeRef get_DeclaringTypeRef()
+FSharp.Compiler.AbstractIL.IL+ILFieldSpec: Int32 CompareTo(ILFieldSpec)
+FSharp.Compiler.AbstractIL.IL+ILFieldSpec: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILFieldSpec: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILFieldSpec: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILFieldSpec: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILFieldSpec: System.String Name
+FSharp.Compiler.AbstractIL.IL+ILFieldSpec: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILFieldSpec: System.String get_Name()
+FSharp.Compiler.AbstractIL.IL+ILFieldSpec: Void .ctor(ILFieldRef, ILType)
+FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef: Boolean HasDefaultConstructorConstraint
+FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef: Boolean HasNotNullableValueTypeConstraint
+FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef: Boolean HasReferenceTypeConstraint
+FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef: Boolean get_HasDefaultConstructorConstraint()
+FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef: Boolean get_HasNotNullableValueTypeConstraint()
+FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef: Boolean get_HasReferenceTypeConstraint()
+FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef: ILAttributes CustomAttrs
+FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef: ILAttributes get_CustomAttrs()
+FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef: ILAttributesStored CustomAttrsStored
+FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef: ILAttributesStored get_CustomAttrsStored()
+FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef: ILGenericVariance Variance
+FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef: ILGenericVariance get_Variance()
+FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef: Int32 MetadataIndex
+FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef: Int32 get_MetadataIndex()
+FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType] Constraints
+FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType] get_Constraints()
+FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef: System.String Name
+FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef: System.String get_Name()
+FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef: Void .ctor(System.String, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType], ILGenericVariance, Boolean, Boolean, Boolean, ILAttributesStored, Int32)
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance+Tags: Int32 CoVariant
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance+Tags: Int32 ContraVariant
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance+Tags: Int32 NonVariant
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance: Boolean Equals(ILGenericVariance)
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance: Boolean IsCoVariant
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance: Boolean IsContraVariant
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance: Boolean IsNonVariant
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance: Boolean get_IsCoVariant()
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance: Boolean get_IsContraVariant()
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance: Boolean get_IsNonVariant()
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance: FSharp.Compiler.AbstractIL.IL+ILGenericVariance+Tags
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance: ILGenericVariance CoVariant
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance: ILGenericVariance ContraVariant
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance: ILGenericVariance NonVariant
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance: ILGenericVariance get_CoVariant()
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance: ILGenericVariance get_ContraVariant()
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance: ILGenericVariance get_NonVariant()
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance: Int32 CompareTo(ILGenericVariance)
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance: Int32 Tag
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance: Int32 get_Tag()
+FSharp.Compiler.AbstractIL.IL+ILGenericVariance: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess+Tags: Int32 Assembly
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess+Tags: Int32 CompilerControlled
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess+Tags: Int32 Family
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess+Tags: Int32 FamilyAndAssembly
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess+Tags: Int32 FamilyOrAssembly
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess+Tags: Int32 Private
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess+Tags: Int32 Public
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: Boolean Equals(ILMemberAccess)
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: Boolean IsAssembly
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: Boolean IsCompilerControlled
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: Boolean IsFamily
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: Boolean IsFamilyAndAssembly
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: Boolean IsFamilyOrAssembly
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: Boolean IsPrivate
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: Boolean IsPublic
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: Boolean get_IsAssembly()
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: Boolean get_IsCompilerControlled()
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: Boolean get_IsFamily()
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: Boolean get_IsFamilyAndAssembly()
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: Boolean get_IsFamilyOrAssembly()
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: Boolean get_IsPrivate()
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: Boolean get_IsPublic()
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: FSharp.Compiler.AbstractIL.IL+ILMemberAccess+Tags
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: ILMemberAccess Assembly
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: ILMemberAccess CompilerControlled
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: ILMemberAccess Family
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: ILMemberAccess FamilyAndAssembly
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: ILMemberAccess FamilyOrAssembly
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: ILMemberAccess Private
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: ILMemberAccess Public
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: ILMemberAccess get_Assembly()
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: ILMemberAccess get_CompilerControlled()
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: ILMemberAccess get_Family()
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: ILMemberAccess get_FamilyAndAssembly()
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: ILMemberAccess get_FamilyOrAssembly()
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: ILMemberAccess get_Private()
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: ILMemberAccess get_Public()
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: Int32 CompareTo(ILMemberAccess)
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: Int32 Tag
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: Int32 get_Tag()
+FSharp.Compiler.AbstractIL.IL+ILMemberAccess: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean HasSecurity
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean IsAbstract
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean IsAggressiveInline
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean IsCheckAccessOnOverride
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean IsClassInitializer
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean IsConstructor
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean IsEntryPoint
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean IsFinal
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean IsForwardRef
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean IsHideBySig
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean IsIL
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean IsInternalCall
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean IsManaged
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean IsMustRun
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean IsNewSlot
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean IsNoInline
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean IsNonVirtualInstance
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean IsPreserveSig
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean IsReqSecObj
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean IsSpecialName
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean IsStatic
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean IsSynchronized
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean IsUnmanagedExport
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean IsVirtual
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean IsZeroInit
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean get_HasSecurity()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean get_IsAbstract()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean get_IsAggressiveInline()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean get_IsCheckAccessOnOverride()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean get_IsClassInitializer()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean get_IsConstructor()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean get_IsEntryPoint()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean get_IsFinal()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean get_IsForwardRef()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean get_IsHideBySig()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean get_IsIL()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean get_IsInternalCall()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean get_IsManaged()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean get_IsMustRun()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean get_IsNewSlot()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean get_IsNoInline()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean get_IsNonVirtualInstance()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean get_IsPreserveSig()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean get_IsReqSecObj()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean get_IsSpecialName()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean get_IsStatic()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean get_IsSynchronized()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean get_IsUnmanagedExport()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean get_IsVirtual()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Boolean get_IsZeroInit()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: ILAttributes CustomAttrs
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: ILAttributes get_CustomAttrs()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: ILCallingConv CallingConv
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: ILCallingConv get_CallingConv()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: ILCallingSignature CallingSignature
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: ILCallingSignature get_CallingSignature()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: ILMemberAccess Access
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: ILMemberAccess get_Access()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: ILMethodBody MethodBody
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: ILMethodBody get_MethodBody()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: ILReturn Return
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: ILReturn get_Return()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: ILSecurityDecls SecurityDecls
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: ILSecurityDecls get_SecurityDecls()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Int32 MaxStack
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Int32 get_MaxStack()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: MethodBody Body
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: MethodBody get_Body()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef] GenericParams
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef] get_GenericParams()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILLocal] Locals
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILLocal] get_Locals()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILParameter] Parameters
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILParameter] get_Parameters()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType] ParameterTypes
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType] get_ParameterTypes()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILCode] Code
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILCode] get_Code()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: System.Reflection.MethodAttributes Attributes
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: System.Reflection.MethodAttributes get_Attributes()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: System.Reflection.MethodImplAttributes ImplAttributes
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: System.Reflection.MethodImplAttributes get_ImplAttributes()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: System.String Name
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: System.String get_Name()
+FSharp.Compiler.AbstractIL.IL+ILMethodDef: Void .ctor(System.String, System.Reflection.MethodAttributes, System.Reflection.MethodImplAttributes, ILCallingConv, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILParameter], ILReturn, System.Lazy`1[FSharp.Compiler.AbstractIL.IL+MethodBody], Boolean, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef], ILSecurityDecls, ILAttributes)
+FSharp.Compiler.AbstractIL.IL+ILMethodDefs: ILMethodDef[] AsArray()
+FSharp.Compiler.AbstractIL.IL+ILMethodDefs: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILMethodDef] AsList()
+FSharp.Compiler.AbstractIL.IL+ILMethodDefs: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILMethodDef] FindByName(System.String)
+FSharp.Compiler.AbstractIL.IL+ILMethodDefs: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILMethodDef] TryFindInstanceByNameAndCallingSignature(System.String, ILCallingSignature)
+FSharp.Compiler.AbstractIL.IL+ILMethodImplDef: Boolean Equals(ILMethodImplDef)
+FSharp.Compiler.AbstractIL.IL+ILMethodImplDef: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILMethodImplDef: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILMethodImplDef: ILMethodSpec OverrideBy
+FSharp.Compiler.AbstractIL.IL+ILMethodImplDef: ILMethodSpec get_OverrideBy()
+FSharp.Compiler.AbstractIL.IL+ILMethodImplDef: ILOverridesSpec Overrides
+FSharp.Compiler.AbstractIL.IL+ILMethodImplDef: ILOverridesSpec get_Overrides()
+FSharp.Compiler.AbstractIL.IL+ILMethodImplDef: Int32 CompareTo(ILMethodImplDef)
+FSharp.Compiler.AbstractIL.IL+ILMethodImplDef: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILMethodImplDef: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILMethodImplDef: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILMethodImplDef: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILMethodImplDef: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILMethodImplDef: Void .ctor(ILOverridesSpec, ILMethodSpec)
+FSharp.Compiler.AbstractIL.IL+ILMethodImplDefs: Boolean Equals(ILMethodImplDefs)
+FSharp.Compiler.AbstractIL.IL+ILMethodImplDefs: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILMethodImplDefs: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILMethodImplDefs: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILMethodImplDefs: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILMethodImplDefs: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: Boolean Equals(ILMethodRef)
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: ILCallingConv CallingConv
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: ILCallingConv get_CallingConv()
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: ILCallingSignature CallingSignature
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: ILCallingSignature get_CallingSignature()
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: ILMethodRef Create(ILTypeRef, ILCallingConv, System.String, Int32, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType], ILType)
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: ILType ReturnType
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: ILType get_ReturnType()
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: ILTypeRef DeclaringTypeRef
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: ILTypeRef get_DeclaringTypeRef()
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: Int32 ArgCount
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: Int32 CompareTo(ILMethodRef)
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: Int32 GenericArity
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: Int32 get_ArgCount()
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: Int32 get_GenericArity()
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType] ArgTypes
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType] get_ArgTypes()
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: System.String Name
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILMethodRef: System.String get_Name()
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: Boolean Equals(ILMethodSpec)
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: ILCallingConv CallingConv
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: ILCallingConv get_CallingConv()
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: ILMethodRef MethodRef
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: ILMethodRef get_MethodRef()
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: ILMethodSpec Create(ILType, ILMethodRef, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType])
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: ILType DeclaringType
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: ILType FormalReturnType
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: ILType get_DeclaringType()
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: ILType get_FormalReturnType()
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: Int32 CompareTo(ILMethodSpec)
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: Int32 GenericArity
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: Int32 get_GenericArity()
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType] FormalArgTypes
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType] GenericArgs
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType] get_FormalArgTypes()
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType] get_GenericArgs()
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: System.String Name
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILMethodSpec: System.String get_Name()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Boolean HasManifest
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Boolean Is32Bit
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Boolean Is32BitPreferred
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Boolean Is64Bit
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Boolean IsDLL
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Boolean IsILOnly
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Boolean UseHighEntropyVA
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Boolean get_HasManifest()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Boolean get_Is32Bit()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Boolean get_Is32BitPreferred()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Boolean get_Is64Bit()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Boolean get_IsDLL()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Boolean get_IsILOnly()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Boolean get_UseHighEntropyVA()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: ILAssemblyManifest ManifestOfAssembly
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: ILAssemblyManifest get_ManifestOfAssembly()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: ILAttributes CustomAttrs
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: ILAttributes get_CustomAttrs()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: ILAttributesStored CustomAttrsStored
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: ILAttributesStored get_CustomAttrsStored()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: ILResources Resources
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: ILResources get_Resources()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: ILTypeDefs TypeDefs
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: ILTypeDefs get_TypeDefs()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Int32 ImageBase
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Int32 MetadataIndex
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Int32 PhysicalAlignment
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Int32 SubSystemFlags
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Int32 VirtualAlignment
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Int32 get_ImageBase()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Int32 get_MetadataIndex()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Int32 get_PhysicalAlignment()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Int32 get_SubSystemFlags()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Int32 get_VirtualAlignment()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILNativeResource] NativeResources
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILNativeResource] get_NativeResources()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest] Manifest
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest] get_Manifest()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILPlatform] Platform
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILPlatform] get_Platform()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] StackReserveSize
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] get_StackReserveSize()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: System.String MetadataVersion
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: System.String Name
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: System.String get_MetadataVersion()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: System.String get_Name()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: System.Tuple`2[System.Int32,System.Int32] SubsystemVersion
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: System.Tuple`2[System.Int32,System.Int32] get_SubsystemVersion()
+FSharp.Compiler.AbstractIL.IL+ILModuleDef: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest], System.String, ILTypeDefs, System.Tuple`2[System.Int32,System.Int32], Boolean, Int32, Boolean, Boolean, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILPlatform], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Boolean, Boolean, Boolean, Int32, Int32, Int32, System.String, ILResources, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILNativeResource], ILAttributesStored, Int32)
+FSharp.Compiler.AbstractIL.IL+ILModuleRef: Boolean Equals(ILModuleRef)
+FSharp.Compiler.AbstractIL.IL+ILModuleRef: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILModuleRef: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILModuleRef: Boolean HasMetadata
+FSharp.Compiler.AbstractIL.IL+ILModuleRef: Boolean get_HasMetadata()
+FSharp.Compiler.AbstractIL.IL+ILModuleRef: ILModuleRef Create(System.String, Boolean, Microsoft.FSharp.Core.FSharpOption`1[System.Byte[]])
+FSharp.Compiler.AbstractIL.IL+ILModuleRef: Int32 CompareTo(ILModuleRef)
+FSharp.Compiler.AbstractIL.IL+ILModuleRef: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILModuleRef: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILModuleRef: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILModuleRef: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILModuleRef: Microsoft.FSharp.Core.FSharpOption`1[System.Byte[]] Hash
+FSharp.Compiler.AbstractIL.IL+ILModuleRef: Microsoft.FSharp.Core.FSharpOption`1[System.Byte[]] get_Hash()
+FSharp.Compiler.AbstractIL.IL+ILModuleRef: System.String Name
+FSharp.Compiler.AbstractIL.IL+ILModuleRef: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILModuleRef: System.String get_Name()
+FSharp.Compiler.AbstractIL.IL+ILNativeResource: Boolean Equals(ILNativeResource)
+FSharp.Compiler.AbstractIL.IL+ILNativeResource: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILNativeResource: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILNativeResource: Int32 CompareTo(ILNativeResource)
+FSharp.Compiler.AbstractIL.IL+ILNativeResource: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILNativeResource: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILNativeResource: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILNativeResource: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILNativeResource: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Array: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILNativeType] Item1
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Array: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILNativeType] get_Item1()
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Array: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Int32,Microsoft.FSharp.Core.FSharpOption`1[System.Int32]]] Item2
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Array: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Int32,Microsoft.FSharp.Core.FSharpOption`1[System.Int32]]] get_Item2()
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Custom: Byte[] Item1
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Custom: Byte[] cookieString
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Custom: Byte[] get_Item1()
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Custom: Byte[] get_cookieString()
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Custom: System.String custMarshallerName
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Custom: System.String get_custMarshallerName()
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Custom: System.String get_nativeTypeName()
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Custom: System.String nativeTypeName
+FSharp.Compiler.AbstractIL.IL+ILNativeType+FixedArray: Int32 Item
+FSharp.Compiler.AbstractIL.IL+ILNativeType+FixedArray: Int32 get_Item()
+FSharp.Compiler.AbstractIL.IL+ILNativeType+FixedSysString: Int32 Item
+FSharp.Compiler.AbstractIL.IL+ILNativeType+FixedSysString: Int32 get_Item()
+FSharp.Compiler.AbstractIL.IL+ILNativeType+SafeArray: ILNativeVariant Item1
+FSharp.Compiler.AbstractIL.IL+ILNativeType+SafeArray: ILNativeVariant get_Item1()
+FSharp.Compiler.AbstractIL.IL+ILNativeType+SafeArray: Microsoft.FSharp.Core.FSharpOption`1[System.String] Item2
+FSharp.Compiler.AbstractIL.IL+ILNativeType+SafeArray: Microsoft.FSharp.Core.FSharpOption`1[System.String] get_Item2()
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 ANSIBSTR
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 Array
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 AsAny
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 BSTR
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 Bool
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 ByValStr
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 Byte
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 Currency
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 Custom
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 Double
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 Empty
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 Error
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 FixedArray
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 FixedSysString
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 IDispatch
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 IUnknown
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 Int
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 Int16
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 Int32
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 Int64
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 Int8
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 Interface
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 LPSTR
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 LPSTRUCT
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 LPTSTR
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 LPUTF8STR
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 LPWSTR
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 Method
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 SafeArray
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 Single
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 Struct
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 TBSTR
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 UInt
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 UInt16
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 UInt32
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 UInt64
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 VariantBool
+FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags: Int32 Void
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean Equals(ILNativeType)
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsANSIBSTR
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsArray
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsAsAny
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsBSTR
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsBool
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsByValStr
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsByte
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsCurrency
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsCustom
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsDouble
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsEmpty
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsError
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsFixedArray
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsFixedSysString
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsIDispatch
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsIUnknown
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsInt
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsInt16
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsInt32
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsInt64
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsInt8
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsInterface
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsLPSTR
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsLPSTRUCT
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsLPTSTR
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsLPUTF8STR
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsLPWSTR
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsMethod
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsSafeArray
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsSingle
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsStruct
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsTBSTR
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsUInt
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsUInt16
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsUInt32
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsUInt64
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsVariantBool
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean IsVoid
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsANSIBSTR()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsArray()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsAsAny()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsBSTR()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsBool()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsByValStr()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsByte()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsCurrency()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsCustom()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsDouble()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsEmpty()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsError()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsFixedArray()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsFixedSysString()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsIDispatch()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsIUnknown()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsInt()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsInt16()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsInt32()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsInt64()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsInt8()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsInterface()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsLPSTR()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsLPSTRUCT()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsLPTSTR()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsLPUTF8STR()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsLPWSTR()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsMethod()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsSafeArray()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsSingle()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsStruct()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsTBSTR()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsUInt()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsUInt16()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsUInt32()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsUInt64()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsVariantBool()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Boolean get_IsVoid()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: FSharp.Compiler.AbstractIL.IL+ILNativeType+Array
+FSharp.Compiler.AbstractIL.IL+ILNativeType: FSharp.Compiler.AbstractIL.IL+ILNativeType+Custom
+FSharp.Compiler.AbstractIL.IL+ILNativeType: FSharp.Compiler.AbstractIL.IL+ILNativeType+FixedArray
+FSharp.Compiler.AbstractIL.IL+ILNativeType: FSharp.Compiler.AbstractIL.IL+ILNativeType+FixedSysString
+FSharp.Compiler.AbstractIL.IL+ILNativeType: FSharp.Compiler.AbstractIL.IL+ILNativeType+SafeArray
+FSharp.Compiler.AbstractIL.IL+ILNativeType: FSharp.Compiler.AbstractIL.IL+ILNativeType+Tags
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType ANSIBSTR
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType AsAny
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType BSTR
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType Bool
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType ByValStr
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType Byte
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType Currency
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType Double
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType Empty
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType Error
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType IDispatch
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType IUnknown
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType Int
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType Int16
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType Int32
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType Int64
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType Int8
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType Interface
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType LPSTR
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType LPSTRUCT
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType LPTSTR
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType LPUTF8STR
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType LPWSTR
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType Method
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType NewArray(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILNativeType], Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Int32,Microsoft.FSharp.Core.FSharpOption`1[System.Int32]]])
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType NewCustom(Byte[], System.String, System.String, Byte[])
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType NewFixedArray(Int32)
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType NewFixedSysString(Int32)
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType NewSafeArray(ILNativeVariant, Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType Single
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType Struct
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType TBSTR
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType UInt
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType UInt16
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType UInt32
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType UInt64
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType VariantBool
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType Void
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_ANSIBSTR()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_AsAny()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_BSTR()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_Bool()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_ByValStr()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_Byte()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_Currency()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_Double()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_Empty()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_Error()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_IDispatch()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_IUnknown()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_Int()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_Int16()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_Int32()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_Int64()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_Int8()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_Interface()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_LPSTR()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_LPSTRUCT()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_LPTSTR()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_LPUTF8STR()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_LPWSTR()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_Method()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_Single()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_Struct()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_TBSTR()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_UInt()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_UInt16()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_UInt32()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_UInt64()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_VariantBool()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: ILNativeType get_Void()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Int32 CompareTo(ILNativeType)
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Int32 Tag
+FSharp.Compiler.AbstractIL.IL+ILNativeType: Int32 get_Tag()
+FSharp.Compiler.AbstractIL.IL+ILNativeType: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILNestedExportedType: ILAttributes CustomAttrs
+FSharp.Compiler.AbstractIL.IL+ILNestedExportedType: ILAttributes get_CustomAttrs()
+FSharp.Compiler.AbstractIL.IL+ILNestedExportedType: ILAttributesStored CustomAttrsStored
+FSharp.Compiler.AbstractIL.IL+ILNestedExportedType: ILAttributesStored get_CustomAttrsStored()
+FSharp.Compiler.AbstractIL.IL+ILNestedExportedType: ILMemberAccess Access
+FSharp.Compiler.AbstractIL.IL+ILNestedExportedType: ILMemberAccess get_Access()
+FSharp.Compiler.AbstractIL.IL+ILNestedExportedType: ILNestedExportedTypes Nested
+FSharp.Compiler.AbstractIL.IL+ILNestedExportedType: ILNestedExportedTypes get_Nested()
+FSharp.Compiler.AbstractIL.IL+ILNestedExportedType: Int32 MetadataIndex
+FSharp.Compiler.AbstractIL.IL+ILNestedExportedType: Int32 get_MetadataIndex()
+FSharp.Compiler.AbstractIL.IL+ILNestedExportedType: System.String Name
+FSharp.Compiler.AbstractIL.IL+ILNestedExportedType: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILNestedExportedType: System.String get_Name()
+FSharp.Compiler.AbstractIL.IL+ILNestedExportedType: Void .ctor(System.String, ILMemberAccess, ILNestedExportedTypes, ILAttributesStored, Int32)
+FSharp.Compiler.AbstractIL.IL+ILNestedExportedTypes: Boolean Equals(ILNestedExportedTypes)
+FSharp.Compiler.AbstractIL.IL+ILNestedExportedTypes: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILNestedExportedTypes: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILNestedExportedTypes: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILNestedExportedTypes: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILNestedExportedTypes: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILParameter: Boolean IsIn
+FSharp.Compiler.AbstractIL.IL+ILParameter: Boolean IsOptional
+FSharp.Compiler.AbstractIL.IL+ILParameter: Boolean IsOut
+FSharp.Compiler.AbstractIL.IL+ILParameter: Boolean get_IsIn()
+FSharp.Compiler.AbstractIL.IL+ILParameter: Boolean get_IsOptional()
+FSharp.Compiler.AbstractIL.IL+ILParameter: Boolean get_IsOut()
+FSharp.Compiler.AbstractIL.IL+ILParameter: ILAttributes CustomAttrs
+FSharp.Compiler.AbstractIL.IL+ILParameter: ILAttributes get_CustomAttrs()
+FSharp.Compiler.AbstractIL.IL+ILParameter: ILAttributesStored CustomAttrsStored
+FSharp.Compiler.AbstractIL.IL+ILParameter: ILAttributesStored get_CustomAttrsStored()
+FSharp.Compiler.AbstractIL.IL+ILParameter: ILType Type
+FSharp.Compiler.AbstractIL.IL+ILParameter: ILType get_Type()
+FSharp.Compiler.AbstractIL.IL+ILParameter: Int32 MetadataIndex
+FSharp.Compiler.AbstractIL.IL+ILParameter: Int32 get_MetadataIndex()
+FSharp.Compiler.AbstractIL.IL+ILParameter: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILFieldInit] Default
+FSharp.Compiler.AbstractIL.IL+ILParameter: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILFieldInit] get_Default()
+FSharp.Compiler.AbstractIL.IL+ILParameter: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILNativeType] Marshal
+FSharp.Compiler.AbstractIL.IL+ILParameter: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILNativeType] get_Marshal()
+FSharp.Compiler.AbstractIL.IL+ILParameter: Microsoft.FSharp.Core.FSharpOption`1[System.String] Name
+FSharp.Compiler.AbstractIL.IL+ILParameter: Microsoft.FSharp.Core.FSharpOption`1[System.String] get_Name()
+FSharp.Compiler.AbstractIL.IL+ILParameter: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILParameter: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[System.String], ILType, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILFieldInit], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILNativeType], Boolean, Boolean, Boolean, ILAttributesStored, Int32)
+FSharp.Compiler.AbstractIL.IL+ILPlatform: Boolean Equals(ILPlatform)
+FSharp.Compiler.AbstractIL.IL+ILPlatform: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILPlatform: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILPlatform: Int32 CompareTo(ILPlatform)
+FSharp.Compiler.AbstractIL.IL+ILPlatform: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILPlatform: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILPlatform: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILPlatform: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILPlatform: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILPreTypeDef: ILTypeDef GetTypeDef()
+FSharp.Compiler.AbstractIL.IL+ILPreTypeDef: Microsoft.FSharp.Collections.FSharpList`1[System.String] Namespace
+FSharp.Compiler.AbstractIL.IL+ILPreTypeDef: Microsoft.FSharp.Collections.FSharpList`1[System.String] get_Namespace()
+FSharp.Compiler.AbstractIL.IL+ILPreTypeDef: System.String Name
+FSharp.Compiler.AbstractIL.IL+ILPreTypeDef: System.String get_Name()
+FSharp.Compiler.AbstractIL.IL+ILPropertyDef: Boolean IsRTSpecialName
+FSharp.Compiler.AbstractIL.IL+ILPropertyDef: Boolean IsSpecialName
+FSharp.Compiler.AbstractIL.IL+ILPropertyDef: Boolean get_IsRTSpecialName()
+FSharp.Compiler.AbstractIL.IL+ILPropertyDef: Boolean get_IsSpecialName()
+FSharp.Compiler.AbstractIL.IL+ILPropertyDef: ILAttributes CustomAttrs
+FSharp.Compiler.AbstractIL.IL+ILPropertyDef: ILAttributes get_CustomAttrs()
+FSharp.Compiler.AbstractIL.IL+ILPropertyDef: ILThisConvention CallingConv
+FSharp.Compiler.AbstractIL.IL+ILPropertyDef: ILThisConvention get_CallingConv()
+FSharp.Compiler.AbstractIL.IL+ILPropertyDef: ILType PropertyType
+FSharp.Compiler.AbstractIL.IL+ILPropertyDef: ILType get_PropertyType()
+FSharp.Compiler.AbstractIL.IL+ILPropertyDef: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType] Args
+FSharp.Compiler.AbstractIL.IL+ILPropertyDef: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType] get_Args()
+FSharp.Compiler.AbstractIL.IL+ILPropertyDef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILFieldInit] Init
+FSharp.Compiler.AbstractIL.IL+ILPropertyDef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILFieldInit] get_Init()
+FSharp.Compiler.AbstractIL.IL+ILPropertyDef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILMethodRef] GetMethod
+FSharp.Compiler.AbstractIL.IL+ILPropertyDef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILMethodRef] SetMethod
+FSharp.Compiler.AbstractIL.IL+ILPropertyDef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILMethodRef] get_GetMethod()
+FSharp.Compiler.AbstractIL.IL+ILPropertyDef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILMethodRef] get_SetMethod()
+FSharp.Compiler.AbstractIL.IL+ILPropertyDef: System.Reflection.PropertyAttributes Attributes
+FSharp.Compiler.AbstractIL.IL+ILPropertyDef: System.Reflection.PropertyAttributes get_Attributes()
+FSharp.Compiler.AbstractIL.IL+ILPropertyDef: System.String Name
+FSharp.Compiler.AbstractIL.IL+ILPropertyDef: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILPropertyDef: System.String get_Name()
+FSharp.Compiler.AbstractIL.IL+ILPropertyDef: Void .ctor(System.String, System.Reflection.PropertyAttributes, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILMethodRef], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILMethodRef], ILThisConvention, ILType, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILFieldInit], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType], ILAttributes)
+FSharp.Compiler.AbstractIL.IL+ILPropertyDefs: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILReferences: Boolean Equals(ILReferences)
+FSharp.Compiler.AbstractIL.IL+ILReferences: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILReferences: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILReferences: ILAssemblyRef[] AssemblyReferences
+FSharp.Compiler.AbstractIL.IL+ILReferences: ILAssemblyRef[] get_AssemblyReferences()
+FSharp.Compiler.AbstractIL.IL+ILReferences: ILFieldRef[] FieldReferences
+FSharp.Compiler.AbstractIL.IL+ILReferences: ILFieldRef[] get_FieldReferences()
+FSharp.Compiler.AbstractIL.IL+ILReferences: ILMethodRef[] MethodReferences
+FSharp.Compiler.AbstractIL.IL+ILReferences: ILMethodRef[] get_MethodReferences()
+FSharp.Compiler.AbstractIL.IL+ILReferences: ILModuleRef[] ModuleReferences
+FSharp.Compiler.AbstractIL.IL+ILReferences: ILModuleRef[] get_ModuleReferences()
+FSharp.Compiler.AbstractIL.IL+ILReferences: ILTypeRef[] TypeReferences
+FSharp.Compiler.AbstractIL.IL+ILReferences: ILTypeRef[] get_TypeReferences()
+FSharp.Compiler.AbstractIL.IL+ILReferences: Int32 CompareTo(ILReferences)
+FSharp.Compiler.AbstractIL.IL+ILReferences: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILReferences: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILReferences: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILReferences: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILReferences: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILReferences: Void .ctor(ILAssemblyRef[], ILModuleRef[], ILTypeRef[], ILMethodRef[], ILFieldRef[])
+FSharp.Compiler.AbstractIL.IL+ILResources: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILReturn: ILAttributes CustomAttrs
+FSharp.Compiler.AbstractIL.IL+ILReturn: ILAttributes get_CustomAttrs()
+FSharp.Compiler.AbstractIL.IL+ILReturn: ILAttributesStored CustomAttrsStored
+FSharp.Compiler.AbstractIL.IL+ILReturn: ILAttributesStored get_CustomAttrsStored()
+FSharp.Compiler.AbstractIL.IL+ILReturn: ILReturn WithCustomAttrs(ILAttributes)
+FSharp.Compiler.AbstractIL.IL+ILReturn: ILType Type
+FSharp.Compiler.AbstractIL.IL+ILReturn: ILType get_Type()
+FSharp.Compiler.AbstractIL.IL+ILReturn: Int32 MetadataIndex
+FSharp.Compiler.AbstractIL.IL+ILReturn: Int32 get_MetadataIndex()
+FSharp.Compiler.AbstractIL.IL+ILReturn: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILNativeType] Marshal
+FSharp.Compiler.AbstractIL.IL+ILReturn: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILNativeType] get_Marshal()
+FSharp.Compiler.AbstractIL.IL+ILReturn: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILReturn: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILNativeType], ILType, ILAttributesStored, Int32)
+FSharp.Compiler.AbstractIL.IL+ILScopeRef+Assembly: ILAssemblyRef Item
+FSharp.Compiler.AbstractIL.IL+ILScopeRef+Assembly: ILAssemblyRef get_Item()
+FSharp.Compiler.AbstractIL.IL+ILScopeRef+Module: ILModuleRef Item
+FSharp.Compiler.AbstractIL.IL+ILScopeRef+Module: ILModuleRef get_Item()
+FSharp.Compiler.AbstractIL.IL+ILScopeRef+Tags: Int32 Assembly
+FSharp.Compiler.AbstractIL.IL+ILScopeRef+Tags: Int32 Local
+FSharp.Compiler.AbstractIL.IL+ILScopeRef+Tags: Int32 Module
+FSharp.Compiler.AbstractIL.IL+ILScopeRef+Tags: Int32 PrimaryAssembly
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: Boolean Equals(ILScopeRef)
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: Boolean IsAssembly
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: Boolean IsLocal
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: Boolean IsLocalRef
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: Boolean IsModule
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: Boolean IsPrimaryAssembly
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: Boolean get_IsAssembly()
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: Boolean get_IsLocal()
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: Boolean get_IsLocalRef()
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: Boolean get_IsModule()
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: Boolean get_IsPrimaryAssembly()
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: FSharp.Compiler.AbstractIL.IL+ILScopeRef+Assembly
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: FSharp.Compiler.AbstractIL.IL+ILScopeRef+Module
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: FSharp.Compiler.AbstractIL.IL+ILScopeRef+Tags
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: ILScopeRef Local
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: ILScopeRef NewAssembly(ILAssemblyRef)
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: ILScopeRef NewModule(ILModuleRef)
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: ILScopeRef PrimaryAssembly
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: ILScopeRef get_Local()
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: ILScopeRef get_PrimaryAssembly()
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: Int32 CompareTo(ILScopeRef)
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: Int32 Tag
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: Int32 get_Tag()
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: System.String QualifiedName
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILScopeRef: System.String get_QualifiedName()
+FSharp.Compiler.AbstractIL.IL+ILSecurityDeclsStored: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILSourceDocument: Boolean Equals(ILSourceDocument)
+FSharp.Compiler.AbstractIL.IL+ILSourceDocument: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILSourceDocument: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILSourceDocument: ILSourceDocument Create(Microsoft.FSharp.Core.FSharpOption`1[System.Byte[]], Microsoft.FSharp.Core.FSharpOption`1[System.Byte[]], Microsoft.FSharp.Core.FSharpOption`1[System.Byte[]], System.String)
+FSharp.Compiler.AbstractIL.IL+ILSourceDocument: Int32 CompareTo(ILSourceDocument)
+FSharp.Compiler.AbstractIL.IL+ILSourceDocument: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILSourceDocument: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILSourceDocument: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILSourceDocument: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILSourceDocument: Microsoft.FSharp.Core.FSharpOption`1[System.Byte[]] DocumentType
+FSharp.Compiler.AbstractIL.IL+ILSourceDocument: Microsoft.FSharp.Core.FSharpOption`1[System.Byte[]] Language
+FSharp.Compiler.AbstractIL.IL+ILSourceDocument: Microsoft.FSharp.Core.FSharpOption`1[System.Byte[]] Vendor
+FSharp.Compiler.AbstractIL.IL+ILSourceDocument: Microsoft.FSharp.Core.FSharpOption`1[System.Byte[]] get_DocumentType()
+FSharp.Compiler.AbstractIL.IL+ILSourceDocument: Microsoft.FSharp.Core.FSharpOption`1[System.Byte[]] get_Language()
+FSharp.Compiler.AbstractIL.IL+ILSourceDocument: Microsoft.FSharp.Core.FSharpOption`1[System.Byte[]] get_Vendor()
+FSharp.Compiler.AbstractIL.IL+ILSourceDocument: System.String File
+FSharp.Compiler.AbstractIL.IL+ILSourceDocument: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILSourceDocument: System.String get_File()
+FSharp.Compiler.AbstractIL.IL+ILThisConvention+Tags: Int32 Instance
+FSharp.Compiler.AbstractIL.IL+ILThisConvention+Tags: Int32 InstanceExplicit
+FSharp.Compiler.AbstractIL.IL+ILThisConvention+Tags: Int32 Static
+FSharp.Compiler.AbstractIL.IL+ILThisConvention: Boolean Equals(ILThisConvention)
+FSharp.Compiler.AbstractIL.IL+ILThisConvention: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILThisConvention: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILThisConvention: Boolean IsInstance
+FSharp.Compiler.AbstractIL.IL+ILThisConvention: Boolean IsInstanceExplicit
+FSharp.Compiler.AbstractIL.IL+ILThisConvention: Boolean IsStatic
+FSharp.Compiler.AbstractIL.IL+ILThisConvention: Boolean get_IsInstance()
+FSharp.Compiler.AbstractIL.IL+ILThisConvention: Boolean get_IsInstanceExplicit()
+FSharp.Compiler.AbstractIL.IL+ILThisConvention: Boolean get_IsStatic()
+FSharp.Compiler.AbstractIL.IL+ILThisConvention: FSharp.Compiler.AbstractIL.IL+ILThisConvention+Tags
+FSharp.Compiler.AbstractIL.IL+ILThisConvention: ILThisConvention Instance
+FSharp.Compiler.AbstractIL.IL+ILThisConvention: ILThisConvention InstanceExplicit
+FSharp.Compiler.AbstractIL.IL+ILThisConvention: ILThisConvention Static
+FSharp.Compiler.AbstractIL.IL+ILThisConvention: ILThisConvention get_Instance()
+FSharp.Compiler.AbstractIL.IL+ILThisConvention: ILThisConvention get_InstanceExplicit()
+FSharp.Compiler.AbstractIL.IL+ILThisConvention: ILThisConvention get_Static()
+FSharp.Compiler.AbstractIL.IL+ILThisConvention: Int32 CompareTo(ILThisConvention)
+FSharp.Compiler.AbstractIL.IL+ILThisConvention: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILThisConvention: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILThisConvention: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILThisConvention: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILThisConvention: Int32 Tag
+FSharp.Compiler.AbstractIL.IL+ILThisConvention: Int32 get_Tag()
+FSharp.Compiler.AbstractIL.IL+ILThisConvention: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILType+Array: ILArrayShape Item1
+FSharp.Compiler.AbstractIL.IL+ILType+Array: ILArrayShape get_Item1()
+FSharp.Compiler.AbstractIL.IL+ILType+Array: ILType Item2
+FSharp.Compiler.AbstractIL.IL+ILType+Array: ILType get_Item2()
+FSharp.Compiler.AbstractIL.IL+ILType+Boxed: ILTypeSpec Item
+FSharp.Compiler.AbstractIL.IL+ILType+Boxed: ILTypeSpec get_Item()
+FSharp.Compiler.AbstractIL.IL+ILType+Byref: ILType Item
+FSharp.Compiler.AbstractIL.IL+ILType+Byref: ILType get_Item()
+FSharp.Compiler.AbstractIL.IL+ILType+FunctionPointer: ILCallingSignature Item
+FSharp.Compiler.AbstractIL.IL+ILType+FunctionPointer: ILCallingSignature get_Item()
+FSharp.Compiler.AbstractIL.IL+ILType+Modified: Boolean Item1
+FSharp.Compiler.AbstractIL.IL+ILType+Modified: Boolean get_Item1()
+FSharp.Compiler.AbstractIL.IL+ILType+Modified: ILType Item3
+FSharp.Compiler.AbstractIL.IL+ILType+Modified: ILType get_Item3()
+FSharp.Compiler.AbstractIL.IL+ILType+Modified: ILTypeRef Item2
+FSharp.Compiler.AbstractIL.IL+ILType+Modified: ILTypeRef get_Item2()
+FSharp.Compiler.AbstractIL.IL+ILType+Ptr: ILType Item
+FSharp.Compiler.AbstractIL.IL+ILType+Ptr: ILType get_Item()
+FSharp.Compiler.AbstractIL.IL+ILType+Tags: Int32 Array
+FSharp.Compiler.AbstractIL.IL+ILType+Tags: Int32 Boxed
+FSharp.Compiler.AbstractIL.IL+ILType+Tags: Int32 Byref
+FSharp.Compiler.AbstractIL.IL+ILType+Tags: Int32 FunctionPointer
+FSharp.Compiler.AbstractIL.IL+ILType+Tags: Int32 Modified
+FSharp.Compiler.AbstractIL.IL+ILType+Tags: Int32 Ptr
+FSharp.Compiler.AbstractIL.IL+ILType+Tags: Int32 TypeVar
+FSharp.Compiler.AbstractIL.IL+ILType+Tags: Int32 Value
+FSharp.Compiler.AbstractIL.IL+ILType+Tags: Int32 Void
+FSharp.Compiler.AbstractIL.IL+ILType+TypeVar: UInt16 Item
+FSharp.Compiler.AbstractIL.IL+ILType+TypeVar: UInt16 get_Item()
+FSharp.Compiler.AbstractIL.IL+ILType+Value: ILTypeSpec Item
+FSharp.Compiler.AbstractIL.IL+ILType+Value: ILTypeSpec get_Item()
+FSharp.Compiler.AbstractIL.IL+ILType: Boolean Equals(ILType)
+FSharp.Compiler.AbstractIL.IL+ILType: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILType: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILType: Boolean IsArray
+FSharp.Compiler.AbstractIL.IL+ILType: Boolean IsBoxed
+FSharp.Compiler.AbstractIL.IL+ILType: Boolean IsByref
+FSharp.Compiler.AbstractIL.IL+ILType: Boolean IsFunctionPointer
+FSharp.Compiler.AbstractIL.IL+ILType: Boolean IsModified
+FSharp.Compiler.AbstractIL.IL+ILType: Boolean IsNominal
+FSharp.Compiler.AbstractIL.IL+ILType: Boolean IsPtr
+FSharp.Compiler.AbstractIL.IL+ILType: Boolean IsTypeVar
+FSharp.Compiler.AbstractIL.IL+ILType: Boolean IsTyvar
+FSharp.Compiler.AbstractIL.IL+ILType: Boolean IsValue
+FSharp.Compiler.AbstractIL.IL+ILType: Boolean IsVoid
+FSharp.Compiler.AbstractIL.IL+ILType: Boolean get_IsArray()
+FSharp.Compiler.AbstractIL.IL+ILType: Boolean get_IsBoxed()
+FSharp.Compiler.AbstractIL.IL+ILType: Boolean get_IsByref()
+FSharp.Compiler.AbstractIL.IL+ILType: Boolean get_IsFunctionPointer()
+FSharp.Compiler.AbstractIL.IL+ILType: Boolean get_IsModified()
+FSharp.Compiler.AbstractIL.IL+ILType: Boolean get_IsNominal()
+FSharp.Compiler.AbstractIL.IL+ILType: Boolean get_IsPtr()
+FSharp.Compiler.AbstractIL.IL+ILType: Boolean get_IsTypeVar()
+FSharp.Compiler.AbstractIL.IL+ILType: Boolean get_IsTyvar()
+FSharp.Compiler.AbstractIL.IL+ILType: Boolean get_IsValue()
+FSharp.Compiler.AbstractIL.IL+ILType: Boolean get_IsVoid()
+FSharp.Compiler.AbstractIL.IL+ILType: FSharp.Compiler.AbstractIL.IL+ILType+Array
+FSharp.Compiler.AbstractIL.IL+ILType: FSharp.Compiler.AbstractIL.IL+ILType+Boxed
+FSharp.Compiler.AbstractIL.IL+ILType: FSharp.Compiler.AbstractIL.IL+ILType+Byref
+FSharp.Compiler.AbstractIL.IL+ILType: FSharp.Compiler.AbstractIL.IL+ILType+FunctionPointer
+FSharp.Compiler.AbstractIL.IL+ILType: FSharp.Compiler.AbstractIL.IL+ILType+Modified
+FSharp.Compiler.AbstractIL.IL+ILType: FSharp.Compiler.AbstractIL.IL+ILType+Ptr
+FSharp.Compiler.AbstractIL.IL+ILType: FSharp.Compiler.AbstractIL.IL+ILType+Tags
+FSharp.Compiler.AbstractIL.IL+ILType: FSharp.Compiler.AbstractIL.IL+ILType+TypeVar
+FSharp.Compiler.AbstractIL.IL+ILType: FSharp.Compiler.AbstractIL.IL+ILType+Value
+FSharp.Compiler.AbstractIL.IL+ILType: ILType NewArray(ILArrayShape, ILType)
+FSharp.Compiler.AbstractIL.IL+ILType: ILType NewBoxed(ILTypeSpec)
+FSharp.Compiler.AbstractIL.IL+ILType: ILType NewByref(ILType)
+FSharp.Compiler.AbstractIL.IL+ILType: ILType NewFunctionPointer(ILCallingSignature)
+FSharp.Compiler.AbstractIL.IL+ILType: ILType NewModified(Boolean, ILTypeRef, ILType)
+FSharp.Compiler.AbstractIL.IL+ILType: ILType NewPtr(ILType)
+FSharp.Compiler.AbstractIL.IL+ILType: ILType NewTypeVar(UInt16)
+FSharp.Compiler.AbstractIL.IL+ILType: ILType NewValue(ILTypeSpec)
+FSharp.Compiler.AbstractIL.IL+ILType: ILType Void
+FSharp.Compiler.AbstractIL.IL+ILType: ILType get_Void()
+FSharp.Compiler.AbstractIL.IL+ILType: ILTypeRef TypeRef
+FSharp.Compiler.AbstractIL.IL+ILType: ILTypeRef get_TypeRef()
+FSharp.Compiler.AbstractIL.IL+ILType: ILTypeSpec TypeSpec
+FSharp.Compiler.AbstractIL.IL+ILType: ILTypeSpec get_TypeSpec()
+FSharp.Compiler.AbstractIL.IL+ILType: Int32 CompareTo(ILType)
+FSharp.Compiler.AbstractIL.IL+ILType: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILType: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILType: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILType: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILType: Int32 Tag
+FSharp.Compiler.AbstractIL.IL+ILType: Int32 get_Tag()
+FSharp.Compiler.AbstractIL.IL+ILType: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType] GenericArgs
+FSharp.Compiler.AbstractIL.IL+ILType: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType] get_GenericArgs()
+FSharp.Compiler.AbstractIL.IL+ILType: System.String BasicQualifiedName
+FSharp.Compiler.AbstractIL.IL+ILType: System.String QualifiedName
+FSharp.Compiler.AbstractIL.IL+ILType: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILType: System.String get_BasicQualifiedName()
+FSharp.Compiler.AbstractIL.IL+ILType: System.String get_QualifiedName()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean HasSecurity
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean IsAbstract
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean IsClass
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean IsComInterop
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean IsDelegate
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean IsEnum
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean IsInterface
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean IsKnownToBeAttribute
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean IsSealed
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean IsSerializable
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean IsSpecialName
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean IsStruct
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean IsStructOrEnum
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean get_HasSecurity()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean get_IsAbstract()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean get_IsClass()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean get_IsComInterop()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean get_IsDelegate()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean get_IsEnum()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean get_IsInterface()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean get_IsKnownToBeAttribute()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean get_IsSealed()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean get_IsSerializable()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean get_IsSpecialName()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean get_IsStruct()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Boolean get_IsStructOrEnum()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: ILAttributes CustomAttrs
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: ILAttributes get_CustomAttrs()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: ILDefaultPInvokeEncoding Encoding
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: ILDefaultPInvokeEncoding get_Encoding()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: ILEventDefs Events
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: ILEventDefs get_Events()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: ILFieldDefs Fields
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: ILFieldDefs get_Fields()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: ILMethodDefs Methods
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: ILMethodDefs get_Methods()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: ILMethodImplDefs MethodImpls
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: ILMethodImplDefs get_MethodImpls()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: ILPropertyDefs Properties
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: ILPropertyDefs get_Properties()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: ILSecurityDecls SecurityDecls
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: ILSecurityDecls get_SecurityDecls()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: ILTypeDef With(Microsoft.FSharp.Core.FSharpOption`1[System.String], Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.TypeAttributes], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType]], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef]], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILType]], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILMethodDefs], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILTypeDefs], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILFieldDefs], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILMethodImplDefs], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILEventDefs], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILPropertyDefs], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILAttributes], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILSecurityDecls])
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: ILTypeDefAccess Access
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: ILTypeDefAccess get_Access()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: ILTypeDefLayout Layout
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: ILTypeDefLayout get_Layout()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: ILTypeDefs NestedTypes
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: ILTypeDefs get_NestedTypes()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef] GenericParams
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef] get_GenericParams()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType] Implements
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType] get_Implements()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILType] Extends
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILType] get_Extends()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: System.Reflection.TypeAttributes Attributes
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: System.Reflection.TypeAttributes get_Attributes()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: System.String Name
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: System.String get_Name()
+FSharp.Compiler.AbstractIL.IL+ILTypeDef: Void .ctor(System.String, System.Reflection.TypeAttributes, ILTypeDefLayout, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.AbstractIL.IL+ILType], ILMethodDefs, ILTypeDefs, ILFieldDefs, ILMethodImplDefs, ILEventDefs, ILPropertyDefs, Boolean, ILSecurityDecls, ILAttributes)
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess+Nested: ILMemberAccess Item
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess+Nested: ILMemberAccess get_Item()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess+Tags: Int32 Nested
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess+Tags: Int32 Private
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess+Tags: Int32 Public
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess: Boolean Equals(ILTypeDefAccess)
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess: Boolean IsNested
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess: Boolean IsPrivate
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess: Boolean IsPublic
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess: Boolean get_IsNested()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess: Boolean get_IsPrivate()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess: Boolean get_IsPublic()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess: FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess+Nested
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess: FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess+Tags
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess: ILTypeDefAccess NewNested(ILMemberAccess)
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess: ILTypeDefAccess Private
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess: ILTypeDefAccess Public
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess: ILTypeDefAccess get_Private()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess: ILTypeDefAccess get_Public()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess: Int32 CompareTo(ILTypeDefAccess)
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess: Int32 Tag
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess: Int32 get_Tag()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind+Tags: Int32 Class
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind+Tags: Int32 Delegate
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind+Tags: Int32 Enum
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind+Tags: Int32 Interface
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind+Tags: Int32 ValueType
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: Boolean Equals(ILTypeDefKind)
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: Boolean IsClass
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: Boolean IsDelegate
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: Boolean IsEnum
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: Boolean IsInterface
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: Boolean IsValueType
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: Boolean get_IsClass()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: Boolean get_IsDelegate()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: Boolean get_IsEnum()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: Boolean get_IsInterface()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: Boolean get_IsValueType()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: FSharp.Compiler.AbstractIL.IL+ILTypeDefKind+Tags
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: ILTypeDefKind Class
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: ILTypeDefKind Delegate
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: ILTypeDefKind Enum
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: ILTypeDefKind Interface
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: ILTypeDefKind ValueType
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: ILTypeDefKind get_Class()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: ILTypeDefKind get_Delegate()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: ILTypeDefKind get_Enum()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: ILTypeDefKind get_Interface()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: ILTypeDefKind get_ValueType()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: Int32 CompareTo(ILTypeDefKind)
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: Int32 Tag
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: Int32 get_Tag()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefKind: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout+Explicit: ILTypeDefLayoutInfo Item
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout+Explicit: ILTypeDefLayoutInfo get_Item()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout+Sequential: ILTypeDefLayoutInfo Item
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout+Sequential: ILTypeDefLayoutInfo get_Item()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout+Tags: Int32 Auto
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout+Tags: Int32 Explicit
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout+Tags: Int32 Sequential
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout: Boolean Equals(ILTypeDefLayout)
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout: Boolean IsAuto
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout: Boolean IsExplicit
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout: Boolean IsSequential
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout: Boolean get_IsAuto()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout: Boolean get_IsExplicit()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout: Boolean get_IsSequential()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout: FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout+Explicit
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout: FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout+Sequential
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout: FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout+Tags
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout: ILTypeDefLayout Auto
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout: ILTypeDefLayout NewExplicit(ILTypeDefLayoutInfo)
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout: ILTypeDefLayout NewSequential(ILTypeDefLayoutInfo)
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout: ILTypeDefLayout get_Auto()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout: Int32 CompareTo(ILTypeDefLayout)
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout: Int32 Tag
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout: Int32 get_Tag()
+FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILTypeInit+Tags: Int32 BeforeField
+FSharp.Compiler.AbstractIL.IL+ILTypeInit+Tags: Int32 OnAny
+FSharp.Compiler.AbstractIL.IL+ILTypeInit: Boolean Equals(ILTypeInit)
+FSharp.Compiler.AbstractIL.IL+ILTypeInit: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILTypeInit: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILTypeInit: Boolean IsBeforeField
+FSharp.Compiler.AbstractIL.IL+ILTypeInit: Boolean IsOnAny
+FSharp.Compiler.AbstractIL.IL+ILTypeInit: Boolean get_IsBeforeField()
+FSharp.Compiler.AbstractIL.IL+ILTypeInit: Boolean get_IsOnAny()
+FSharp.Compiler.AbstractIL.IL+ILTypeInit: FSharp.Compiler.AbstractIL.IL+ILTypeInit+Tags
+FSharp.Compiler.AbstractIL.IL+ILTypeInit: ILTypeInit BeforeField
+FSharp.Compiler.AbstractIL.IL+ILTypeInit: ILTypeInit OnAny
+FSharp.Compiler.AbstractIL.IL+ILTypeInit: ILTypeInit get_BeforeField()
+FSharp.Compiler.AbstractIL.IL+ILTypeInit: ILTypeInit get_OnAny()
+FSharp.Compiler.AbstractIL.IL+ILTypeInit: Int32 CompareTo(ILTypeInit)
+FSharp.Compiler.AbstractIL.IL+ILTypeInit: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILTypeInit: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILTypeInit: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILTypeInit: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILTypeInit: Int32 Tag
+FSharp.Compiler.AbstractIL.IL+ILTypeInit: Int32 get_Tag()
+FSharp.Compiler.AbstractIL.IL+ILTypeInit: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILTypeRef: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILTypeRef: ILScopeRef Scope
+FSharp.Compiler.AbstractIL.IL+ILTypeRef: ILScopeRef get_Scope()
+FSharp.Compiler.AbstractIL.IL+ILTypeRef: ILTypeRef Create(ILScopeRef, Microsoft.FSharp.Collections.FSharpList`1[System.String], System.String)
+FSharp.Compiler.AbstractIL.IL+ILTypeRef: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILTypeRef: Microsoft.FSharp.Collections.FSharpList`1[System.String] Enclosing
+FSharp.Compiler.AbstractIL.IL+ILTypeRef: Microsoft.FSharp.Collections.FSharpList`1[System.String] get_Enclosing()
+FSharp.Compiler.AbstractIL.IL+ILTypeRef: System.String BasicQualifiedName
+FSharp.Compiler.AbstractIL.IL+ILTypeRef: System.String FullName
+FSharp.Compiler.AbstractIL.IL+ILTypeRef: System.String Name
+FSharp.Compiler.AbstractIL.IL+ILTypeRef: System.String QualifiedName
+FSharp.Compiler.AbstractIL.IL+ILTypeRef: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILTypeRef: System.String get_BasicQualifiedName()
+FSharp.Compiler.AbstractIL.IL+ILTypeRef: System.String get_FullName()
+FSharp.Compiler.AbstractIL.IL+ILTypeRef: System.String get_Name()
+FSharp.Compiler.AbstractIL.IL+ILTypeRef: System.String get_QualifiedName()
+FSharp.Compiler.AbstractIL.IL+ILTypeSpec: Boolean Equals(ILTypeSpec)
+FSharp.Compiler.AbstractIL.IL+ILTypeSpec: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILTypeSpec: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILTypeSpec: ILScopeRef Scope
+FSharp.Compiler.AbstractIL.IL+ILTypeSpec: ILScopeRef get_Scope()
+FSharp.Compiler.AbstractIL.IL+ILTypeSpec: ILTypeRef TypeRef
+FSharp.Compiler.AbstractIL.IL+ILTypeSpec: ILTypeRef get_TypeRef()
+FSharp.Compiler.AbstractIL.IL+ILTypeSpec: ILTypeSpec Create(ILTypeRef, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType])
+FSharp.Compiler.AbstractIL.IL+ILTypeSpec: Int32 CompareTo(ILTypeSpec)
+FSharp.Compiler.AbstractIL.IL+ILTypeSpec: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILTypeSpec: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILTypeSpec: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILTypeSpec: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILTypeSpec: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType] GenericArgs
+FSharp.Compiler.AbstractIL.IL+ILTypeSpec: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILType] get_GenericArgs()
+FSharp.Compiler.AbstractIL.IL+ILTypeSpec: Microsoft.FSharp.Collections.FSharpList`1[System.String] Enclosing
+FSharp.Compiler.AbstractIL.IL+ILTypeSpec: Microsoft.FSharp.Collections.FSharpList`1[System.String] get_Enclosing()
+FSharp.Compiler.AbstractIL.IL+ILTypeSpec: System.String FullName
+FSharp.Compiler.AbstractIL.IL+ILTypeSpec: System.String Name
+FSharp.Compiler.AbstractIL.IL+ILTypeSpec: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILTypeSpec: System.String get_FullName()
+FSharp.Compiler.AbstractIL.IL+ILTypeSpec: System.String get_Name()
+FSharp.Compiler.AbstractIL.IL+ILVersionInfo: Boolean Equals(ILVersionInfo)
+FSharp.Compiler.AbstractIL.IL+ILVersionInfo: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILVersionInfo: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILVersionInfo: Int32 CompareTo(ILVersionInfo)
+FSharp.Compiler.AbstractIL.IL+ILVersionInfo: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+ILVersionInfo: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+ILVersionInfo: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+ILVersionInfo: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+ILVersionInfo: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+ILVersionInfo: UInt16 Build
+FSharp.Compiler.AbstractIL.IL+ILVersionInfo: UInt16 Major
+FSharp.Compiler.AbstractIL.IL+ILVersionInfo: UInt16 Minor
+FSharp.Compiler.AbstractIL.IL+ILVersionInfo: UInt16 Revision
+FSharp.Compiler.AbstractIL.IL+ILVersionInfo: UInt16 get_Build()
+FSharp.Compiler.AbstractIL.IL+ILVersionInfo: UInt16 get_Major()
+FSharp.Compiler.AbstractIL.IL+ILVersionInfo: UInt16 get_Minor()
+FSharp.Compiler.AbstractIL.IL+ILVersionInfo: UInt16 get_Revision()
+FSharp.Compiler.AbstractIL.IL+ILVersionInfo: Void .ctor(UInt16, UInt16, UInt16, UInt16)
+FSharp.Compiler.AbstractIL.IL+MethodBody+IL: System.Lazy`1[FSharp.Compiler.AbstractIL.IL+ILMethodBody] Item
+FSharp.Compiler.AbstractIL.IL+MethodBody+IL: System.Lazy`1[FSharp.Compiler.AbstractIL.IL+ILMethodBody] get_Item()
+FSharp.Compiler.AbstractIL.IL+MethodBody+PInvoke: System.Lazy`1[FSharp.Compiler.AbstractIL.IL+PInvokeMethod] Item
+FSharp.Compiler.AbstractIL.IL+MethodBody+PInvoke: System.Lazy`1[FSharp.Compiler.AbstractIL.IL+PInvokeMethod] get_Item()
+FSharp.Compiler.AbstractIL.IL+MethodBody+Tags: Int32 Abstract
+FSharp.Compiler.AbstractIL.IL+MethodBody+Tags: Int32 IL
+FSharp.Compiler.AbstractIL.IL+MethodBody+Tags: Int32 Native
+FSharp.Compiler.AbstractIL.IL+MethodBody+Tags: Int32 NotAvailable
+FSharp.Compiler.AbstractIL.IL+MethodBody+Tags: Int32 PInvoke
+FSharp.Compiler.AbstractIL.IL+MethodBody: Boolean Equals(MethodBody)
+FSharp.Compiler.AbstractIL.IL+MethodBody: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+MethodBody: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+MethodBody: Boolean IsAbstract
+FSharp.Compiler.AbstractIL.IL+MethodBody: Boolean IsIL
+FSharp.Compiler.AbstractIL.IL+MethodBody: Boolean IsNative
+FSharp.Compiler.AbstractIL.IL+MethodBody: Boolean IsNotAvailable
+FSharp.Compiler.AbstractIL.IL+MethodBody: Boolean IsPInvoke
+FSharp.Compiler.AbstractIL.IL+MethodBody: Boolean get_IsAbstract()
+FSharp.Compiler.AbstractIL.IL+MethodBody: Boolean get_IsIL()
+FSharp.Compiler.AbstractIL.IL+MethodBody: Boolean get_IsNative()
+FSharp.Compiler.AbstractIL.IL+MethodBody: Boolean get_IsNotAvailable()
+FSharp.Compiler.AbstractIL.IL+MethodBody: Boolean get_IsPInvoke()
+FSharp.Compiler.AbstractIL.IL+MethodBody: FSharp.Compiler.AbstractIL.IL+MethodBody+IL
+FSharp.Compiler.AbstractIL.IL+MethodBody: FSharp.Compiler.AbstractIL.IL+MethodBody+PInvoke
+FSharp.Compiler.AbstractIL.IL+MethodBody: FSharp.Compiler.AbstractIL.IL+MethodBody+Tags
+FSharp.Compiler.AbstractIL.IL+MethodBody: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+MethodBody: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+MethodBody: Int32 Tag
+FSharp.Compiler.AbstractIL.IL+MethodBody: Int32 get_Tag()
+FSharp.Compiler.AbstractIL.IL+MethodBody: MethodBody Abstract
+FSharp.Compiler.AbstractIL.IL+MethodBody: MethodBody Native
+FSharp.Compiler.AbstractIL.IL+MethodBody: MethodBody NewIL(System.Lazy`1[FSharp.Compiler.AbstractIL.IL+ILMethodBody])
+FSharp.Compiler.AbstractIL.IL+MethodBody: MethodBody NewPInvoke(System.Lazy`1[FSharp.Compiler.AbstractIL.IL+PInvokeMethod])
+FSharp.Compiler.AbstractIL.IL+MethodBody: MethodBody NotAvailable
+FSharp.Compiler.AbstractIL.IL+MethodBody: MethodBody get_Abstract()
+FSharp.Compiler.AbstractIL.IL+MethodBody: MethodBody get_Native()
+FSharp.Compiler.AbstractIL.IL+MethodBody: MethodBody get_NotAvailable()
+FSharp.Compiler.AbstractIL.IL+MethodBody: System.String ToString()
+FSharp.Compiler.AbstractIL.IL+PublicKey+PublicKey: Byte[] Item
+FSharp.Compiler.AbstractIL.IL+PublicKey+PublicKey: Byte[] get_Item()
+FSharp.Compiler.AbstractIL.IL+PublicKey+PublicKeyToken: Byte[] Item
+FSharp.Compiler.AbstractIL.IL+PublicKey+PublicKeyToken: Byte[] get_Item()
+FSharp.Compiler.AbstractIL.IL+PublicKey+Tags: Int32 PublicKey
+FSharp.Compiler.AbstractIL.IL+PublicKey+Tags: Int32 PublicKeyToken
+FSharp.Compiler.AbstractIL.IL+PublicKey: Boolean Equals(PublicKey)
+FSharp.Compiler.AbstractIL.IL+PublicKey: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.IL+PublicKey: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+PublicKey: Boolean IsKey
+FSharp.Compiler.AbstractIL.IL+PublicKey: Boolean IsKeyToken
+FSharp.Compiler.AbstractIL.IL+PublicKey: Boolean IsPublicKey
+FSharp.Compiler.AbstractIL.IL+PublicKey: Boolean IsPublicKeyToken
+FSharp.Compiler.AbstractIL.IL+PublicKey: Boolean get_IsKey()
+FSharp.Compiler.AbstractIL.IL+PublicKey: Boolean get_IsKeyToken()
+FSharp.Compiler.AbstractIL.IL+PublicKey: Boolean get_IsPublicKey()
+FSharp.Compiler.AbstractIL.IL+PublicKey: Boolean get_IsPublicKeyToken()
+FSharp.Compiler.AbstractIL.IL+PublicKey: Byte[] Key
+FSharp.Compiler.AbstractIL.IL+PublicKey: Byte[] KeyToken
+FSharp.Compiler.AbstractIL.IL+PublicKey: Byte[] get_Key()
+FSharp.Compiler.AbstractIL.IL+PublicKey: Byte[] get_KeyToken()
+FSharp.Compiler.AbstractIL.IL+PublicKey: FSharp.Compiler.AbstractIL.IL+PublicKey+PublicKey
+FSharp.Compiler.AbstractIL.IL+PublicKey: FSharp.Compiler.AbstractIL.IL+PublicKey+PublicKeyToken
+FSharp.Compiler.AbstractIL.IL+PublicKey: FSharp.Compiler.AbstractIL.IL+PublicKey+Tags
+FSharp.Compiler.AbstractIL.IL+PublicKey: Int32 CompareTo(PublicKey)
+FSharp.Compiler.AbstractIL.IL+PublicKey: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.IL+PublicKey: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.IL+PublicKey: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.IL+PublicKey: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.IL+PublicKey: Int32 Tag
+FSharp.Compiler.AbstractIL.IL+PublicKey: Int32 get_Tag()
+FSharp.Compiler.AbstractIL.IL+PublicKey: PublicKey KeyAsToken(Byte[])
+FSharp.Compiler.AbstractIL.IL+PublicKey: PublicKey NewPublicKey(Byte[])
+FSharp.Compiler.AbstractIL.IL+PublicKey: PublicKey NewPublicKeyToken(Byte[])
+FSharp.Compiler.AbstractIL.IL+PublicKey: System.String ToString()
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILArgConvention
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILArrayShape
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILAssemblyLongevity
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILAssemblyManifest
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILAssemblyRef
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILAttribElem
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILAttribute
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILAttributes
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILAttributesStored
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILCallingConv
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILCallingSignature
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILDebugImport
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILDebugImports
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILDefaultPInvokeEncoding
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILEventDef
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILEventDefs
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILExportedTypeOrForwarder
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILExportedTypesAndForwarders
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILFieldDef
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILFieldDefs
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILFieldInit
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILFieldRef
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILFieldSpec
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILGenericParameterDef
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILGenericVariance
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILMemberAccess
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILMethodDef
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILMethodDefs
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILMethodImplDef
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILMethodImplDefs
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILMethodRef
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILMethodSpec
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILModuleDef
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILModuleRef
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILNativeResource
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILNativeType
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILNestedExportedType
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILNestedExportedTypes
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILParameter
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILPlatform
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILPreTypeDef
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILPropertyDef
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILPropertyDefs
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILReferences
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILResources
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILReturn
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILScopeRef
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILSecurityDeclsStored
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILSourceDocument
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILThisConvention
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILType
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILTypeDef
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILTypeDefAccess
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILTypeDefKind
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILTypeDefLayout
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILTypeDefs
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILTypeInit
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILTypeRef
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILTypeSpec
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+ILVersionInfo
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+MethodBody
+FSharp.Compiler.AbstractIL.IL: FSharp.Compiler.AbstractIL.IL+PublicKey
+FSharp.Compiler.AbstractIL.IL: ILAttributes emptyILCustomAttrs
+FSharp.Compiler.AbstractIL.IL: ILAttributes get_emptyILCustomAttrs()
+FSharp.Compiler.AbstractIL.IL: ILAttributes mkILCustomAttrs(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILAttribute])
+FSharp.Compiler.AbstractIL.IL: ILAttributes mkILCustomAttrsFromArray(ILAttribute[])
+FSharp.Compiler.AbstractIL.IL: ILAttributesStored storeILCustomAttrs(ILAttributes)
+FSharp.Compiler.AbstractIL.IL: ILEventDefs emptyILEvents
+FSharp.Compiler.AbstractIL.IL: ILEventDefs get_emptyILEvents()
+FSharp.Compiler.AbstractIL.IL: ILEventDefs mkILEvents(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILEventDef])
+FSharp.Compiler.AbstractIL.IL: ILEventDefs mkILEventsLazy(System.Lazy`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILEventDef]])
+FSharp.Compiler.AbstractIL.IL: ILExportedTypesAndForwarders mkILExportedTypes(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILExportedTypeOrForwarder])
+FSharp.Compiler.AbstractIL.IL: ILFieldDefs emptyILFields
+FSharp.Compiler.AbstractIL.IL: ILFieldDefs get_emptyILFields()
+FSharp.Compiler.AbstractIL.IL: ILFieldDefs mkILFields(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILFieldDef])
+FSharp.Compiler.AbstractIL.IL: ILFieldDefs mkILFieldsLazy(System.Lazy`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILFieldDef]])
+FSharp.Compiler.AbstractIL.IL: ILMethodDefs emptyILMethods
+FSharp.Compiler.AbstractIL.IL: ILMethodDefs get_emptyILMethods()
+FSharp.Compiler.AbstractIL.IL: ILMethodDefs mkILMethods(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILMethodDef])
+FSharp.Compiler.AbstractIL.IL: ILMethodDefs mkILMethodsComputed(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,FSharp.Compiler.AbstractIL.IL+ILMethodDef[]])
+FSharp.Compiler.AbstractIL.IL: ILMethodDefs mkILMethodsFromArray(ILMethodDef[])
+FSharp.Compiler.AbstractIL.IL: ILMethodImplDefs emptyILMethodImpls
+FSharp.Compiler.AbstractIL.IL: ILMethodImplDefs get_emptyILMethodImpls()
+FSharp.Compiler.AbstractIL.IL: ILMethodImplDefs mkILMethodImpls(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILMethodImplDef])
+FSharp.Compiler.AbstractIL.IL: ILMethodImplDefs mkILMethodImplsLazy(System.Lazy`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILMethodImplDef]])
+FSharp.Compiler.AbstractIL.IL: ILModuleDef mkILSimpleModule(System.String, System.String, Boolean, System.Tuple`2[System.Int32,System.Int32], Boolean, ILTypeDefs, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.String], Int32, ILExportedTypesAndForwarders, System.String)
+FSharp.Compiler.AbstractIL.IL: ILNestedExportedTypes mkILNestedExportedTypes(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILNestedExportedType])
+FSharp.Compiler.AbstractIL.IL: ILPropertyDefs emptyILProperties
+FSharp.Compiler.AbstractIL.IL: ILPropertyDefs get_emptyILProperties()
+FSharp.Compiler.AbstractIL.IL: ILPropertyDefs mkILProperties(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILPropertyDef])
+FSharp.Compiler.AbstractIL.IL: ILPropertyDefs mkILPropertiesLazy(System.Lazy`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILPropertyDef]])
+FSharp.Compiler.AbstractIL.IL: ILResources emptyILResources
+FSharp.Compiler.AbstractIL.IL: ILResources get_emptyILResources()
+FSharp.Compiler.AbstractIL.IL: ILReturn mkILReturn(ILType)
+FSharp.Compiler.AbstractIL.IL: ILSecurityDecls emptyILSecurityDecls
+FSharp.Compiler.AbstractIL.IL: ILSecurityDecls get_emptyILSecurityDecls()
+FSharp.Compiler.AbstractIL.IL: ILSecurityDecls mkILSecurityDecls(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILSecurityDecl])
+FSharp.Compiler.AbstractIL.IL: ILSecurityDeclsStored storeILSecurityDecls(ILSecurityDecls)
+FSharp.Compiler.AbstractIL.IL: ILTypeDefs emptyILTypeDefs
+FSharp.Compiler.AbstractIL.IL: ILTypeDefs get_emptyILTypeDefs()
+FSharp.Compiler.AbstractIL.IL: ILTypeDefs mkILTypeDefs(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILTypeDef])
+FSharp.Compiler.AbstractIL.IL: ILTypeDefs mkILTypeDefsComputed(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,FSharp.Compiler.AbstractIL.IL+ILPreTypeDef[]])
+FSharp.Compiler.AbstractIL.IL: ILTypeDefs mkILTypeDefsFromArray(ILTypeDef[])
+FSharp.Compiler.AbstractIL.IL: Int32 NoMetadataIdx
+FSharp.Compiler.AbstractIL.IL: Int32 get_NoMetadataIdx()
+FSharp.Compiler.AbstractIL.ILBinaryReader+ILModuleReader: ILModuleDef ILModuleDef
+FSharp.Compiler.AbstractIL.ILBinaryReader+ILModuleReader: ILModuleDef get_ILModuleDef()
+FSharp.Compiler.AbstractIL.ILBinaryReader+ILModuleReader: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILAssemblyRef] ILAssemblyRefs
+FSharp.Compiler.AbstractIL.ILBinaryReader+ILModuleReader: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.AbstractIL.IL+ILAssemblyRef] get_ILAssemblyRefs()
+FSharp.Compiler.AbstractIL.ILBinaryReader+ILReaderOptions: MetadataOnlyFlag get_metadataOnly()
+FSharp.Compiler.AbstractIL.ILBinaryReader+ILReaderOptions: MetadataOnlyFlag metadataOnly
+FSharp.Compiler.AbstractIL.ILBinaryReader+ILReaderOptions: Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[System.String,System.DateTime],Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Object,System.IntPtr,System.Int32]]] get_tryGetMetadataSnapshot()
+FSharp.Compiler.AbstractIL.ILBinaryReader+ILReaderOptions: Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[System.String,System.DateTime],Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Object,System.IntPtr,System.Int32]]] tryGetMetadataSnapshot
+FSharp.Compiler.AbstractIL.ILBinaryReader+ILReaderOptions: Microsoft.FSharp.Core.FSharpOption`1[System.String] get_pdbDirPath()
+FSharp.Compiler.AbstractIL.ILBinaryReader+ILReaderOptions: Microsoft.FSharp.Core.FSharpOption`1[System.String] pdbDirPath
+FSharp.Compiler.AbstractIL.ILBinaryReader+ILReaderOptions: ReduceMemoryFlag get_reduceMemoryUsage()
+FSharp.Compiler.AbstractIL.ILBinaryReader+ILReaderOptions: ReduceMemoryFlag reduceMemoryUsage
+FSharp.Compiler.AbstractIL.ILBinaryReader+ILReaderOptions: System.String ToString()
+FSharp.Compiler.AbstractIL.ILBinaryReader+ILReaderOptions: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[System.String], ReduceMemoryFlag, MetadataOnlyFlag, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[System.String,System.DateTime],Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Object,System.IntPtr,System.Int32]]])
+FSharp.Compiler.AbstractIL.ILBinaryReader+MetadataOnlyFlag+Tags: Int32 No
+FSharp.Compiler.AbstractIL.ILBinaryReader+MetadataOnlyFlag+Tags: Int32 Yes
+FSharp.Compiler.AbstractIL.ILBinaryReader+MetadataOnlyFlag: Boolean Equals(MetadataOnlyFlag)
+FSharp.Compiler.AbstractIL.ILBinaryReader+MetadataOnlyFlag: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.ILBinaryReader+MetadataOnlyFlag: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.ILBinaryReader+MetadataOnlyFlag: Boolean IsNo
+FSharp.Compiler.AbstractIL.ILBinaryReader+MetadataOnlyFlag: Boolean IsYes
+FSharp.Compiler.AbstractIL.ILBinaryReader+MetadataOnlyFlag: Boolean get_IsNo()
+FSharp.Compiler.AbstractIL.ILBinaryReader+MetadataOnlyFlag: Boolean get_IsYes()
+FSharp.Compiler.AbstractIL.ILBinaryReader+MetadataOnlyFlag: FSharp.Compiler.AbstractIL.ILBinaryReader+MetadataOnlyFlag+Tags
+FSharp.Compiler.AbstractIL.ILBinaryReader+MetadataOnlyFlag: Int32 CompareTo(MetadataOnlyFlag)
+FSharp.Compiler.AbstractIL.ILBinaryReader+MetadataOnlyFlag: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.ILBinaryReader+MetadataOnlyFlag: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.ILBinaryReader+MetadataOnlyFlag: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.ILBinaryReader+MetadataOnlyFlag: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.ILBinaryReader+MetadataOnlyFlag: Int32 Tag
+FSharp.Compiler.AbstractIL.ILBinaryReader+MetadataOnlyFlag: Int32 get_Tag()
+FSharp.Compiler.AbstractIL.ILBinaryReader+MetadataOnlyFlag: MetadataOnlyFlag No
+FSharp.Compiler.AbstractIL.ILBinaryReader+MetadataOnlyFlag: MetadataOnlyFlag Yes
+FSharp.Compiler.AbstractIL.ILBinaryReader+MetadataOnlyFlag: MetadataOnlyFlag get_No()
+FSharp.Compiler.AbstractIL.ILBinaryReader+MetadataOnlyFlag: MetadataOnlyFlag get_Yes()
+FSharp.Compiler.AbstractIL.ILBinaryReader+MetadataOnlyFlag: System.String ToString()
+FSharp.Compiler.AbstractIL.ILBinaryReader+ReduceMemoryFlag+Tags: Int32 No
+FSharp.Compiler.AbstractIL.ILBinaryReader+ReduceMemoryFlag+Tags: Int32 Yes
+FSharp.Compiler.AbstractIL.ILBinaryReader+ReduceMemoryFlag: Boolean Equals(ReduceMemoryFlag)
+FSharp.Compiler.AbstractIL.ILBinaryReader+ReduceMemoryFlag: Boolean Equals(System.Object)
+FSharp.Compiler.AbstractIL.ILBinaryReader+ReduceMemoryFlag: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.ILBinaryReader+ReduceMemoryFlag: Boolean IsNo
+FSharp.Compiler.AbstractIL.ILBinaryReader+ReduceMemoryFlag: Boolean IsYes
+FSharp.Compiler.AbstractIL.ILBinaryReader+ReduceMemoryFlag: Boolean get_IsNo()
+FSharp.Compiler.AbstractIL.ILBinaryReader+ReduceMemoryFlag: Boolean get_IsYes()
+FSharp.Compiler.AbstractIL.ILBinaryReader+ReduceMemoryFlag: FSharp.Compiler.AbstractIL.ILBinaryReader+ReduceMemoryFlag+Tags
+FSharp.Compiler.AbstractIL.ILBinaryReader+ReduceMemoryFlag: Int32 CompareTo(ReduceMemoryFlag)
+FSharp.Compiler.AbstractIL.ILBinaryReader+ReduceMemoryFlag: Int32 CompareTo(System.Object)
+FSharp.Compiler.AbstractIL.ILBinaryReader+ReduceMemoryFlag: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.AbstractIL.ILBinaryReader+ReduceMemoryFlag: Int32 GetHashCode()
+FSharp.Compiler.AbstractIL.ILBinaryReader+ReduceMemoryFlag: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.AbstractIL.ILBinaryReader+ReduceMemoryFlag: Int32 Tag
+FSharp.Compiler.AbstractIL.ILBinaryReader+ReduceMemoryFlag: Int32 get_Tag()
+FSharp.Compiler.AbstractIL.ILBinaryReader+ReduceMemoryFlag: ReduceMemoryFlag No
+FSharp.Compiler.AbstractIL.ILBinaryReader+ReduceMemoryFlag: ReduceMemoryFlag Yes
+FSharp.Compiler.AbstractIL.ILBinaryReader+ReduceMemoryFlag: ReduceMemoryFlag get_No()
+FSharp.Compiler.AbstractIL.ILBinaryReader+ReduceMemoryFlag: ReduceMemoryFlag get_Yes()
+FSharp.Compiler.AbstractIL.ILBinaryReader+ReduceMemoryFlag: System.String ToString()
+FSharp.Compiler.AbstractIL.ILBinaryReader+Shim+IAssemblyReader: ILModuleReader GetILModuleReader(System.String, ILReaderOptions)
+FSharp.Compiler.AbstractIL.ILBinaryReader+Shim: FSharp.Compiler.AbstractIL.ILBinaryReader+Shim+IAssemblyReader
+FSharp.Compiler.AbstractIL.ILBinaryReader+Shim: IAssemblyReader AssemblyReader
+FSharp.Compiler.AbstractIL.ILBinaryReader+Shim: IAssemblyReader get_AssemblyReader()
+FSharp.Compiler.AbstractIL.ILBinaryReader+Shim: Void set_AssemblyReader(IAssemblyReader)
+FSharp.Compiler.AbstractIL.ILBinaryReader: FSharp.Compiler.AbstractIL.ILBinaryReader+ILModuleReader
+FSharp.Compiler.AbstractIL.ILBinaryReader: FSharp.Compiler.AbstractIL.ILBinaryReader+ILReaderOptions
+FSharp.Compiler.AbstractIL.ILBinaryReader: FSharp.Compiler.AbstractIL.ILBinaryReader+MetadataOnlyFlag
+FSharp.Compiler.AbstractIL.ILBinaryReader: FSharp.Compiler.AbstractIL.ILBinaryReader+ReduceMemoryFlag
+FSharp.Compiler.AbstractIL.ILBinaryReader: FSharp.Compiler.AbstractIL.ILBinaryReader+Shim
+FSharp.Compiler.CodeAnalysis.DocumentSource+Custom: Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.ISourceText]] Item
+FSharp.Compiler.CodeAnalysis.DocumentSource+Custom: Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.ISourceText]] get_Item()
+FSharp.Compiler.CodeAnalysis.DocumentSource+Tags: Int32 Custom
+FSharp.Compiler.CodeAnalysis.DocumentSource+Tags: Int32 FileSystem
+FSharp.Compiler.CodeAnalysis.DocumentSource: Boolean IsCustom
+FSharp.Compiler.CodeAnalysis.DocumentSource: Boolean IsFileSystem
+FSharp.Compiler.CodeAnalysis.DocumentSource: Boolean get_IsCustom()
+FSharp.Compiler.CodeAnalysis.DocumentSource: Boolean get_IsFileSystem()
+FSharp.Compiler.CodeAnalysis.DocumentSource: FSharp.Compiler.CodeAnalysis.DocumentSource FileSystem
+FSharp.Compiler.CodeAnalysis.DocumentSource: FSharp.Compiler.CodeAnalysis.DocumentSource NewCustom(Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.ISourceText]])
+FSharp.Compiler.CodeAnalysis.DocumentSource: FSharp.Compiler.CodeAnalysis.DocumentSource get_FileSystem()
+FSharp.Compiler.CodeAnalysis.DocumentSource: FSharp.Compiler.CodeAnalysis.DocumentSource+Custom
+FSharp.Compiler.CodeAnalysis.DocumentSource: FSharp.Compiler.CodeAnalysis.DocumentSource+Tags
+FSharp.Compiler.CodeAnalysis.DocumentSource: Int32 Tag
+FSharp.Compiler.CodeAnalysis.DocumentSource: Int32 get_Tag()
+FSharp.Compiler.CodeAnalysis.DocumentSource: System.String ToString()
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer+Succeeded: FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults Item
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer+Succeeded: FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults get_Item()
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer+Tags: Int32 Aborted
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer+Tags: Int32 Succeeded
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer: Boolean Equals(FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer)
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer: Boolean Equals(System.Object)
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer: Boolean IsAborted
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer: Boolean IsSucceeded
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer: Boolean get_IsAborted()
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer: Boolean get_IsSucceeded()
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer: FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer Aborted
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer: FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer NewSucceeded(FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults)
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer: FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer get_Aborted()
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer: FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer+Succeeded
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer: FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer+Tags
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer: Int32 GetHashCode()
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer: Int32 Tag
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer: Int32 get_Tag()
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer: System.String ToString()
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: Boolean HasFullTypeCheckInfo
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: Boolean IsRelativeNameResolvableFromSymbol(FSharp.Compiler.Text.Position, Microsoft.FSharp.Collections.FSharpList`1[System.String], FSharp.Compiler.Symbols.FSharpSymbol)
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: Boolean get_HasFullTypeCheckInfo()
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: FSharp.Compiler.CodeAnalysis.FSharpProjectContext ProjectContext
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: FSharp.Compiler.CodeAnalysis.FSharpProjectContext get_ProjectContext()
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: FSharp.Compiler.CodeAnalysis.FSharpSymbolUse[] GetUsesOfSymbolInFile(FSharp.Compiler.Symbols.FSharpSymbol, Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: FSharp.Compiler.Diagnostics.FSharpDiagnostic[] Diagnostics
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: FSharp.Compiler.Diagnostics.FSharpDiagnostic[] get_Diagnostics()
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: FSharp.Compiler.EditorServices.DeclarationListInfo GetDeclarationListInfo(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.CodeAnalysis.FSharpParseFileResults], Int32, System.String, FSharp.Compiler.EditorServices.PartialLongName, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.AssemblySymbol]]], Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Text.Position,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.EditorServices.CompletionContext]]])
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: FSharp.Compiler.EditorServices.FindDeclResult GetDeclarationLocation(Int32, Int32, System.String, Microsoft.FSharp.Collections.FSharpList`1[System.String], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: FSharp.Compiler.EditorServices.MethodGroup GetMethods(Int32, Int32, System.String, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[System.String]])
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: FSharp.Compiler.EditorServices.SemanticClassificationItem[] GetSemanticClassification(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: FSharp.Compiler.EditorServices.ToolTipText GetDescription(FSharp.Compiler.Symbols.FSharpSymbol, Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpGenericParameter,FSharp.Compiler.Symbols.FSharpType]], Boolean, FSharp.Compiler.Text.Range)
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: FSharp.Compiler.EditorServices.ToolTipText GetKeywordTooltip(Microsoft.FSharp.Collections.FSharpList`1[System.String])
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: FSharp.Compiler.EditorServices.ToolTipText GetToolTip(Int32, Int32, System.String, Microsoft.FSharp.Collections.FSharpList`1[System.String], Int32)
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: FSharp.Compiler.Symbols.FSharpAssemblySignature PartialAssemblySignature
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: FSharp.Compiler.Symbols.FSharpAssemblySignature get_PartialAssemblySignature()
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: FSharp.Compiler.Symbols.FSharpOpenDeclaration[] OpenDeclarations
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: FSharp.Compiler.Symbols.FSharpOpenDeclaration[] get_OpenDeclarations()
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: FSharp.Compiler.Text.Range[] GetFormatSpecifierLocations()
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.CodeAnalysis.FSharpSymbolUse]] GetDeclarationListSymbols(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.CodeAnalysis.FSharpParseFileResults], Int32, System.String, FSharp.Compiler.EditorServices.PartialLongName, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.AssemblySymbol]]])
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.CodeAnalysis.FSharpSymbolUse] GetSymbolUseAtLocation(Int32, Int32, System.String, Microsoft.FSharp.Collections.FSharpList`1[System.String])
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpDisplayContext] GetDisplayContextForPos(FSharp.Compiler.Text.Position)
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpImplementationFileContents] ImplementationFile
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpImplementationFileContents] get_ImplementationFile()
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.ISourceText] GenerateSignature(Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.CodeAnalysis.FSharpSymbolUse]] GetMethodsAsSymbols(Int32, Int32, System.String, Microsoft.FSharp.Collections.FSharpList`1[System.String])
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: Microsoft.FSharp.Core.FSharpOption`1[System.String] GetF1Keyword(Int32, Int32, System.String, Microsoft.FSharp.Collections.FSharpList`1[System.String])
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: System.Collections.Generic.IEnumerable`1[FSharp.Compiler.CodeAnalysis.FSharpSymbolUse] GetAllUsesOfAllSymbolsInFile(Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: System.String ToString()
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: System.String[] DependencyFiles
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: System.String[] get_DependencyFiles()
+FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults: System.Tuple`2[FSharp.Compiler.Text.Range,System.Int32][] GetFormatSpecifierLocationsAndArity()
+FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults: Boolean HasCriticalErrors
+FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults: Boolean get_HasCriticalErrors()
+FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults: FSharp.Compiler.CodeAnalysis.FSharpProjectContext ProjectContext
+FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults: FSharp.Compiler.CodeAnalysis.FSharpProjectContext get_ProjectContext()
+FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults: FSharp.Compiler.CodeAnalysis.FSharpSymbolUse[] GetAllUsesOfAllSymbols(Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults: FSharp.Compiler.CodeAnalysis.FSharpSymbolUse[] GetUsesOfSymbol(FSharp.Compiler.Symbols.FSharpSymbol, Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults: FSharp.Compiler.Diagnostics.FSharpDiagnostic[] Diagnostics
+FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults: FSharp.Compiler.Diagnostics.FSharpDiagnostic[] get_Diagnostics()
+FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults: FSharp.Compiler.Symbols.FSharpAssemblyContents AssemblyContents
+FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults: FSharp.Compiler.Symbols.FSharpAssemblyContents GetOptimizedAssemblyContents()
+FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults: FSharp.Compiler.Symbols.FSharpAssemblyContents get_AssemblyContents()
+FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults: FSharp.Compiler.Symbols.FSharpAssemblySignature AssemblySignature
+FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults: FSharp.Compiler.Symbols.FSharpAssemblySignature get_AssemblySignature()
+FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults: System.String ToString()
+FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults: System.String[] DependencyFiles
+FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults: System.String[] get_DependencyFiles()
+FSharp.Compiler.CodeAnalysis.FSharpChecker: FSharp.Compiler.CodeAnalysis.FSharpChecker Create(Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.CodeAnalysis.LegacyReferenceResolver], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[System.String,System.DateTime],Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Object,System.IntPtr,System.Int32]]]], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.CodeAnalysis.DocumentSource])
+FSharp.Compiler.CodeAnalysis.FSharpChecker: FSharp.Compiler.CodeAnalysis.FSharpChecker Instance
+FSharp.Compiler.CodeAnalysis.FSharpChecker: FSharp.Compiler.CodeAnalysis.FSharpChecker get_Instance()
+FSharp.Compiler.CodeAnalysis.FSharpChecker: FSharp.Compiler.CodeAnalysis.FSharpProjectOptions GetProjectOptionsFromCommandLineArgs(System.String, System.String[], Microsoft.FSharp.Core.FSharpOption`1[System.DateTime], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+FSharp.Compiler.CodeAnalysis.FSharpChecker: FSharp.Compiler.Tokenization.FSharpTokenInfo[][] TokenizeFile(System.String)
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Int32 ActualCheckFileCount
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Int32 ActualParseFileCount
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Int32 get_ActualCheckFileCount()
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Int32 get_ActualParseFileCount()
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer] CheckFileInProject(FSharp.Compiler.CodeAnalysis.FSharpParseFileResults, System.String, Int32, FSharp.Compiler.Text.ISourceText, FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults] ParseAndCheckProject(FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[FSharp.Compiler.CodeAnalysis.FSharpParseFileResults] GetBackgroundParseResultsForFileInProject(System.String, FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[FSharp.Compiler.CodeAnalysis.FSharpParseFileResults] ParseFile(System.String, FSharp.Compiler.Text.ISourceText, FSharp.Compiler.CodeAnalysis.FSharpParsingOptions, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[FSharp.Compiler.CodeAnalysis.FSharpParseFileResults] ParseFileInProject(System.String, System.String, FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer]] CheckFileInProjectAllowingStaleCachedResults(FSharp.Compiler.CodeAnalysis.FSharpParseFileResults, System.String, Int32, System.String, FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.EditorServices.SemanticClassificationView]] GetBackgroundSemanticClassificationForFile(System.String, FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] NotifyFileChanged(System.String, FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] NotifyProjectCleaned(FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[System.Collections.Generic.IEnumerable`1[FSharp.Compiler.Text.Range]] FindBackgroundReferencesInFile(System.String, FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, FSharp.Compiler.Symbols.FSharpSymbol, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[System.Tuple`2[FSharp.Compiler.CodeAnalysis.FSharpParseFileResults,FSharp.Compiler.CodeAnalysis.FSharpCheckFileAnswer]] ParseAndCheckFileInProject(System.String, Int32, FSharp.Compiler.Text.ISourceText, FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[System.Tuple`2[FSharp.Compiler.CodeAnalysis.FSharpParseFileResults,FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults]] GetBackgroundCheckResultsForFileInProject(System.String, FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[System.Tuple`2[FSharp.Compiler.CodeAnalysis.FSharpProjectOptions,Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Diagnostics.FSharpDiagnostic]]] GetProjectOptionsFromScript(System.String, FSharp.Compiler.Text.ISourceText, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.DateTime], Microsoft.FSharp.Core.FSharpOption`1[System.String[]], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.String], Microsoft.FSharp.Core.FSharpOption`1[System.Int64], Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[System.Tuple`2[FSharp.Compiler.Diagnostics.FSharpDiagnostic[],System.Int32]] Compile(System.String[], Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[System.Tuple`2[FSharp.Compiler.Text.Range,FSharp.Compiler.Text.Range][]] MatchBraces(System.String, FSharp.Compiler.Text.ISourceText, FSharp.Compiler.CodeAnalysis.FSharpParsingOptions, Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[System.Tuple`2[FSharp.Compiler.Text.Range,FSharp.Compiler.Text.Range][]] MatchBraces(System.String, System.String, FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[FSharp.Compiler.CodeAnalysis.FSharpProjectOptions],FSharp.Compiler.CodeAnalysis.FSharpProjectOptions] ProjectChecked
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[FSharp.Compiler.CodeAnalysis.FSharpProjectOptions],FSharp.Compiler.CodeAnalysis.FSharpProjectOptions] get_ProjectChecked()
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[System.Tuple`2[System.String,FSharp.Compiler.CodeAnalysis.FSharpProjectOptions]],System.Tuple`2[System.String,FSharp.Compiler.CodeAnalysis.FSharpProjectOptions]] BeforeBackgroundFileCheck
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[System.Tuple`2[System.String,FSharp.Compiler.CodeAnalysis.FSharpProjectOptions]],System.Tuple`2[System.String,FSharp.Compiler.CodeAnalysis.FSharpProjectOptions]] FileChecked
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[System.Tuple`2[System.String,FSharp.Compiler.CodeAnalysis.FSharpProjectOptions]],System.Tuple`2[System.String,FSharp.Compiler.CodeAnalysis.FSharpProjectOptions]] FileParsed
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[System.Tuple`2[System.String,FSharp.Compiler.CodeAnalysis.FSharpProjectOptions]],System.Tuple`2[System.String,FSharp.Compiler.CodeAnalysis.FSharpProjectOptions]] get_BeforeBackgroundFileCheck()
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[System.Tuple`2[System.String,FSharp.Compiler.CodeAnalysis.FSharpProjectOptions]],System.Tuple`2[System.String,FSharp.Compiler.CodeAnalysis.FSharpProjectOptions]] get_FileChecked()
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[System.Tuple`2[System.String,FSharp.Compiler.CodeAnalysis.FSharpProjectOptions]],System.Tuple`2[System.String,FSharp.Compiler.CodeAnalysis.FSharpProjectOptions]] get_FileParsed()
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[FSharp.Compiler.CodeAnalysis.FSharpParseFileResults,FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults,System.Int64]] TryGetRecentCheckResultsForFile(System.String, FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.ISourceText], Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.CodeAnalysis.FSharpChecker: System.Tuple`2[FSharp.Compiler.CodeAnalysis.FSharpParsingOptions,Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Diagnostics.FSharpDiagnostic]] GetParsingOptionsFromCommandLineArgs(Microsoft.FSharp.Collections.FSharpList`1[System.String], Microsoft.FSharp.Collections.FSharpList`1[System.String], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+FSharp.Compiler.CodeAnalysis.FSharpChecker: System.Tuple`2[FSharp.Compiler.CodeAnalysis.FSharpParsingOptions,Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Diagnostics.FSharpDiagnostic]] GetParsingOptionsFromCommandLineArgs(Microsoft.FSharp.Collections.FSharpList`1[System.String], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+FSharp.Compiler.CodeAnalysis.FSharpChecker: System.Tuple`2[FSharp.Compiler.CodeAnalysis.FSharpParsingOptions,Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Diagnostics.FSharpDiagnostic]] GetParsingOptionsFromProjectOptions(FSharp.Compiler.CodeAnalysis.FSharpProjectOptions)
+FSharp.Compiler.CodeAnalysis.FSharpChecker: System.Tuple`2[FSharp.Compiler.Tokenization.FSharpTokenInfo[],FSharp.Compiler.Tokenization.FSharpTokenizerLexState] TokenizeLine(System.String, FSharp.Compiler.Tokenization.FSharpTokenizerLexState)
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Void ClearCache(System.Collections.Generic.IEnumerable`1[FSharp.Compiler.CodeAnalysis.FSharpProjectOptions], Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Void ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients()
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Void InvalidateAll()
+FSharp.Compiler.CodeAnalysis.FSharpChecker: Void InvalidateConfiguration(FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: Boolean IsBindingALambdaAtPosition(FSharp.Compiler.Text.Position)
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: Boolean IsPosContainedInApplication(FSharp.Compiler.Text.Position)
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: Boolean IsPositionContainedInACurriedParameter(FSharp.Compiler.Text.Position)
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: Boolean IsTypeAnnotationGivenAtPosition(FSharp.Compiler.Text.Position)
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: Boolean ParseHadErrors
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: Boolean get_ParseHadErrors()
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: FSharp.Compiler.Diagnostics.FSharpDiagnostic[] Diagnostics
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: FSharp.Compiler.Diagnostics.FSharpDiagnostic[] get_Diagnostics()
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: FSharp.Compiler.EditorServices.NavigationItems GetNavigationItems()
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: FSharp.Compiler.Syntax.ParsedInput ParseTree
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: FSharp.Compiler.Syntax.ParsedInput get_ParseTree()
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.EditorServices.ParameterLocations] FindParameterLocations(FSharp.Compiler.Text.Position)
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] TryRangeOfExprInYieldOrReturn(FSharp.Compiler.Text.Position)
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] TryRangeOfExpressionBeingDereferencedContainingPos(FSharp.Compiler.Text.Position)
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] TryRangeOfFunctionOrMethodBeingApplied(FSharp.Compiler.Text.Position)
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] TryRangeOfNameOfNearestOuterBindingContainingPos(FSharp.Compiler.Text.Position)
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] TryRangeOfRecordExpressionContainingPos(FSharp.Compiler.Text.Position)
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] TryRangeOfRefCellDereferenceContainingPos(FSharp.Compiler.Text.Position)
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] TryRangeOfStringInterpolationContainingPos(FSharp.Compiler.Text.Position)
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] ValidateBreakpointLocation(FSharp.Compiler.Text.Position)
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.Range]] GetAllArgumentsForFunctionApplicationAtPosition(FSharp.Compiler.Text.Position)
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Syntax.Ident,System.Int32]] TryIdentOfPipelineContainingPosAndNumArgsApplied(FSharp.Compiler.Text.Position)
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[FSharp.Compiler.Text.Range,FSharp.Compiler.Text.Range,FSharp.Compiler.Text.Range]] TryRangeOfParenEnclosingOpEqualsGreaterUsage(FSharp.Compiler.Text.Position)
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: System.String FileName
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: System.String get_FileName()
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: System.String[] DependencyFiles
+FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: System.String[] get_DependencyFiles()
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean ApplyLineDirectives
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean CompilingFSharpCore
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean Equals(FSharp.Compiler.CodeAnalysis.FSharpParsingOptions)
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean Equals(System.Object)
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean IsExe
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean IsInteractive
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean get_ApplyLineDirectives()
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean get_CompilingFSharpCore()
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean get_IsExe()
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean get_IsInteractive()
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: FSharp.Compiler.CodeAnalysis.FSharpParsingOptions Default
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: FSharp.Compiler.CodeAnalysis.FSharpParsingOptions get_Default()
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions DiagnosticOptions
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions get_DiagnosticOptions()
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Int32 CompareTo(FSharp.Compiler.CodeAnalysis.FSharpParsingOptions)
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Int32 CompareTo(System.Object)
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Int32 GetHashCode()
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Microsoft.FSharp.Collections.FSharpList`1[System.String] ConditionalDefines
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Microsoft.FSharp.Collections.FSharpList`1[System.String] get_ConditionalDefines()
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Microsoft.FSharp.Core.FSharpOption`1[System.Boolean] IndentationAwareSyntax
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Microsoft.FSharp.Core.FSharpOption`1[System.Boolean] get_IndentationAwareSyntax()
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: System.String LangVersionText
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: System.String ToString()
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: System.String get_LangVersionText()
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: System.String[] SourceFiles
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: System.String[] get_SourceFiles()
+FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Void .ctor(System.String[], Boolean, Microsoft.FSharp.Collections.FSharpList`1[System.String], FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions, System.String, Boolean, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Boolean, Boolean)
+FSharp.Compiler.CodeAnalysis.FSharpProjectContext: FSharp.Compiler.CodeAnalysis.FSharpProjectOptions ProjectOptions
+FSharp.Compiler.CodeAnalysis.FSharpProjectContext: FSharp.Compiler.CodeAnalysis.FSharpProjectOptions get_ProjectOptions()
+FSharp.Compiler.CodeAnalysis.FSharpProjectContext: FSharp.Compiler.Symbols.FSharpAccessibilityRights AccessibilityRights
+FSharp.Compiler.CodeAnalysis.FSharpProjectContext: FSharp.Compiler.Symbols.FSharpAccessibilityRights get_AccessibilityRights()
+FSharp.Compiler.CodeAnalysis.FSharpProjectContext: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpAssembly] GetReferencedAssemblies()
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: Boolean Equals(FSharp.Compiler.CodeAnalysis.FSharpProjectOptions)
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: Boolean Equals(System.Object)
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: Boolean IsIncompleteTypeCheckEnvironment
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: Boolean UseScriptResolutionRules
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: Boolean get_IsIncompleteTypeCheckEnvironment()
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: Boolean get_UseScriptResolutionRules()
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: FSharp.Compiler.CodeAnalysis.FSharpReferencedProject[] ReferencedProjects
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: FSharp.Compiler.CodeAnalysis.FSharpReferencedProject[] get_ReferencedProjects()
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: Int32 GetHashCode()
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[FSharp.Compiler.Text.Range,System.String,System.String]] OriginalLoadReferences
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[FSharp.Compiler.Text.Range,System.String,System.String]] get_OriginalLoadReferences()
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.CodeAnalysis.FSharpUnresolvedReferencesSet] UnresolvedReferences
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.CodeAnalysis.FSharpUnresolvedReferencesSet] get_UnresolvedReferences()
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: Microsoft.FSharp.Core.FSharpOption`1[System.Int64] Stamp
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: Microsoft.FSharp.Core.FSharpOption`1[System.Int64] get_Stamp()
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: Microsoft.FSharp.Core.FSharpOption`1[System.String] ProjectId
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: Microsoft.FSharp.Core.FSharpOption`1[System.String] get_ProjectId()
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: System.DateTime LoadTime
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: System.DateTime get_LoadTime()
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: System.String ProjectFileName
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: System.String ToString()
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: System.String get_ProjectFileName()
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: System.String[] OtherOptions
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: System.String[] SourceFiles
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: System.String[] get_OtherOptions()
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: System.String[] get_SourceFiles()
+FSharp.Compiler.CodeAnalysis.FSharpProjectOptions: Void .ctor(System.String, Microsoft.FSharp.Core.FSharpOption`1[System.String], System.String[], System.String[], FSharp.Compiler.CodeAnalysis.FSharpReferencedProject[], Boolean, Boolean, System.DateTime, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.CodeAnalysis.FSharpUnresolvedReferencesSet], Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[FSharp.Compiler.Text.Range,System.String,System.String]], Microsoft.FSharp.Core.FSharpOption`1[System.Int64])
+FSharp.Compiler.CodeAnalysis.FSharpReferencedProject: Boolean Equals(System.Object)
+FSharp.Compiler.CodeAnalysis.FSharpReferencedProject: FSharp.Compiler.CodeAnalysis.FSharpReferencedProject CreateFSharp(System.String, FSharp.Compiler.CodeAnalysis.FSharpProjectOptions)
+FSharp.Compiler.CodeAnalysis.FSharpReferencedProject: FSharp.Compiler.CodeAnalysis.FSharpReferencedProject CreateFromILModuleReader(System.String, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.DateTime], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,FSharp.Compiler.AbstractIL.ILBinaryReader+ILModuleReader])
+FSharp.Compiler.CodeAnalysis.FSharpReferencedProject: FSharp.Compiler.CodeAnalysis.FSharpReferencedProject CreatePortableExecutable(System.String, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.DateTime], Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,Microsoft.FSharp.Core.FSharpOption`1[System.IO.Stream]])
+FSharp.Compiler.CodeAnalysis.FSharpReferencedProject: Int32 GetHashCode()
+FSharp.Compiler.CodeAnalysis.FSharpReferencedProject: System.String OutputFile
+FSharp.Compiler.CodeAnalysis.FSharpReferencedProject: System.String ToString()
+FSharp.Compiler.CodeAnalysis.FSharpReferencedProject: System.String get_OutputFile()
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean IsFromAttribute
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean IsFromComputationExpression
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean IsFromDefinition
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean IsFromDispatchSlotImplementation
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean IsFromOpenStatement
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean IsFromPattern
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean IsFromType
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean IsFromUse
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean IsPrivateToFile
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean get_IsFromAttribute()
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean get_IsFromComputationExpression()
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean get_IsFromDefinition()
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean get_IsFromDispatchSlotImplementation()
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean get_IsFromOpenStatement()
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean get_IsFromPattern()
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean get_IsFromType()
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean get_IsFromUse()
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Boolean get_IsPrivateToFile()
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: FSharp.Compiler.Symbols.FSharpDisplayContext DisplayContext
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: FSharp.Compiler.Symbols.FSharpDisplayContext get_DisplayContext()
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: FSharp.Compiler.Symbols.FSharpSymbol Symbol
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: FSharp.Compiler.Symbols.FSharpSymbol get_Symbol()
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpGenericParameter,FSharp.Compiler.Symbols.FSharpType]] GenericArguments
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpGenericParameter,FSharp.Compiler.Symbols.FSharpType]] get_GenericArguments()
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: System.String FileName
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: System.String ToString()
+FSharp.Compiler.CodeAnalysis.FSharpSymbolUse: System.String get_FileName()
+FSharp.Compiler.CodeAnalysis.FSharpUnresolvedReferencesSet: Boolean Equals(FSharp.Compiler.CodeAnalysis.FSharpUnresolvedReferencesSet)
+FSharp.Compiler.CodeAnalysis.FSharpUnresolvedReferencesSet: Boolean Equals(System.Object)
+FSharp.Compiler.CodeAnalysis.FSharpUnresolvedReferencesSet: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.CodeAnalysis.FSharpUnresolvedReferencesSet: Int32 GetHashCode()
+FSharp.Compiler.CodeAnalysis.FSharpUnresolvedReferencesSet: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.CodeAnalysis.FSharpUnresolvedReferencesSet: System.String ToString()
+FSharp.Compiler.CodeAnalysis.ILegacyReferenceResolver: FSharp.Compiler.CodeAnalysis.LegacyResolvedFile[] Resolve(FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment, System.Tuple`2[System.String,System.String][], System.String, Microsoft.FSharp.Collections.FSharpList`1[System.String], System.String, System.String, Microsoft.FSharp.Collections.FSharpList`1[System.String], System.String, Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[System.Boolean,Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.Unit]]])
+FSharp.Compiler.CodeAnalysis.ILegacyReferenceResolver: System.String DotNetFrameworkReferenceAssembliesRootDirectory
+FSharp.Compiler.CodeAnalysis.ILegacyReferenceResolver: System.String HighestInstalledNetFrameworkVersion()
+FSharp.Compiler.CodeAnalysis.ILegacyReferenceResolver: System.String get_DotNetFrameworkReferenceAssembliesRootDirectory()
+FSharp.Compiler.CodeAnalysis.LegacyReferenceResolver: Void .ctor(FSharp.Compiler.CodeAnalysis.ILegacyReferenceResolver)
+FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment+EditingOrCompilation: Boolean get_isEditing()
+FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment+EditingOrCompilation: Boolean isEditing
+FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment+Tags: Int32 CompilationAndEvaluation
+FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment+Tags: Int32 EditingOrCompilation
+FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment: Boolean Equals(FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment)
+FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment: Boolean Equals(System.Object)
+FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment: Boolean IsCompilationAndEvaluation
+FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment: Boolean IsEditingOrCompilation
+FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment: Boolean get_IsCompilationAndEvaluation()
+FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment: Boolean get_IsEditingOrCompilation()
+FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment: FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment CompilationAndEvaluation
+FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment: FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment NewEditingOrCompilation(Boolean)
+FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment: FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment get_CompilationAndEvaluation()
+FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment: FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment+EditingOrCompilation
+FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment: FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment+Tags
+FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment: Int32 CompareTo(FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment)
+FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment: Int32 CompareTo(System.Object)
+FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment: Int32 GetHashCode()
+FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment: Int32 Tag
+FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment: Int32 get_Tag()
+FSharp.Compiler.CodeAnalysis.LegacyResolutionEnvironment: System.String ToString()
+FSharp.Compiler.CodeAnalysis.LegacyResolutionFailure: Boolean Equals(System.Object)
+FSharp.Compiler.CodeAnalysis.LegacyResolutionFailure: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.CodeAnalysis.LegacyResolutionFailure: Int32 GetHashCode()
+FSharp.Compiler.CodeAnalysis.LegacyResolutionFailure: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.CodeAnalysis.LegacyResolutionFailure: System.String get_Message()
+FSharp.Compiler.CodeAnalysis.LegacyResolutionFailure: Void .ctor()
+FSharp.Compiler.CodeAnalysis.LegacyResolvedFile: Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[System.String,System.String],System.String] get_prepareToolTip()
+FSharp.Compiler.CodeAnalysis.LegacyResolvedFile: Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[System.String,System.String],System.String] prepareToolTip
+FSharp.Compiler.CodeAnalysis.LegacyResolvedFile: System.String ToString()
+FSharp.Compiler.CodeAnalysis.LegacyResolvedFile: System.String baggage
+FSharp.Compiler.CodeAnalysis.LegacyResolvedFile: System.String get_baggage()
+FSharp.Compiler.CodeAnalysis.LegacyResolvedFile: System.String get_itemSpec()
+FSharp.Compiler.CodeAnalysis.LegacyResolvedFile: System.String itemSpec
+FSharp.Compiler.CodeAnalysis.LegacyResolvedFile: Void .ctor(System.String, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[System.String,System.String],System.String], System.String)
+FSharp.Compiler.CompilerEnvironment: Boolean IsCheckerSupportedSubcategory(System.String)
+FSharp.Compiler.CompilerEnvironment: Boolean IsCompilable(System.String)
+FSharp.Compiler.CompilerEnvironment: Boolean IsScriptFile(System.String)
+FSharp.Compiler.CompilerEnvironment: Boolean MustBeSingleFileProject(System.String)
+FSharp.Compiler.CompilerEnvironment: Microsoft.FSharp.Collections.FSharpList`1[System.String] DefaultReferencesForOrphanSources(Boolean)
+FSharp.Compiler.CompilerEnvironment: Microsoft.FSharp.Collections.FSharpList`1[System.String] GetConditionalDefinesForEditing(FSharp.Compiler.CodeAnalysis.FSharpParsingOptions)
+FSharp.Compiler.CompilerEnvironment: Microsoft.FSharp.Core.FSharpOption`1[System.String] BinFolderOfDefaultFSharpCompiler(Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.CompilerEnvironment: System.Guid GetDebuggerLanguageID()
+FSharp.Compiler.DependencyManager.AssemblyResolutionProbe: System.Collections.Generic.IEnumerable`1[System.String] EndInvoke(System.IAsyncResult)
+FSharp.Compiler.DependencyManager.AssemblyResolutionProbe: System.Collections.Generic.IEnumerable`1[System.String] Invoke()
+FSharp.Compiler.DependencyManager.AssemblyResolutionProbe: System.IAsyncResult BeginInvoke(System.AsyncCallback, System.Object)
+FSharp.Compiler.DependencyManager.AssemblyResolutionProbe: Void .ctor(System.Object, IntPtr)
+FSharp.Compiler.DependencyManager.AssemblyResolveHandler: Void .ctor(FSharp.Compiler.DependencyManager.AssemblyResolutionProbe)
+FSharp.Compiler.DependencyManager.DependencyProvider: FSharp.Compiler.DependencyManager.IDependencyManagerProvider TryFindDependencyManagerByKey(System.Collections.Generic.IEnumerable`1[System.String], System.String, FSharp.Compiler.DependencyManager.ResolvingErrorReport, System.String)
+FSharp.Compiler.DependencyManager.DependencyProvider: FSharp.Compiler.DependencyManager.IResolveDependenciesResult Resolve(FSharp.Compiler.DependencyManager.IDependencyManagerProvider, System.String, System.Collections.Generic.IEnumerable`1[System.Tuple`2[System.String,System.String]], FSharp.Compiler.DependencyManager.ResolvingErrorReport, System.String, System.String, System.String, System.String, System.String, Int32)
+FSharp.Compiler.DependencyManager.DependencyProvider: System.String[] GetRegisteredDependencyManagerHelpText(System.Collections.Generic.IEnumerable`1[System.String], System.String, FSharp.Compiler.DependencyManager.ResolvingErrorReport)
+FSharp.Compiler.DependencyManager.DependencyProvider: System.Tuple`2[System.Int32,System.String] CreatePackageManagerUnknownError(System.Collections.Generic.IEnumerable`1[System.String], System.String, System.String, FSharp.Compiler.DependencyManager.ResolvingErrorReport)
+FSharp.Compiler.DependencyManager.DependencyProvider: System.Tuple`2[System.String,FSharp.Compiler.DependencyManager.IDependencyManagerProvider] TryFindDependencyManagerInPath(System.Collections.Generic.IEnumerable`1[System.String], System.String, FSharp.Compiler.DependencyManager.ResolvingErrorReport, System.String)
+FSharp.Compiler.DependencyManager.DependencyProvider: Void .ctor()
+FSharp.Compiler.DependencyManager.DependencyProvider: Void .ctor(FSharp.Compiler.DependencyManager.AssemblyResolutionProbe, FSharp.Compiler.DependencyManager.NativeResolutionProbe)
+FSharp.Compiler.DependencyManager.DependencyProvider: Void .ctor(FSharp.Compiler.DependencyManager.AssemblyResolutionProbe, FSharp.Compiler.DependencyManager.NativeResolutionProbe, Boolean)
+FSharp.Compiler.DependencyManager.DependencyProvider: Void .ctor(FSharp.Compiler.DependencyManager.NativeResolutionProbe)
+FSharp.Compiler.DependencyManager.DependencyProvider: Void .ctor(FSharp.Compiler.DependencyManager.NativeResolutionProbe, Boolean)
+FSharp.Compiler.DependencyManager.DependencyProvider: Void ClearResultsCache(System.Collections.Generic.IEnumerable`1[System.String], System.String, FSharp.Compiler.DependencyManager.ResolvingErrorReport)
+FSharp.Compiler.DependencyManager.ErrorReportType+Tags: Int32 Error
+FSharp.Compiler.DependencyManager.ErrorReportType+Tags: Int32 Warning
+FSharp.Compiler.DependencyManager.ErrorReportType: Boolean Equals(FSharp.Compiler.DependencyManager.ErrorReportType)
+FSharp.Compiler.DependencyManager.ErrorReportType: Boolean Equals(System.Object)
+FSharp.Compiler.DependencyManager.ErrorReportType: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.DependencyManager.ErrorReportType: Boolean IsError
+FSharp.Compiler.DependencyManager.ErrorReportType: Boolean IsWarning
+FSharp.Compiler.DependencyManager.ErrorReportType: Boolean get_IsError()
+FSharp.Compiler.DependencyManager.ErrorReportType: Boolean get_IsWarning()
+FSharp.Compiler.DependencyManager.ErrorReportType: FSharp.Compiler.DependencyManager.ErrorReportType Error
+FSharp.Compiler.DependencyManager.ErrorReportType: FSharp.Compiler.DependencyManager.ErrorReportType Warning
+FSharp.Compiler.DependencyManager.ErrorReportType: FSharp.Compiler.DependencyManager.ErrorReportType get_Error()
+FSharp.Compiler.DependencyManager.ErrorReportType: FSharp.Compiler.DependencyManager.ErrorReportType get_Warning()
+FSharp.Compiler.DependencyManager.ErrorReportType: FSharp.Compiler.DependencyManager.ErrorReportType+Tags
+FSharp.Compiler.DependencyManager.ErrorReportType: Int32 CompareTo(FSharp.Compiler.DependencyManager.ErrorReportType)
+FSharp.Compiler.DependencyManager.ErrorReportType: Int32 CompareTo(System.Object)
+FSharp.Compiler.DependencyManager.ErrorReportType: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.DependencyManager.ErrorReportType: Int32 GetHashCode()
+FSharp.Compiler.DependencyManager.ErrorReportType: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.DependencyManager.ErrorReportType: Int32 Tag
+FSharp.Compiler.DependencyManager.ErrorReportType: Int32 get_Tag()
+FSharp.Compiler.DependencyManager.ErrorReportType: System.String ToString()
+FSharp.Compiler.DependencyManager.IDependencyManagerProvider: FSharp.Compiler.DependencyManager.IResolveDependenciesResult ResolveDependencies(System.String, System.String, System.String, System.String, System.Collections.Generic.IEnumerable`1[System.Tuple`2[System.String,System.String]], System.String, System.String, Int32)
+FSharp.Compiler.DependencyManager.IDependencyManagerProvider: System.String Key
+FSharp.Compiler.DependencyManager.IDependencyManagerProvider: System.String Name
+FSharp.Compiler.DependencyManager.IDependencyManagerProvider: System.String get_Key()
+FSharp.Compiler.DependencyManager.IDependencyManagerProvider: System.String get_Name()
+FSharp.Compiler.DependencyManager.IDependencyManagerProvider: System.String[] HelpMessages
+FSharp.Compiler.DependencyManager.IDependencyManagerProvider: System.String[] get_HelpMessages()
+FSharp.Compiler.DependencyManager.IDependencyManagerProvider: Void ClearResultsCache()
+FSharp.Compiler.DependencyManager.IResolveDependenciesResult: Boolean Success
+FSharp.Compiler.DependencyManager.IResolveDependenciesResult: Boolean get_Success()
+FSharp.Compiler.DependencyManager.IResolveDependenciesResult: System.Collections.Generic.IEnumerable`1[System.String] Resolutions
+FSharp.Compiler.DependencyManager.IResolveDependenciesResult: System.Collections.Generic.IEnumerable`1[System.String] Roots
+FSharp.Compiler.DependencyManager.IResolveDependenciesResult: System.Collections.Generic.IEnumerable`1[System.String] SourceFiles
+FSharp.Compiler.DependencyManager.IResolveDependenciesResult: System.Collections.Generic.IEnumerable`1[System.String] get_Resolutions()
+FSharp.Compiler.DependencyManager.IResolveDependenciesResult: System.Collections.Generic.IEnumerable`1[System.String] get_Roots()
+FSharp.Compiler.DependencyManager.IResolveDependenciesResult: System.Collections.Generic.IEnumerable`1[System.String] get_SourceFiles()
+FSharp.Compiler.DependencyManager.IResolveDependenciesResult: System.String[] StdError
+FSharp.Compiler.DependencyManager.IResolveDependenciesResult: System.String[] StdOut
+FSharp.Compiler.DependencyManager.IResolveDependenciesResult: System.String[] get_StdError()
+FSharp.Compiler.DependencyManager.IResolveDependenciesResult: System.String[] get_StdOut()
+FSharp.Compiler.DependencyManager.NativeDllResolveHandler: Void .ctor(FSharp.Compiler.DependencyManager.NativeResolutionProbe)
+FSharp.Compiler.DependencyManager.NativeResolutionProbe: System.Collections.Generic.IEnumerable`1[System.String] EndInvoke(System.IAsyncResult)
+FSharp.Compiler.DependencyManager.NativeResolutionProbe: System.Collections.Generic.IEnumerable`1[System.String] Invoke()
+FSharp.Compiler.DependencyManager.NativeResolutionProbe: System.IAsyncResult BeginInvoke(System.AsyncCallback, System.Object)
+FSharp.Compiler.DependencyManager.NativeResolutionProbe: Void .ctor(System.Object, IntPtr)
+FSharp.Compiler.DependencyManager.ResolvingErrorReport: System.IAsyncResult BeginInvoke(FSharp.Compiler.DependencyManager.ErrorReportType, Int32, System.String, System.AsyncCallback, System.Object)
+FSharp.Compiler.DependencyManager.ResolvingErrorReport: Void .ctor(System.Object, IntPtr)
+FSharp.Compiler.DependencyManager.ResolvingErrorReport: Void EndInvoke(System.IAsyncResult)
+FSharp.Compiler.DependencyManager.ResolvingErrorReport: Void Invoke(FSharp.Compiler.DependencyManager.ErrorReportType, Int32, System.String)
+FSharp.Compiler.Diagnostics.CompilerDiagnostics: System.Collections.Generic.IEnumerable`1[System.String] GetSuggestedNames(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.Unit],Microsoft.FSharp.Core.Unit], System.String)
+FSharp.Compiler.Diagnostics.CompilerDiagnostics: System.String GetErrorMessage(FSharp.Compiler.Diagnostics.FSharpDiagnosticKind)
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: FSharp.Compiler.Diagnostics.FSharpDiagnostic Create(FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity, System.String, Int32, FSharp.Compiler.Text.Range, Microsoft.FSharp.Core.FSharpOption`1[System.String], Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity Severity
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity get_Severity()
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: FSharp.Compiler.Text.Position End
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: FSharp.Compiler.Text.Position Start
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: FSharp.Compiler.Text.Position get_End()
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: FSharp.Compiler.Text.Position get_Start()
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: Int32 EndColumn
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: Int32 EndLine
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: Int32 ErrorNumber
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: Int32 StartColumn
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: Int32 StartLine
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: Int32 get_EndColumn()
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: Int32 get_EndLine()
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: Int32 get_ErrorNumber()
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: Int32 get_StartColumn()
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: Int32 get_StartLine()
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: System.String ErrorNumberPrefix
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: System.String ErrorNumberText
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: System.String FileName
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: System.String Message
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: System.String NewlineifyErrorString(System.String)
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: System.String NormalizeErrorString(System.String)
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: System.String Subcategory
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: System.String ToString()
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: System.String get_ErrorNumberPrefix()
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: System.String get_ErrorNumberText()
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: System.String get_FileName()
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: System.String get_Message()
+FSharp.Compiler.Diagnostics.FSharpDiagnostic: System.String get_Subcategory()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticKind+ReplaceWithSuggestion: System.String get_suggestion()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticKind+ReplaceWithSuggestion: System.String suggestion
+FSharp.Compiler.Diagnostics.FSharpDiagnosticKind+Tags: Int32 AddIndexerDot
+FSharp.Compiler.Diagnostics.FSharpDiagnosticKind+Tags: Int32 ReplaceWithSuggestion
+FSharp.Compiler.Diagnostics.FSharpDiagnosticKind: Boolean Equals(FSharp.Compiler.Diagnostics.FSharpDiagnosticKind)
+FSharp.Compiler.Diagnostics.FSharpDiagnosticKind: Boolean Equals(System.Object)
+FSharp.Compiler.Diagnostics.FSharpDiagnosticKind: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Diagnostics.FSharpDiagnosticKind: Boolean IsAddIndexerDot
+FSharp.Compiler.Diagnostics.FSharpDiagnosticKind: Boolean IsReplaceWithSuggestion
+FSharp.Compiler.Diagnostics.FSharpDiagnosticKind: Boolean get_IsAddIndexerDot()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticKind: Boolean get_IsReplaceWithSuggestion()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticKind: FSharp.Compiler.Diagnostics.FSharpDiagnosticKind AddIndexerDot
+FSharp.Compiler.Diagnostics.FSharpDiagnosticKind: FSharp.Compiler.Diagnostics.FSharpDiagnosticKind NewReplaceWithSuggestion(System.String)
+FSharp.Compiler.Diagnostics.FSharpDiagnosticKind: FSharp.Compiler.Diagnostics.FSharpDiagnosticKind get_AddIndexerDot()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticKind: FSharp.Compiler.Diagnostics.FSharpDiagnosticKind+ReplaceWithSuggestion
+FSharp.Compiler.Diagnostics.FSharpDiagnosticKind: FSharp.Compiler.Diagnostics.FSharpDiagnosticKind+Tags
+FSharp.Compiler.Diagnostics.FSharpDiagnosticKind: Int32 CompareTo(FSharp.Compiler.Diagnostics.FSharpDiagnosticKind)
+FSharp.Compiler.Diagnostics.FSharpDiagnosticKind: Int32 CompareTo(System.Object)
+FSharp.Compiler.Diagnostics.FSharpDiagnosticKind: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.Diagnostics.FSharpDiagnosticKind: Int32 GetHashCode()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticKind: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Diagnostics.FSharpDiagnosticKind: Int32 Tag
+FSharp.Compiler.Diagnostics.FSharpDiagnosticKind: Int32 get_Tag()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticKind: System.String ToString()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Boolean CheckXmlDocs
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Boolean Equals(FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions)
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Boolean Equals(System.Object)
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Boolean GlobalWarnAsError
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Boolean get_CheckXmlDocs()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Boolean get_GlobalWarnAsError()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions Default
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions get_Default()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Int32 CompareTo(FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions)
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Int32 CompareTo(System.Object)
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Int32 GetHashCode()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Int32 WarnLevel
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Int32 get_WarnLevel()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Microsoft.FSharp.Collections.FSharpList`1[System.Int32] WarnAsError
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Microsoft.FSharp.Collections.FSharpList`1[System.Int32] WarnAsWarn
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Microsoft.FSharp.Collections.FSharpList`1[System.Int32] WarnOff
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Microsoft.FSharp.Collections.FSharpList`1[System.Int32] WarnOn
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Microsoft.FSharp.Collections.FSharpList`1[System.Int32] get_WarnAsError()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Microsoft.FSharp.Collections.FSharpList`1[System.Int32] get_WarnAsWarn()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Microsoft.FSharp.Collections.FSharpList`1[System.Int32] get_WarnOff()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Microsoft.FSharp.Collections.FSharpList`1[System.Int32] get_WarnOn()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: System.String ToString()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions: Void .ctor(Int32, Boolean, Microsoft.FSharp.Collections.FSharpList`1[System.Int32], Microsoft.FSharp.Collections.FSharpList`1[System.Int32], Microsoft.FSharp.Collections.FSharpList`1[System.Int32], Microsoft.FSharp.Collections.FSharpList`1[System.Int32])
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity+Tags: Int32 Error
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity+Tags: Int32 Hidden
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity+Tags: Int32 Info
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity+Tags: Int32 Warning
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: Boolean Equals(FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity)
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: Boolean Equals(System.Object)
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: Boolean IsError
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: Boolean IsHidden
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: Boolean IsInfo
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: Boolean IsWarning
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: Boolean get_IsError()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: Boolean get_IsHidden()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: Boolean get_IsInfo()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: Boolean get_IsWarning()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity Error
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity Hidden
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity Info
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity Warning
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity get_Error()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity get_Hidden()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity get_Info()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity get_Warning()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity+Tags
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: Int32 CompareTo(FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity)
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: Int32 CompareTo(System.Object)
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: Int32 GetHashCode()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: Int32 Tag
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: Int32 get_Tag()
+FSharp.Compiler.Diagnostics.FSharpDiagnosticSeverity: System.String ToString()
+FSharp.Compiler.EditorServices.AssemblyContent: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.AssemblySymbol] GetAssemblyContent(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.EditorServices.IAssemblyContentCache,Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.AssemblySymbol]],Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.AssemblySymbol]], FSharp.Compiler.EditorServices.AssemblyContentType, Microsoft.FSharp.Core.FSharpOption`1[System.String], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpAssembly])
+FSharp.Compiler.EditorServices.AssemblyContent: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.AssemblySymbol] GetAssemblySignatureContent(FSharp.Compiler.EditorServices.AssemblyContentType, FSharp.Compiler.Symbols.FSharpAssemblySignature)
+FSharp.Compiler.EditorServices.AssemblyContentType+Tags: Int32 Full
+FSharp.Compiler.EditorServices.AssemblyContentType+Tags: Int32 Public
+FSharp.Compiler.EditorServices.AssemblyContentType: Boolean Equals(FSharp.Compiler.EditorServices.AssemblyContentType)
+FSharp.Compiler.EditorServices.AssemblyContentType: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.AssemblyContentType: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.AssemblyContentType: Boolean IsFull
+FSharp.Compiler.EditorServices.AssemblyContentType: Boolean IsPublic
+FSharp.Compiler.EditorServices.AssemblyContentType: Boolean get_IsFull()
+FSharp.Compiler.EditorServices.AssemblyContentType: Boolean get_IsPublic()
+FSharp.Compiler.EditorServices.AssemblyContentType: FSharp.Compiler.EditorServices.AssemblyContentType Full
+FSharp.Compiler.EditorServices.AssemblyContentType: FSharp.Compiler.EditorServices.AssemblyContentType Public
+FSharp.Compiler.EditorServices.AssemblyContentType: FSharp.Compiler.EditorServices.AssemblyContentType get_Full()
+FSharp.Compiler.EditorServices.AssemblyContentType: FSharp.Compiler.EditorServices.AssemblyContentType get_Public()
+FSharp.Compiler.EditorServices.AssemblyContentType: FSharp.Compiler.EditorServices.AssemblyContentType+Tags
+FSharp.Compiler.EditorServices.AssemblyContentType: Int32 CompareTo(FSharp.Compiler.EditorServices.AssemblyContentType)
+FSharp.Compiler.EditorServices.AssemblyContentType: Int32 CompareTo(System.Object)
+FSharp.Compiler.EditorServices.AssemblyContentType: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.EditorServices.AssemblyContentType: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.AssemblyContentType: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.AssemblyContentType: Int32 Tag
+FSharp.Compiler.EditorServices.AssemblyContentType: Int32 get_Tag()
+FSharp.Compiler.EditorServices.AssemblyContentType: System.String ToString()
+FSharp.Compiler.EditorServices.AssemblySymbol: FSharp.Compiler.EditorServices.UnresolvedSymbol UnresolvedSymbol
+FSharp.Compiler.EditorServices.AssemblySymbol: FSharp.Compiler.EditorServices.UnresolvedSymbol get_UnresolvedSymbol()
+FSharp.Compiler.EditorServices.AssemblySymbol: FSharp.Compiler.Symbols.FSharpSymbol Symbol
+FSharp.Compiler.EditorServices.AssemblySymbol: FSharp.Compiler.Symbols.FSharpSymbol get_Symbol()
+FSharp.Compiler.EditorServices.AssemblySymbol: Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.EditorServices.LookupType,FSharp.Compiler.EditorServices.EntityKind] Kind
+FSharp.Compiler.EditorServices.AssemblySymbol: Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.EditorServices.LookupType,FSharp.Compiler.EditorServices.EntityKind] get_Kind()
+FSharp.Compiler.EditorServices.AssemblySymbol: Microsoft.FSharp.Core.FSharpOption`1[System.String[]] AutoOpenParent
+FSharp.Compiler.EditorServices.AssemblySymbol: Microsoft.FSharp.Core.FSharpOption`1[System.String[]] Namespace
+FSharp.Compiler.EditorServices.AssemblySymbol: Microsoft.FSharp.Core.FSharpOption`1[System.String[]] NearestRequireQualifiedAccessParent
+FSharp.Compiler.EditorServices.AssemblySymbol: Microsoft.FSharp.Core.FSharpOption`1[System.String[]] TopRequireQualifiedAccessParent
+FSharp.Compiler.EditorServices.AssemblySymbol: Microsoft.FSharp.Core.FSharpOption`1[System.String[]] get_AutoOpenParent()
+FSharp.Compiler.EditorServices.AssemblySymbol: Microsoft.FSharp.Core.FSharpOption`1[System.String[]] get_Namespace()
+FSharp.Compiler.EditorServices.AssemblySymbol: Microsoft.FSharp.Core.FSharpOption`1[System.String[]] get_NearestRequireQualifiedAccessParent()
+FSharp.Compiler.EditorServices.AssemblySymbol: Microsoft.FSharp.Core.FSharpOption`1[System.String[]] get_TopRequireQualifiedAccessParent()
+FSharp.Compiler.EditorServices.AssemblySymbol: System.String FullName
+FSharp.Compiler.EditorServices.AssemblySymbol: System.String ToString()
+FSharp.Compiler.EditorServices.AssemblySymbol: System.String get_FullName()
+FSharp.Compiler.EditorServices.AssemblySymbol: System.String[] CleanedIdents
+FSharp.Compiler.EditorServices.AssemblySymbol: System.String[] get_CleanedIdents()
+FSharp.Compiler.EditorServices.AssemblySymbol: Void .ctor(System.String, System.String[], Microsoft.FSharp.Core.FSharpOption`1[System.String[]], Microsoft.FSharp.Core.FSharpOption`1[System.String[]], Microsoft.FSharp.Core.FSharpOption`1[System.String[]], Microsoft.FSharp.Core.FSharpOption`1[System.String[]], FSharp.Compiler.Symbols.FSharpSymbol, Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.EditorServices.LookupType,FSharp.Compiler.EditorServices.EntityKind], FSharp.Compiler.EditorServices.UnresolvedSymbol)
+FSharp.Compiler.EditorServices.CompletionContext+Inherit: FSharp.Compiler.EditorServices.InheritanceContext context
+FSharp.Compiler.EditorServices.CompletionContext+Inherit: FSharp.Compiler.EditorServices.InheritanceContext get_context()
+FSharp.Compiler.EditorServices.CompletionContext+Inherit: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[System.String],Microsoft.FSharp.Core.FSharpOption`1[System.String]] get_path()
+FSharp.Compiler.EditorServices.CompletionContext+Inherit: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[System.String],Microsoft.FSharp.Core.FSharpOption`1[System.String]] path
+FSharp.Compiler.EditorServices.CompletionContext+OpenDeclaration: Boolean get_isOpenType()
+FSharp.Compiler.EditorServices.CompletionContext+OpenDeclaration: Boolean isOpenType
+FSharp.Compiler.EditorServices.CompletionContext+ParameterList: FSharp.Compiler.Text.Position Item1
+FSharp.Compiler.EditorServices.CompletionContext+ParameterList: FSharp.Compiler.Text.Position get_Item1()
+FSharp.Compiler.EditorServices.CompletionContext+ParameterList: System.Collections.Generic.HashSet`1[System.String] Item2
+FSharp.Compiler.EditorServices.CompletionContext+ParameterList: System.Collections.Generic.HashSet`1[System.String] get_Item2()
+FSharp.Compiler.EditorServices.CompletionContext+RecordField: FSharp.Compiler.EditorServices.RecordContext context
+FSharp.Compiler.EditorServices.CompletionContext+RecordField: FSharp.Compiler.EditorServices.RecordContext get_context()
+FSharp.Compiler.EditorServices.CompletionContext+Tags: Int32 AttributeApplication
+FSharp.Compiler.EditorServices.CompletionContext+Tags: Int32 Inherit
+FSharp.Compiler.EditorServices.CompletionContext+Tags: Int32 Invalid
+FSharp.Compiler.EditorServices.CompletionContext+Tags: Int32 OpenDeclaration
+FSharp.Compiler.EditorServices.CompletionContext+Tags: Int32 ParameterList
+FSharp.Compiler.EditorServices.CompletionContext+Tags: Int32 PatternType
+FSharp.Compiler.EditorServices.CompletionContext+Tags: Int32 RangeOperator
+FSharp.Compiler.EditorServices.CompletionContext+Tags: Int32 RecordField
+FSharp.Compiler.EditorServices.CompletionContext+Tags: Int32 TypeAbbreviationOrSingleCaseUnion
+FSharp.Compiler.EditorServices.CompletionContext+Tags: Int32 UnionCaseFieldsDeclaration
+FSharp.Compiler.EditorServices.CompletionContext: Boolean Equals(FSharp.Compiler.EditorServices.CompletionContext)
+FSharp.Compiler.EditorServices.CompletionContext: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.CompletionContext: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.CompletionContext: Boolean IsAttributeApplication
+FSharp.Compiler.EditorServices.CompletionContext: Boolean IsInherit
+FSharp.Compiler.EditorServices.CompletionContext: Boolean IsInvalid
+FSharp.Compiler.EditorServices.CompletionContext: Boolean IsOpenDeclaration
+FSharp.Compiler.EditorServices.CompletionContext: Boolean IsParameterList
+FSharp.Compiler.EditorServices.CompletionContext: Boolean IsPatternType
+FSharp.Compiler.EditorServices.CompletionContext: Boolean IsRangeOperator
+FSharp.Compiler.EditorServices.CompletionContext: Boolean IsRecordField
+FSharp.Compiler.EditorServices.CompletionContext: Boolean IsTypeAbbreviationOrSingleCaseUnion
+FSharp.Compiler.EditorServices.CompletionContext: Boolean IsUnionCaseFieldsDeclaration
+FSharp.Compiler.EditorServices.CompletionContext: Boolean get_IsAttributeApplication()
+FSharp.Compiler.EditorServices.CompletionContext: Boolean get_IsInherit()
+FSharp.Compiler.EditorServices.CompletionContext: Boolean get_IsInvalid()
+FSharp.Compiler.EditorServices.CompletionContext: Boolean get_IsOpenDeclaration()
+FSharp.Compiler.EditorServices.CompletionContext: Boolean get_IsParameterList()
+FSharp.Compiler.EditorServices.CompletionContext: Boolean get_IsPatternType()
+FSharp.Compiler.EditorServices.CompletionContext: Boolean get_IsRangeOperator()
+FSharp.Compiler.EditorServices.CompletionContext: Boolean get_IsRecordField()
+FSharp.Compiler.EditorServices.CompletionContext: Boolean get_IsTypeAbbreviationOrSingleCaseUnion()
+FSharp.Compiler.EditorServices.CompletionContext: Boolean get_IsUnionCaseFieldsDeclaration()
+FSharp.Compiler.EditorServices.CompletionContext: FSharp.Compiler.EditorServices.CompletionContext AttributeApplication
+FSharp.Compiler.EditorServices.CompletionContext: FSharp.Compiler.EditorServices.CompletionContext Invalid
+FSharp.Compiler.EditorServices.CompletionContext: FSharp.Compiler.EditorServices.CompletionContext NewInherit(FSharp.Compiler.EditorServices.InheritanceContext, System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[System.String],Microsoft.FSharp.Core.FSharpOption`1[System.String]])
+FSharp.Compiler.EditorServices.CompletionContext: FSharp.Compiler.EditorServices.CompletionContext NewOpenDeclaration(Boolean)
+FSharp.Compiler.EditorServices.CompletionContext: FSharp.Compiler.EditorServices.CompletionContext NewParameterList(FSharp.Compiler.Text.Position, System.Collections.Generic.HashSet`1[System.String])
+FSharp.Compiler.EditorServices.CompletionContext: FSharp.Compiler.EditorServices.CompletionContext NewRecordField(FSharp.Compiler.EditorServices.RecordContext)
+FSharp.Compiler.EditorServices.CompletionContext: FSharp.Compiler.EditorServices.CompletionContext PatternType
+FSharp.Compiler.EditorServices.CompletionContext: FSharp.Compiler.EditorServices.CompletionContext RangeOperator
+FSharp.Compiler.EditorServices.CompletionContext: FSharp.Compiler.EditorServices.CompletionContext TypeAbbreviationOrSingleCaseUnion
+FSharp.Compiler.EditorServices.CompletionContext: FSharp.Compiler.EditorServices.CompletionContext UnionCaseFieldsDeclaration
+FSharp.Compiler.EditorServices.CompletionContext: FSharp.Compiler.EditorServices.CompletionContext get_AttributeApplication()
+FSharp.Compiler.EditorServices.CompletionContext: FSharp.Compiler.EditorServices.CompletionContext get_Invalid()
+FSharp.Compiler.EditorServices.CompletionContext: FSharp.Compiler.EditorServices.CompletionContext get_PatternType()
+FSharp.Compiler.EditorServices.CompletionContext: FSharp.Compiler.EditorServices.CompletionContext get_RangeOperator()
+FSharp.Compiler.EditorServices.CompletionContext: FSharp.Compiler.EditorServices.CompletionContext get_TypeAbbreviationOrSingleCaseUnion()
+FSharp.Compiler.EditorServices.CompletionContext: FSharp.Compiler.EditorServices.CompletionContext get_UnionCaseFieldsDeclaration()
+FSharp.Compiler.EditorServices.CompletionContext: FSharp.Compiler.EditorServices.CompletionContext+Inherit
+FSharp.Compiler.EditorServices.CompletionContext: FSharp.Compiler.EditorServices.CompletionContext+OpenDeclaration
+FSharp.Compiler.EditorServices.CompletionContext: FSharp.Compiler.EditorServices.CompletionContext+ParameterList
+FSharp.Compiler.EditorServices.CompletionContext: FSharp.Compiler.EditorServices.CompletionContext+RecordField
+FSharp.Compiler.EditorServices.CompletionContext: FSharp.Compiler.EditorServices.CompletionContext+Tags
+FSharp.Compiler.EditorServices.CompletionContext: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.CompletionContext: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.CompletionContext: Int32 Tag
+FSharp.Compiler.EditorServices.CompletionContext: Int32 get_Tag()
+FSharp.Compiler.EditorServices.CompletionContext: System.String ToString()
+FSharp.Compiler.EditorServices.CompletionItemKind+Method: Boolean get_isExtension()
+FSharp.Compiler.EditorServices.CompletionItemKind+Method: Boolean isExtension
+FSharp.Compiler.EditorServices.CompletionItemKind+Tags: Int32 Argument
+FSharp.Compiler.EditorServices.CompletionItemKind+Tags: Int32 CustomOperation
+FSharp.Compiler.EditorServices.CompletionItemKind+Tags: Int32 Event
+FSharp.Compiler.EditorServices.CompletionItemKind+Tags: Int32 Field
+FSharp.Compiler.EditorServices.CompletionItemKind+Tags: Int32 Method
+FSharp.Compiler.EditorServices.CompletionItemKind+Tags: Int32 Other
+FSharp.Compiler.EditorServices.CompletionItemKind+Tags: Int32 Property
+FSharp.Compiler.EditorServices.CompletionItemKind: Boolean Equals(FSharp.Compiler.EditorServices.CompletionItemKind)
+FSharp.Compiler.EditorServices.CompletionItemKind: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.CompletionItemKind: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.CompletionItemKind: Boolean IsArgument
+FSharp.Compiler.EditorServices.CompletionItemKind: Boolean IsCustomOperation
+FSharp.Compiler.EditorServices.CompletionItemKind: Boolean IsEvent
+FSharp.Compiler.EditorServices.CompletionItemKind: Boolean IsField
+FSharp.Compiler.EditorServices.CompletionItemKind: Boolean IsMethod
+FSharp.Compiler.EditorServices.CompletionItemKind: Boolean IsOther
+FSharp.Compiler.EditorServices.CompletionItemKind: Boolean IsProperty
+FSharp.Compiler.EditorServices.CompletionItemKind: Boolean get_IsArgument()
+FSharp.Compiler.EditorServices.CompletionItemKind: Boolean get_IsCustomOperation()
+FSharp.Compiler.EditorServices.CompletionItemKind: Boolean get_IsEvent()
+FSharp.Compiler.EditorServices.CompletionItemKind: Boolean get_IsField()
+FSharp.Compiler.EditorServices.CompletionItemKind: Boolean get_IsMethod()
+FSharp.Compiler.EditorServices.CompletionItemKind: Boolean get_IsOther()
+FSharp.Compiler.EditorServices.CompletionItemKind: Boolean get_IsProperty()
+FSharp.Compiler.EditorServices.CompletionItemKind: FSharp.Compiler.EditorServices.CompletionItemKind Argument
+FSharp.Compiler.EditorServices.CompletionItemKind: FSharp.Compiler.EditorServices.CompletionItemKind CustomOperation
+FSharp.Compiler.EditorServices.CompletionItemKind: FSharp.Compiler.EditorServices.CompletionItemKind Event
+FSharp.Compiler.EditorServices.CompletionItemKind: FSharp.Compiler.EditorServices.CompletionItemKind Field
+FSharp.Compiler.EditorServices.CompletionItemKind: FSharp.Compiler.EditorServices.CompletionItemKind NewMethod(Boolean)
+FSharp.Compiler.EditorServices.CompletionItemKind: FSharp.Compiler.EditorServices.CompletionItemKind Other
+FSharp.Compiler.EditorServices.CompletionItemKind: FSharp.Compiler.EditorServices.CompletionItemKind Property
+FSharp.Compiler.EditorServices.CompletionItemKind: FSharp.Compiler.EditorServices.CompletionItemKind get_Argument()
+FSharp.Compiler.EditorServices.CompletionItemKind: FSharp.Compiler.EditorServices.CompletionItemKind get_CustomOperation()
+FSharp.Compiler.EditorServices.CompletionItemKind: FSharp.Compiler.EditorServices.CompletionItemKind get_Event()
+FSharp.Compiler.EditorServices.CompletionItemKind: FSharp.Compiler.EditorServices.CompletionItemKind get_Field()
+FSharp.Compiler.EditorServices.CompletionItemKind: FSharp.Compiler.EditorServices.CompletionItemKind get_Other()
+FSharp.Compiler.EditorServices.CompletionItemKind: FSharp.Compiler.EditorServices.CompletionItemKind get_Property()
+FSharp.Compiler.EditorServices.CompletionItemKind: FSharp.Compiler.EditorServices.CompletionItemKind+Method
+FSharp.Compiler.EditorServices.CompletionItemKind: FSharp.Compiler.EditorServices.CompletionItemKind+Tags
+FSharp.Compiler.EditorServices.CompletionItemKind: Int32 CompareTo(FSharp.Compiler.EditorServices.CompletionItemKind)
+FSharp.Compiler.EditorServices.CompletionItemKind: Int32 CompareTo(System.Object)
+FSharp.Compiler.EditorServices.CompletionItemKind: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.EditorServices.CompletionItemKind: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.CompletionItemKind: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.CompletionItemKind: Int32 Tag
+FSharp.Compiler.EditorServices.CompletionItemKind: Int32 get_Tag()
+FSharp.Compiler.EditorServices.CompletionItemKind: System.String ToString()
+FSharp.Compiler.EditorServices.DeclarationListInfo: Boolean IsError
+FSharp.Compiler.EditorServices.DeclarationListInfo: Boolean IsForType
+FSharp.Compiler.EditorServices.DeclarationListInfo: Boolean get_IsError()
+FSharp.Compiler.EditorServices.DeclarationListInfo: Boolean get_IsForType()
+FSharp.Compiler.EditorServices.DeclarationListInfo: FSharp.Compiler.EditorServices.DeclarationListInfo Empty
+FSharp.Compiler.EditorServices.DeclarationListInfo: FSharp.Compiler.EditorServices.DeclarationListInfo get_Empty()
+FSharp.Compiler.EditorServices.DeclarationListInfo: FSharp.Compiler.EditorServices.DeclarationListItem[] Items
+FSharp.Compiler.EditorServices.DeclarationListInfo: FSharp.Compiler.EditorServices.DeclarationListItem[] get_Items()
+FSharp.Compiler.EditorServices.DeclarationListItem: Boolean IsOwnMember
+FSharp.Compiler.EditorServices.DeclarationListItem: Boolean IsResolved
+FSharp.Compiler.EditorServices.DeclarationListItem: Boolean get_IsOwnMember()
+FSharp.Compiler.EditorServices.DeclarationListItem: Boolean get_IsResolved()
+FSharp.Compiler.EditorServices.DeclarationListItem: FSharp.Compiler.EditorServices.CompletionItemKind Kind
+FSharp.Compiler.EditorServices.DeclarationListItem: FSharp.Compiler.EditorServices.CompletionItemKind get_Kind()
+FSharp.Compiler.EditorServices.DeclarationListItem: FSharp.Compiler.EditorServices.FSharpGlyph Glyph
+FSharp.Compiler.EditorServices.DeclarationListItem: FSharp.Compiler.EditorServices.FSharpGlyph get_Glyph()
+FSharp.Compiler.EditorServices.DeclarationListItem: FSharp.Compiler.EditorServices.ToolTipText Description
+FSharp.Compiler.EditorServices.DeclarationListItem: FSharp.Compiler.EditorServices.ToolTipText get_Description()
+FSharp.Compiler.EditorServices.DeclarationListItem: FSharp.Compiler.Symbols.FSharpAccessibility Accessibility
+FSharp.Compiler.EditorServices.DeclarationListItem: FSharp.Compiler.Symbols.FSharpAccessibility get_Accessibility()
+FSharp.Compiler.EditorServices.DeclarationListItem: Int32 MinorPriority
+FSharp.Compiler.EditorServices.DeclarationListItem: Int32 get_MinorPriority()
+FSharp.Compiler.EditorServices.DeclarationListItem: Microsoft.FSharp.Core.FSharpOption`1[System.String] NamespaceToOpen
+FSharp.Compiler.EditorServices.DeclarationListItem: Microsoft.FSharp.Core.FSharpOption`1[System.String] get_NamespaceToOpen()
+FSharp.Compiler.EditorServices.DeclarationListItem: System.String FullName
+FSharp.Compiler.EditorServices.DeclarationListItem: System.String Name
+FSharp.Compiler.EditorServices.DeclarationListItem: System.String NameInCode
+FSharp.Compiler.EditorServices.DeclarationListItem: System.String NameInList
+FSharp.Compiler.EditorServices.DeclarationListItem: System.String get_FullName()
+FSharp.Compiler.EditorServices.DeclarationListItem: System.String get_Name()
+FSharp.Compiler.EditorServices.DeclarationListItem: System.String get_NameInCode()
+FSharp.Compiler.EditorServices.DeclarationListItem: System.String get_NameInList()
+FSharp.Compiler.EditorServices.EntityCache: T Locking[T](Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.EditorServices.IAssemblyContentCache,T])
+FSharp.Compiler.EditorServices.EntityCache: Void .ctor()
+FSharp.Compiler.EditorServices.EntityCache: Void Clear()
+FSharp.Compiler.EditorServices.EntityKind+FunctionOrValue: Boolean get_isActivePattern()
+FSharp.Compiler.EditorServices.EntityKind+FunctionOrValue: Boolean isActivePattern
+FSharp.Compiler.EditorServices.EntityKind+Module: FSharp.Compiler.EditorServices.ModuleKind Item
+FSharp.Compiler.EditorServices.EntityKind+Module: FSharp.Compiler.EditorServices.ModuleKind get_Item()
+FSharp.Compiler.EditorServices.EntityKind+Tags: Int32 Attribute
+FSharp.Compiler.EditorServices.EntityKind+Tags: Int32 FunctionOrValue
+FSharp.Compiler.EditorServices.EntityKind+Tags: Int32 Module
+FSharp.Compiler.EditorServices.EntityKind+Tags: Int32 Type
+FSharp.Compiler.EditorServices.EntityKind: Boolean Equals(FSharp.Compiler.EditorServices.EntityKind)
+FSharp.Compiler.EditorServices.EntityKind: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.EntityKind: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.EntityKind: Boolean IsAttribute
+FSharp.Compiler.EditorServices.EntityKind: Boolean IsFunctionOrValue
+FSharp.Compiler.EditorServices.EntityKind: Boolean IsModule
+FSharp.Compiler.EditorServices.EntityKind: Boolean IsType
+FSharp.Compiler.EditorServices.EntityKind: Boolean get_IsAttribute()
+FSharp.Compiler.EditorServices.EntityKind: Boolean get_IsFunctionOrValue()
+FSharp.Compiler.EditorServices.EntityKind: Boolean get_IsModule()
+FSharp.Compiler.EditorServices.EntityKind: Boolean get_IsType()
+FSharp.Compiler.EditorServices.EntityKind: FSharp.Compiler.EditorServices.EntityKind Attribute
+FSharp.Compiler.EditorServices.EntityKind: FSharp.Compiler.EditorServices.EntityKind NewFunctionOrValue(Boolean)
+FSharp.Compiler.EditorServices.EntityKind: FSharp.Compiler.EditorServices.EntityKind NewModule(FSharp.Compiler.EditorServices.ModuleKind)
+FSharp.Compiler.EditorServices.EntityKind: FSharp.Compiler.EditorServices.EntityKind Type
+FSharp.Compiler.EditorServices.EntityKind: FSharp.Compiler.EditorServices.EntityKind get_Attribute()
+FSharp.Compiler.EditorServices.EntityKind: FSharp.Compiler.EditorServices.EntityKind get_Type()
+FSharp.Compiler.EditorServices.EntityKind: FSharp.Compiler.EditorServices.EntityKind+FunctionOrValue
+FSharp.Compiler.EditorServices.EntityKind: FSharp.Compiler.EditorServices.EntityKind+Module
+FSharp.Compiler.EditorServices.EntityKind: FSharp.Compiler.EditorServices.EntityKind+Tags
+FSharp.Compiler.EditorServices.EntityKind: Int32 CompareTo(FSharp.Compiler.EditorServices.EntityKind)
+FSharp.Compiler.EditorServices.EntityKind: Int32 CompareTo(System.Object)
+FSharp.Compiler.EditorServices.EntityKind: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.EditorServices.EntityKind: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.EntityKind: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.EntityKind: Int32 Tag
+FSharp.Compiler.EditorServices.EntityKind: Int32 get_Tag()
+FSharp.Compiler.EditorServices.EntityKind: System.String ToString()
+FSharp.Compiler.EditorServices.FSharpGlyph+Tags: Int32 Class
+FSharp.Compiler.EditorServices.FSharpGlyph+Tags: Int32 Constant
+FSharp.Compiler.EditorServices.FSharpGlyph+Tags: Int32 Delegate
+FSharp.Compiler.EditorServices.FSharpGlyph+Tags: Int32 Enum
+FSharp.Compiler.EditorServices.FSharpGlyph+Tags: Int32 EnumMember
+FSharp.Compiler.EditorServices.FSharpGlyph+Tags: Int32 Error
+FSharp.Compiler.EditorServices.FSharpGlyph+Tags: Int32 Event
+FSharp.Compiler.EditorServices.FSharpGlyph+Tags: Int32 Exception
+FSharp.Compiler.EditorServices.FSharpGlyph+Tags: Int32 ExtensionMethod
+FSharp.Compiler.EditorServices.FSharpGlyph+Tags: Int32 Field
+FSharp.Compiler.EditorServices.FSharpGlyph+Tags: Int32 Interface
+FSharp.Compiler.EditorServices.FSharpGlyph+Tags: Int32 Method
+FSharp.Compiler.EditorServices.FSharpGlyph+Tags: Int32 Module
+FSharp.Compiler.EditorServices.FSharpGlyph+Tags: Int32 NameSpace
+FSharp.Compiler.EditorServices.FSharpGlyph+Tags: Int32 OverridenMethod
+FSharp.Compiler.EditorServices.FSharpGlyph+Tags: Int32 Property
+FSharp.Compiler.EditorServices.FSharpGlyph+Tags: Int32 Struct
+FSharp.Compiler.EditorServices.FSharpGlyph+Tags: Int32 Type
+FSharp.Compiler.EditorServices.FSharpGlyph+Tags: Int32 TypeParameter
+FSharp.Compiler.EditorServices.FSharpGlyph+Tags: Int32 Typedef
+FSharp.Compiler.EditorServices.FSharpGlyph+Tags: Int32 Union
+FSharp.Compiler.EditorServices.FSharpGlyph+Tags: Int32 Variable
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean Equals(FSharp.Compiler.EditorServices.FSharpGlyph)
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean IsClass
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean IsConstant
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean IsDelegate
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean IsEnum
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean IsEnumMember
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean IsError
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean IsEvent
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean IsException
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean IsExtensionMethod
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean IsField
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean IsInterface
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean IsMethod
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean IsModule
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean IsNameSpace
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean IsOverridenMethod
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean IsProperty
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean IsStruct
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean IsType
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean IsTypeParameter
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean IsTypedef
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean IsUnion
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean IsVariable
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean get_IsClass()
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean get_IsConstant()
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean get_IsDelegate()
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean get_IsEnum()
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean get_IsEnumMember()
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean get_IsError()
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean get_IsEvent()
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean get_IsException()
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean get_IsExtensionMethod()
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean get_IsField()
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean get_IsInterface()
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean get_IsMethod()
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean get_IsModule()
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean get_IsNameSpace()
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean get_IsOverridenMethod()
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean get_IsProperty()
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean get_IsStruct()
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean get_IsType()
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean get_IsTypeParameter()
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean get_IsTypedef()
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean get_IsUnion()
+FSharp.Compiler.EditorServices.FSharpGlyph: Boolean get_IsVariable()
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph Class
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph Constant
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph Delegate
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph Enum
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph EnumMember
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph Error
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph Event
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph Exception
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph ExtensionMethod
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph Field
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph Interface
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph Method
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph Module
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph NameSpace
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph OverridenMethod
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph Property
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph Struct
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph Type
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph TypeParameter
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph Typedef
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph Union
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph Variable
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph get_Class()
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph get_Constant()
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph get_Delegate()
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph get_Enum()
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph get_EnumMember()
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph get_Error()
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph get_Event()
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph get_Exception()
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph get_ExtensionMethod()
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph get_Field()
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph get_Interface()
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph get_Method()
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph get_Module()
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph get_NameSpace()
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph get_OverridenMethod()
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph get_Property()
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph get_Struct()
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph get_Type()
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph get_TypeParameter()
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph get_Typedef()
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph get_Union()
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph get_Variable()
+FSharp.Compiler.EditorServices.FSharpGlyph: FSharp.Compiler.EditorServices.FSharpGlyph+Tags
+FSharp.Compiler.EditorServices.FSharpGlyph: Int32 CompareTo(FSharp.Compiler.EditorServices.FSharpGlyph)
+FSharp.Compiler.EditorServices.FSharpGlyph: Int32 CompareTo(System.Object)
+FSharp.Compiler.EditorServices.FSharpGlyph: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.EditorServices.FSharpGlyph: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.FSharpGlyph: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.FSharpGlyph: Int32 Tag
+FSharp.Compiler.EditorServices.FSharpGlyph: Int32 get_Tag()
+FSharp.Compiler.EditorServices.FSharpGlyph: System.String ToString()
+FSharp.Compiler.EditorServices.FindDeclExternalParam: Boolean Equals(FSharp.Compiler.EditorServices.FindDeclExternalParam)
+FSharp.Compiler.EditorServices.FindDeclExternalParam: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.FindDeclExternalParam: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.FindDeclExternalParam: Boolean IsByRef
+FSharp.Compiler.EditorServices.FindDeclExternalParam: Boolean get_IsByRef()
+FSharp.Compiler.EditorServices.FindDeclExternalParam: FSharp.Compiler.EditorServices.FindDeclExternalParam Create(FSharp.Compiler.EditorServices.FindDeclExternalType, Boolean)
+FSharp.Compiler.EditorServices.FindDeclExternalParam: FSharp.Compiler.EditorServices.FindDeclExternalType ParameterType
+FSharp.Compiler.EditorServices.FindDeclExternalParam: FSharp.Compiler.EditorServices.FindDeclExternalType get_ParameterType()
+FSharp.Compiler.EditorServices.FindDeclExternalParam: Int32 CompareTo(FSharp.Compiler.EditorServices.FindDeclExternalParam)
+FSharp.Compiler.EditorServices.FindDeclExternalParam: Int32 CompareTo(System.Object)
+FSharp.Compiler.EditorServices.FindDeclExternalParam: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.EditorServices.FindDeclExternalParam: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.FindDeclExternalParam: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.FindDeclExternalParam: System.String ToString()
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Constructor: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.FindDeclExternalParam] args
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Constructor: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.FindDeclExternalParam] get_args()
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Constructor: System.String get_typeName()
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Constructor: System.String typeName
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Event: System.String get_name()
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Event: System.String get_typeName()
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Event: System.String name
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Event: System.String typeName
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Field: System.String get_name()
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Field: System.String get_typeName()
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Field: System.String name
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Field: System.String typeName
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Method: Int32 genericArity
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Method: Int32 get_genericArity()
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Method: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.FindDeclExternalParam] get_paramSyms()
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Method: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.FindDeclExternalParam] paramSyms
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Method: System.String get_name()
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Method: System.String get_typeName()
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Method: System.String name
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Method: System.String typeName
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Property: System.String get_name()
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Property: System.String get_typeName()
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Property: System.String name
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Property: System.String typeName
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Tags: Int32 Constructor
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Tags: Int32 Event
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Tags: Int32 Field
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Tags: Int32 Method
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Tags: Int32 Property
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Tags: Int32 Type
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Type: System.String fullName
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Type: System.String get_fullName()
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: Boolean Equals(FSharp.Compiler.EditorServices.FindDeclExternalSymbol)
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: Boolean IsConstructor
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: Boolean IsEvent
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: Boolean IsField
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: Boolean IsMethod
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: Boolean IsProperty
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: Boolean IsType
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: Boolean get_IsConstructor()
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: Boolean get_IsEvent()
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: Boolean get_IsField()
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: Boolean get_IsMethod()
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: Boolean get_IsProperty()
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: Boolean get_IsType()
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: FSharp.Compiler.EditorServices.FindDeclExternalSymbol NewConstructor(System.String, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.FindDeclExternalParam])
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: FSharp.Compiler.EditorServices.FindDeclExternalSymbol NewEvent(System.String, System.String)
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: FSharp.Compiler.EditorServices.FindDeclExternalSymbol NewField(System.String, System.String)
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: FSharp.Compiler.EditorServices.FindDeclExternalSymbol NewMethod(System.String, System.String, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.FindDeclExternalParam], Int32)
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: FSharp.Compiler.EditorServices.FindDeclExternalSymbol NewProperty(System.String, System.String)
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: FSharp.Compiler.EditorServices.FindDeclExternalSymbol NewType(System.String)
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Constructor
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Event
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Field
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Method
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Property
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Tags
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: FSharp.Compiler.EditorServices.FindDeclExternalSymbol+Type
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: Int32 CompareTo(FSharp.Compiler.EditorServices.FindDeclExternalSymbol)
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: Int32 CompareTo(System.Object)
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: Int32 Tag
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: Int32 get_Tag()
+FSharp.Compiler.EditorServices.FindDeclExternalSymbol: System.String ToString()
+FSharp.Compiler.EditorServices.FindDeclExternalType+Array: FSharp.Compiler.EditorServices.FindDeclExternalType get_inner()
+FSharp.Compiler.EditorServices.FindDeclExternalType+Array: FSharp.Compiler.EditorServices.FindDeclExternalType inner
+FSharp.Compiler.EditorServices.FindDeclExternalType+Pointer: FSharp.Compiler.EditorServices.FindDeclExternalType get_inner()
+FSharp.Compiler.EditorServices.FindDeclExternalType+Pointer: FSharp.Compiler.EditorServices.FindDeclExternalType inner
+FSharp.Compiler.EditorServices.FindDeclExternalType+Tags: Int32 Array
+FSharp.Compiler.EditorServices.FindDeclExternalType+Tags: Int32 Pointer
+FSharp.Compiler.EditorServices.FindDeclExternalType+Tags: Int32 Type
+FSharp.Compiler.EditorServices.FindDeclExternalType+Tags: Int32 TypeVar
+FSharp.Compiler.EditorServices.FindDeclExternalType+Type: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.FindDeclExternalType] genericArgs
+FSharp.Compiler.EditorServices.FindDeclExternalType+Type: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.FindDeclExternalType] get_genericArgs()
+FSharp.Compiler.EditorServices.FindDeclExternalType+Type: System.String fullName
+FSharp.Compiler.EditorServices.FindDeclExternalType+Type: System.String get_fullName()
+FSharp.Compiler.EditorServices.FindDeclExternalType+TypeVar: System.String get_typeName()
+FSharp.Compiler.EditorServices.FindDeclExternalType+TypeVar: System.String typeName
+FSharp.Compiler.EditorServices.FindDeclExternalType: Boolean Equals(FSharp.Compiler.EditorServices.FindDeclExternalType)
+FSharp.Compiler.EditorServices.FindDeclExternalType: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.FindDeclExternalType: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.FindDeclExternalType: Boolean IsArray
+FSharp.Compiler.EditorServices.FindDeclExternalType: Boolean IsPointer
+FSharp.Compiler.EditorServices.FindDeclExternalType: Boolean IsType
+FSharp.Compiler.EditorServices.FindDeclExternalType: Boolean IsTypeVar
+FSharp.Compiler.EditorServices.FindDeclExternalType: Boolean get_IsArray()
+FSharp.Compiler.EditorServices.FindDeclExternalType: Boolean get_IsPointer()
+FSharp.Compiler.EditorServices.FindDeclExternalType: Boolean get_IsType()
+FSharp.Compiler.EditorServices.FindDeclExternalType: Boolean get_IsTypeVar()
+FSharp.Compiler.EditorServices.FindDeclExternalType: FSharp.Compiler.EditorServices.FindDeclExternalType NewArray(FSharp.Compiler.EditorServices.FindDeclExternalType)
+FSharp.Compiler.EditorServices.FindDeclExternalType: FSharp.Compiler.EditorServices.FindDeclExternalType NewPointer(FSharp.Compiler.EditorServices.FindDeclExternalType)
+FSharp.Compiler.EditorServices.FindDeclExternalType: FSharp.Compiler.EditorServices.FindDeclExternalType NewType(System.String, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.FindDeclExternalType])
+FSharp.Compiler.EditorServices.FindDeclExternalType: FSharp.Compiler.EditorServices.FindDeclExternalType NewTypeVar(System.String)
+FSharp.Compiler.EditorServices.FindDeclExternalType: FSharp.Compiler.EditorServices.FindDeclExternalType+Array
+FSharp.Compiler.EditorServices.FindDeclExternalType: FSharp.Compiler.EditorServices.FindDeclExternalType+Pointer
+FSharp.Compiler.EditorServices.FindDeclExternalType: FSharp.Compiler.EditorServices.FindDeclExternalType+Tags
+FSharp.Compiler.EditorServices.FindDeclExternalType: FSharp.Compiler.EditorServices.FindDeclExternalType+Type
+FSharp.Compiler.EditorServices.FindDeclExternalType: FSharp.Compiler.EditorServices.FindDeclExternalType+TypeVar
+FSharp.Compiler.EditorServices.FindDeclExternalType: Int32 CompareTo(FSharp.Compiler.EditorServices.FindDeclExternalType)
+FSharp.Compiler.EditorServices.FindDeclExternalType: Int32 CompareTo(System.Object)
+FSharp.Compiler.EditorServices.FindDeclExternalType: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.EditorServices.FindDeclExternalType: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.FindDeclExternalType: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.FindDeclExternalType: Int32 Tag
+FSharp.Compiler.EditorServices.FindDeclExternalType: Int32 get_Tag()
+FSharp.Compiler.EditorServices.FindDeclExternalType: System.String ToString()
+FSharp.Compiler.EditorServices.FindDeclFailureReason+ProvidedMember: System.String get_memberName()
+FSharp.Compiler.EditorServices.FindDeclFailureReason+ProvidedMember: System.String memberName
+FSharp.Compiler.EditorServices.FindDeclFailureReason+ProvidedType: System.String get_typeName()
+FSharp.Compiler.EditorServices.FindDeclFailureReason+ProvidedType: System.String typeName
+FSharp.Compiler.EditorServices.FindDeclFailureReason+Tags: Int32 NoSourceCode
+FSharp.Compiler.EditorServices.FindDeclFailureReason+Tags: Int32 ProvidedMember
+FSharp.Compiler.EditorServices.FindDeclFailureReason+Tags: Int32 ProvidedType
+FSharp.Compiler.EditorServices.FindDeclFailureReason+Tags: Int32 Unknown
+FSharp.Compiler.EditorServices.FindDeclFailureReason+Unknown: System.String get_message()
+FSharp.Compiler.EditorServices.FindDeclFailureReason+Unknown: System.String message
+FSharp.Compiler.EditorServices.FindDeclFailureReason: Boolean Equals(FSharp.Compiler.EditorServices.FindDeclFailureReason)
+FSharp.Compiler.EditorServices.FindDeclFailureReason: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.FindDeclFailureReason: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.FindDeclFailureReason: Boolean IsNoSourceCode
+FSharp.Compiler.EditorServices.FindDeclFailureReason: Boolean IsProvidedMember
+FSharp.Compiler.EditorServices.FindDeclFailureReason: Boolean IsProvidedType
+FSharp.Compiler.EditorServices.FindDeclFailureReason: Boolean IsUnknown
+FSharp.Compiler.EditorServices.FindDeclFailureReason: Boolean get_IsNoSourceCode()
+FSharp.Compiler.EditorServices.FindDeclFailureReason: Boolean get_IsProvidedMember()
+FSharp.Compiler.EditorServices.FindDeclFailureReason: Boolean get_IsProvidedType()
+FSharp.Compiler.EditorServices.FindDeclFailureReason: Boolean get_IsUnknown()
+FSharp.Compiler.EditorServices.FindDeclFailureReason: FSharp.Compiler.EditorServices.FindDeclFailureReason NewProvidedMember(System.String)
+FSharp.Compiler.EditorServices.FindDeclFailureReason: FSharp.Compiler.EditorServices.FindDeclFailureReason NewProvidedType(System.String)
+FSharp.Compiler.EditorServices.FindDeclFailureReason: FSharp.Compiler.EditorServices.FindDeclFailureReason NewUnknown(System.String)
+FSharp.Compiler.EditorServices.FindDeclFailureReason: FSharp.Compiler.EditorServices.FindDeclFailureReason NoSourceCode
+FSharp.Compiler.EditorServices.FindDeclFailureReason: FSharp.Compiler.EditorServices.FindDeclFailureReason get_NoSourceCode()
+FSharp.Compiler.EditorServices.FindDeclFailureReason: FSharp.Compiler.EditorServices.FindDeclFailureReason+ProvidedMember
+FSharp.Compiler.EditorServices.FindDeclFailureReason: FSharp.Compiler.EditorServices.FindDeclFailureReason+ProvidedType
+FSharp.Compiler.EditorServices.FindDeclFailureReason: FSharp.Compiler.EditorServices.FindDeclFailureReason+Tags
+FSharp.Compiler.EditorServices.FindDeclFailureReason: FSharp.Compiler.EditorServices.FindDeclFailureReason+Unknown
+FSharp.Compiler.EditorServices.FindDeclFailureReason: Int32 CompareTo(FSharp.Compiler.EditorServices.FindDeclFailureReason)
+FSharp.Compiler.EditorServices.FindDeclFailureReason: Int32 CompareTo(System.Object)
+FSharp.Compiler.EditorServices.FindDeclFailureReason: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.EditorServices.FindDeclFailureReason: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.FindDeclFailureReason: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.FindDeclFailureReason: Int32 Tag
+FSharp.Compiler.EditorServices.FindDeclFailureReason: Int32 get_Tag()
+FSharp.Compiler.EditorServices.FindDeclFailureReason: System.String ToString()
+FSharp.Compiler.EditorServices.FindDeclResult+DeclFound: FSharp.Compiler.Text.Range get_location()
+FSharp.Compiler.EditorServices.FindDeclResult+DeclFound: FSharp.Compiler.Text.Range location
+FSharp.Compiler.EditorServices.FindDeclResult+DeclNotFound: FSharp.Compiler.EditorServices.FindDeclFailureReason Item
+FSharp.Compiler.EditorServices.FindDeclResult+DeclNotFound: FSharp.Compiler.EditorServices.FindDeclFailureReason get_Item()
+FSharp.Compiler.EditorServices.FindDeclResult+ExternalDecl: FSharp.Compiler.EditorServices.FindDeclExternalSymbol externalSym
+FSharp.Compiler.EditorServices.FindDeclResult+ExternalDecl: FSharp.Compiler.EditorServices.FindDeclExternalSymbol get_externalSym()
+FSharp.Compiler.EditorServices.FindDeclResult+ExternalDecl: System.String assembly
+FSharp.Compiler.EditorServices.FindDeclResult+ExternalDecl: System.String get_assembly()
+FSharp.Compiler.EditorServices.FindDeclResult+Tags: Int32 DeclFound
+FSharp.Compiler.EditorServices.FindDeclResult+Tags: Int32 DeclNotFound
+FSharp.Compiler.EditorServices.FindDeclResult+Tags: Int32 ExternalDecl
+FSharp.Compiler.EditorServices.FindDeclResult: Boolean Equals(FSharp.Compiler.EditorServices.FindDeclResult)
+FSharp.Compiler.EditorServices.FindDeclResult: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.FindDeclResult: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.FindDeclResult: Boolean IsDeclFound
+FSharp.Compiler.EditorServices.FindDeclResult: Boolean IsDeclNotFound
+FSharp.Compiler.EditorServices.FindDeclResult: Boolean IsExternalDecl
+FSharp.Compiler.EditorServices.FindDeclResult: Boolean get_IsDeclFound()
+FSharp.Compiler.EditorServices.FindDeclResult: Boolean get_IsDeclNotFound()
+FSharp.Compiler.EditorServices.FindDeclResult: Boolean get_IsExternalDecl()
+FSharp.Compiler.EditorServices.FindDeclResult: FSharp.Compiler.EditorServices.FindDeclResult NewDeclFound(FSharp.Compiler.Text.Range)
+FSharp.Compiler.EditorServices.FindDeclResult: FSharp.Compiler.EditorServices.FindDeclResult NewDeclNotFound(FSharp.Compiler.EditorServices.FindDeclFailureReason)
+FSharp.Compiler.EditorServices.FindDeclResult: FSharp.Compiler.EditorServices.FindDeclResult NewExternalDecl(System.String, FSharp.Compiler.EditorServices.FindDeclExternalSymbol)
+FSharp.Compiler.EditorServices.FindDeclResult: FSharp.Compiler.EditorServices.FindDeclResult+DeclFound
+FSharp.Compiler.EditorServices.FindDeclResult: FSharp.Compiler.EditorServices.FindDeclResult+DeclNotFound
+FSharp.Compiler.EditorServices.FindDeclResult: FSharp.Compiler.EditorServices.FindDeclResult+ExternalDecl
+FSharp.Compiler.EditorServices.FindDeclResult: FSharp.Compiler.EditorServices.FindDeclResult+Tags
+FSharp.Compiler.EditorServices.FindDeclResult: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.FindDeclResult: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.FindDeclResult: Int32 Tag
+FSharp.Compiler.EditorServices.FindDeclResult: Int32 get_Tag()
+FSharp.Compiler.EditorServices.FindDeclResult: System.String ToString()
+FSharp.Compiler.EditorServices.IAssemblyContentCache: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.EditorServices.AssemblyContentCacheEntry] TryGet(System.String)
+FSharp.Compiler.EditorServices.IAssemblyContentCache: Void Set(System.String, FSharp.Compiler.EditorServices.AssemblyContentCacheEntry)
+FSharp.Compiler.EditorServices.InheritanceContext+Tags: Int32 Class
+FSharp.Compiler.EditorServices.InheritanceContext+Tags: Int32 Interface
+FSharp.Compiler.EditorServices.InheritanceContext+Tags: Int32 Unknown
+FSharp.Compiler.EditorServices.InheritanceContext: Boolean Equals(FSharp.Compiler.EditorServices.InheritanceContext)
+FSharp.Compiler.EditorServices.InheritanceContext: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.InheritanceContext: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.InheritanceContext: Boolean IsClass
+FSharp.Compiler.EditorServices.InheritanceContext: Boolean IsInterface
+FSharp.Compiler.EditorServices.InheritanceContext: Boolean IsUnknown
+FSharp.Compiler.EditorServices.InheritanceContext: Boolean get_IsClass()
+FSharp.Compiler.EditorServices.InheritanceContext: Boolean get_IsInterface()
+FSharp.Compiler.EditorServices.InheritanceContext: Boolean get_IsUnknown()
+FSharp.Compiler.EditorServices.InheritanceContext: FSharp.Compiler.EditorServices.InheritanceContext Class
+FSharp.Compiler.EditorServices.InheritanceContext: FSharp.Compiler.EditorServices.InheritanceContext Interface
+FSharp.Compiler.EditorServices.InheritanceContext: FSharp.Compiler.EditorServices.InheritanceContext Unknown
+FSharp.Compiler.EditorServices.InheritanceContext: FSharp.Compiler.EditorServices.InheritanceContext get_Class()
+FSharp.Compiler.EditorServices.InheritanceContext: FSharp.Compiler.EditorServices.InheritanceContext get_Interface()
+FSharp.Compiler.EditorServices.InheritanceContext: FSharp.Compiler.EditorServices.InheritanceContext get_Unknown()
+FSharp.Compiler.EditorServices.InheritanceContext: FSharp.Compiler.EditorServices.InheritanceContext+Tags
+FSharp.Compiler.EditorServices.InheritanceContext: Int32 CompareTo(FSharp.Compiler.EditorServices.InheritanceContext)
+FSharp.Compiler.EditorServices.InheritanceContext: Int32 CompareTo(System.Object)
+FSharp.Compiler.EditorServices.InheritanceContext: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.EditorServices.InheritanceContext: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.InheritanceContext: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.InheritanceContext: Int32 Tag
+FSharp.Compiler.EditorServices.InheritanceContext: Int32 get_Tag()
+FSharp.Compiler.EditorServices.InheritanceContext: System.String ToString()
+FSharp.Compiler.EditorServices.InsertionContext: Boolean Equals(FSharp.Compiler.EditorServices.InsertionContext)
+FSharp.Compiler.EditorServices.InsertionContext: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.InsertionContext: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.InsertionContext: FSharp.Compiler.EditorServices.ScopeKind ScopeKind
+FSharp.Compiler.EditorServices.InsertionContext: FSharp.Compiler.EditorServices.ScopeKind get_ScopeKind()
+FSharp.Compiler.EditorServices.InsertionContext: FSharp.Compiler.Text.Position Pos
+FSharp.Compiler.EditorServices.InsertionContext: FSharp.Compiler.Text.Position get_Pos()
+FSharp.Compiler.EditorServices.InsertionContext: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.InsertionContext: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.InsertionContext: System.String ToString()
+FSharp.Compiler.EditorServices.InsertionContext: Void .ctor(FSharp.Compiler.EditorServices.ScopeKind, FSharp.Compiler.Text.Position)
+FSharp.Compiler.EditorServices.InsertionContextEntity: Boolean Equals(FSharp.Compiler.EditorServices.InsertionContextEntity)
+FSharp.Compiler.EditorServices.InsertionContextEntity: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.InsertionContextEntity: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.InsertionContextEntity: Int32 CompareTo(FSharp.Compiler.EditorServices.InsertionContextEntity)
+FSharp.Compiler.EditorServices.InsertionContextEntity: Int32 CompareTo(System.Object)
+FSharp.Compiler.EditorServices.InsertionContextEntity: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.EditorServices.InsertionContextEntity: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.InsertionContextEntity: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.InsertionContextEntity: Microsoft.FSharp.Core.FSharpOption`1[System.String] Namespace
+FSharp.Compiler.EditorServices.InsertionContextEntity: Microsoft.FSharp.Core.FSharpOption`1[System.String] get_Namespace()
+FSharp.Compiler.EditorServices.InsertionContextEntity: System.String FullDisplayName
+FSharp.Compiler.EditorServices.InsertionContextEntity: System.String FullRelativeName
+FSharp.Compiler.EditorServices.InsertionContextEntity: System.String LastIdent
+FSharp.Compiler.EditorServices.InsertionContextEntity: System.String Qualifier
+FSharp.Compiler.EditorServices.InsertionContextEntity: System.String ToString()
+FSharp.Compiler.EditorServices.InsertionContextEntity: System.String get_FullDisplayName()
+FSharp.Compiler.EditorServices.InsertionContextEntity: System.String get_FullRelativeName()
+FSharp.Compiler.EditorServices.InsertionContextEntity: System.String get_LastIdent()
+FSharp.Compiler.EditorServices.InsertionContextEntity: System.String get_Qualifier()
+FSharp.Compiler.EditorServices.InsertionContextEntity: Void .ctor(System.String, System.String, Microsoft.FSharp.Core.FSharpOption`1[System.String], System.String, System.String)
+FSharp.Compiler.EditorServices.InterfaceData+Interface: FSharp.Compiler.Syntax.SynType get_interfaceType()
+FSharp.Compiler.EditorServices.InterfaceData+Interface: FSharp.Compiler.Syntax.SynType interfaceType
+FSharp.Compiler.EditorServices.InterfaceData+Interface: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn]] get_memberDefns()
+FSharp.Compiler.EditorServices.InterfaceData+Interface: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn]] memberDefns
+FSharp.Compiler.EditorServices.InterfaceData+ObjExpr: FSharp.Compiler.Syntax.SynType get_objType()
+FSharp.Compiler.EditorServices.InterfaceData+ObjExpr: FSharp.Compiler.Syntax.SynType objType
+FSharp.Compiler.EditorServices.InterfaceData+ObjExpr: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynBinding] bindings
+FSharp.Compiler.EditorServices.InterfaceData+ObjExpr: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynBinding] get_bindings()
+FSharp.Compiler.EditorServices.InterfaceData+Tags: Int32 Interface
+FSharp.Compiler.EditorServices.InterfaceData+Tags: Int32 ObjExpr
+FSharp.Compiler.EditorServices.InterfaceData: Boolean IsInterface
+FSharp.Compiler.EditorServices.InterfaceData: Boolean IsObjExpr
+FSharp.Compiler.EditorServices.InterfaceData: Boolean get_IsInterface()
+FSharp.Compiler.EditorServices.InterfaceData: Boolean get_IsObjExpr()
+FSharp.Compiler.EditorServices.InterfaceData: FSharp.Compiler.EditorServices.InterfaceData NewInterface(FSharp.Compiler.Syntax.SynType, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn]])
+FSharp.Compiler.EditorServices.InterfaceData: FSharp.Compiler.EditorServices.InterfaceData NewObjExpr(FSharp.Compiler.Syntax.SynType, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynBinding])
+FSharp.Compiler.EditorServices.InterfaceData: FSharp.Compiler.EditorServices.InterfaceData+Interface
+FSharp.Compiler.EditorServices.InterfaceData: FSharp.Compiler.EditorServices.InterfaceData+ObjExpr
+FSharp.Compiler.EditorServices.InterfaceData: FSharp.Compiler.EditorServices.InterfaceData+Tags
+FSharp.Compiler.EditorServices.InterfaceData: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.EditorServices.InterfaceData: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.EditorServices.InterfaceData: Int32 Tag
+FSharp.Compiler.EditorServices.InterfaceData: Int32 get_Tag()
+FSharp.Compiler.EditorServices.InterfaceData: System.String ToString()
+FSharp.Compiler.EditorServices.InterfaceData: System.String[] TypeParameters
+FSharp.Compiler.EditorServices.InterfaceData: System.String[] get_TypeParameters()
+FSharp.Compiler.EditorServices.InterfaceStubGenerator: Boolean HasNoInterfaceMember(FSharp.Compiler.Symbols.FSharpEntity)
+FSharp.Compiler.EditorServices.InterfaceStubGenerator: Boolean IsInterface(FSharp.Compiler.Symbols.FSharpEntity)
+FSharp.Compiler.EditorServices.InterfaceStubGenerator: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[System.String,FSharp.Compiler.Text.Range]] GetMemberNameAndRanges(FSharp.Compiler.EditorServices.InterfaceData)
+FSharp.Compiler.EditorServices.InterfaceStubGenerator: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Collections.FSharpSet`1[System.String]] GetImplementedMemberSignatures(Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[System.String,FSharp.Compiler.Text.Range],Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.CodeAnalysis.FSharpSymbolUse]], FSharp.Compiler.Symbols.FSharpDisplayContext, FSharp.Compiler.EditorServices.InterfaceData)
+FSharp.Compiler.EditorServices.InterfaceStubGenerator: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.EditorServices.InterfaceData] TryFindInterfaceDeclaration(FSharp.Compiler.Text.Position, FSharp.Compiler.Syntax.ParsedInput)
+FSharp.Compiler.EditorServices.InterfaceStubGenerator: System.Collections.Generic.IEnumerable`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue,System.Collections.Generic.IEnumerable`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpGenericParameter,FSharp.Compiler.Symbols.FSharpType]]]] GetInterfaceMembers(FSharp.Compiler.Symbols.FSharpEntity)
+FSharp.Compiler.EditorServices.InterfaceStubGenerator: System.String FormatInterface(Int32, Int32, System.String[], System.String, System.String, FSharp.Compiler.Symbols.FSharpDisplayContext, Microsoft.FSharp.Collections.FSharpSet`1[System.String], FSharp.Compiler.Symbols.FSharpEntity, Boolean)
+FSharp.Compiler.EditorServices.LookupType+Tags: Int32 Fuzzy
+FSharp.Compiler.EditorServices.LookupType+Tags: Int32 Precise
+FSharp.Compiler.EditorServices.LookupType: Boolean Equals(FSharp.Compiler.EditorServices.LookupType)
+FSharp.Compiler.EditorServices.LookupType: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.LookupType: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.LookupType: Boolean IsFuzzy
+FSharp.Compiler.EditorServices.LookupType: Boolean IsPrecise
+FSharp.Compiler.EditorServices.LookupType: Boolean get_IsFuzzy()
+FSharp.Compiler.EditorServices.LookupType: Boolean get_IsPrecise()
+FSharp.Compiler.EditorServices.LookupType: FSharp.Compiler.EditorServices.LookupType Fuzzy
+FSharp.Compiler.EditorServices.LookupType: FSharp.Compiler.EditorServices.LookupType Precise
+FSharp.Compiler.EditorServices.LookupType: FSharp.Compiler.EditorServices.LookupType get_Fuzzy()
+FSharp.Compiler.EditorServices.LookupType: FSharp.Compiler.EditorServices.LookupType get_Precise()
+FSharp.Compiler.EditorServices.LookupType: FSharp.Compiler.EditorServices.LookupType+Tags
+FSharp.Compiler.EditorServices.LookupType: Int32 CompareTo(FSharp.Compiler.EditorServices.LookupType)
+FSharp.Compiler.EditorServices.LookupType: Int32 CompareTo(System.Object)
+FSharp.Compiler.EditorServices.LookupType: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.EditorServices.LookupType: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.LookupType: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.LookupType: Int32 Tag
+FSharp.Compiler.EditorServices.LookupType: Int32 get_Tag()
+FSharp.Compiler.EditorServices.LookupType: System.String ToString()
+FSharp.Compiler.EditorServices.MaybeUnresolvedIdent: Boolean Equals(FSharp.Compiler.EditorServices.MaybeUnresolvedIdent)
+FSharp.Compiler.EditorServices.MaybeUnresolvedIdent: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.MaybeUnresolvedIdent: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.MaybeUnresolvedIdent: Boolean Resolved
+FSharp.Compiler.EditorServices.MaybeUnresolvedIdent: Boolean get_Resolved()
+FSharp.Compiler.EditorServices.MaybeUnresolvedIdent: Int32 CompareTo(FSharp.Compiler.EditorServices.MaybeUnresolvedIdent)
+FSharp.Compiler.EditorServices.MaybeUnresolvedIdent: Int32 CompareTo(System.Object)
+FSharp.Compiler.EditorServices.MaybeUnresolvedIdent: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.EditorServices.MaybeUnresolvedIdent: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.MaybeUnresolvedIdent: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.MaybeUnresolvedIdent: System.String Ident
+FSharp.Compiler.EditorServices.MaybeUnresolvedIdent: System.String ToString()
+FSharp.Compiler.EditorServices.MaybeUnresolvedIdent: System.String get_Ident()
+FSharp.Compiler.EditorServices.MaybeUnresolvedIdent: Void .ctor(System.String, Boolean)
+FSharp.Compiler.EditorServices.MethodGroup: FSharp.Compiler.EditorServices.MethodGroupItem[] Methods
+FSharp.Compiler.EditorServices.MethodGroup: FSharp.Compiler.EditorServices.MethodGroupItem[] get_Methods()
+FSharp.Compiler.EditorServices.MethodGroup: System.String MethodName
+FSharp.Compiler.EditorServices.MethodGroup: System.String get_MethodName()
+FSharp.Compiler.EditorServices.MethodGroupItem: Boolean HasParamArrayArg
+FSharp.Compiler.EditorServices.MethodGroupItem: Boolean HasParameters
+FSharp.Compiler.EditorServices.MethodGroupItem: Boolean get_HasParamArrayArg()
+FSharp.Compiler.EditorServices.MethodGroupItem: Boolean get_HasParameters()
+FSharp.Compiler.EditorServices.MethodGroupItem: FSharp.Compiler.EditorServices.MethodGroupItemParameter[] Parameters
+FSharp.Compiler.EditorServices.MethodGroupItem: FSharp.Compiler.EditorServices.MethodGroupItemParameter[] StaticParameters
+FSharp.Compiler.EditorServices.MethodGroupItem: FSharp.Compiler.EditorServices.MethodGroupItemParameter[] get_Parameters()
+FSharp.Compiler.EditorServices.MethodGroupItem: FSharp.Compiler.EditorServices.MethodGroupItemParameter[] get_StaticParameters()
+FSharp.Compiler.EditorServices.MethodGroupItem: FSharp.Compiler.EditorServices.ToolTipText Description
+FSharp.Compiler.EditorServices.MethodGroupItem: FSharp.Compiler.EditorServices.ToolTipText get_Description()
+FSharp.Compiler.EditorServices.MethodGroupItem: FSharp.Compiler.Symbols.FSharpXmlDoc XmlDoc
+FSharp.Compiler.EditorServices.MethodGroupItem: FSharp.Compiler.Symbols.FSharpXmlDoc get_XmlDoc()
+FSharp.Compiler.EditorServices.MethodGroupItem: FSharp.Compiler.Text.TaggedText[] ReturnTypeText
+FSharp.Compiler.EditorServices.MethodGroupItem: FSharp.Compiler.Text.TaggedText[] get_ReturnTypeText()
+FSharp.Compiler.EditorServices.MethodGroupItemParameter: Boolean IsOptional
+FSharp.Compiler.EditorServices.MethodGroupItemParameter: Boolean get_IsOptional()
+FSharp.Compiler.EditorServices.MethodGroupItemParameter: FSharp.Compiler.Text.TaggedText[] Display
+FSharp.Compiler.EditorServices.MethodGroupItemParameter: FSharp.Compiler.Text.TaggedText[] get_Display()
+FSharp.Compiler.EditorServices.MethodGroupItemParameter: System.String CanonicalTypeTextForSorting
+FSharp.Compiler.EditorServices.MethodGroupItemParameter: System.String ParameterName
+FSharp.Compiler.EditorServices.MethodGroupItemParameter: System.String get_CanonicalTypeTextForSorting()
+FSharp.Compiler.EditorServices.MethodGroupItemParameter: System.String get_ParameterName()
+FSharp.Compiler.EditorServices.ModuleKind: Boolean Equals(FSharp.Compiler.EditorServices.ModuleKind)
+FSharp.Compiler.EditorServices.ModuleKind: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.ModuleKind: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.ModuleKind: Boolean HasModuleSuffix
+FSharp.Compiler.EditorServices.ModuleKind: Boolean IsAutoOpen
+FSharp.Compiler.EditorServices.ModuleKind: Boolean get_HasModuleSuffix()
+FSharp.Compiler.EditorServices.ModuleKind: Boolean get_IsAutoOpen()
+FSharp.Compiler.EditorServices.ModuleKind: Int32 CompareTo(FSharp.Compiler.EditorServices.ModuleKind)
+FSharp.Compiler.EditorServices.ModuleKind: Int32 CompareTo(System.Object)
+FSharp.Compiler.EditorServices.ModuleKind: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.EditorServices.ModuleKind: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.ModuleKind: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.ModuleKind: System.String ToString()
+FSharp.Compiler.EditorServices.ModuleKind: Void .ctor(Boolean, Boolean)
+FSharp.Compiler.EditorServices.NavigableContainer: Boolean Equals(FSharp.Compiler.EditorServices.NavigableContainer)
+FSharp.Compiler.EditorServices.NavigableContainer: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.NavigableContainer: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.NavigableContainer: FSharp.Compiler.EditorServices.NavigableContainerType Type
+FSharp.Compiler.EditorServices.NavigableContainer: FSharp.Compiler.EditorServices.NavigableContainerType get_Type()
+FSharp.Compiler.EditorServices.NavigableContainer: Int32 CompareTo(FSharp.Compiler.EditorServices.NavigableContainer)
+FSharp.Compiler.EditorServices.NavigableContainer: Int32 CompareTo(System.Object)
+FSharp.Compiler.EditorServices.NavigableContainer: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.EditorServices.NavigableContainer: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.NavigableContainer: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.NavigableContainer: System.String LogicalName
+FSharp.Compiler.EditorServices.NavigableContainer: System.String ToString()
+FSharp.Compiler.EditorServices.NavigableContainer: System.String get_LogicalName()
+FSharp.Compiler.EditorServices.NavigableContainer: Void .ctor(FSharp.Compiler.EditorServices.NavigableContainerType, System.String)
+FSharp.Compiler.EditorServices.NavigableContainerType+Tags: Int32 Exception
+FSharp.Compiler.EditorServices.NavigableContainerType+Tags: Int32 File
+FSharp.Compiler.EditorServices.NavigableContainerType+Tags: Int32 Module
+FSharp.Compiler.EditorServices.NavigableContainerType+Tags: Int32 Namespace
+FSharp.Compiler.EditorServices.NavigableContainerType+Tags: Int32 Type
+FSharp.Compiler.EditorServices.NavigableContainerType: Boolean Equals(FSharp.Compiler.EditorServices.NavigableContainerType)
+FSharp.Compiler.EditorServices.NavigableContainerType: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.NavigableContainerType: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.NavigableContainerType: Boolean IsException
+FSharp.Compiler.EditorServices.NavigableContainerType: Boolean IsFile
+FSharp.Compiler.EditorServices.NavigableContainerType: Boolean IsModule
+FSharp.Compiler.EditorServices.NavigableContainerType: Boolean IsNamespace
+FSharp.Compiler.EditorServices.NavigableContainerType: Boolean IsType
+FSharp.Compiler.EditorServices.NavigableContainerType: Boolean get_IsException()
+FSharp.Compiler.EditorServices.NavigableContainerType: Boolean get_IsFile()
+FSharp.Compiler.EditorServices.NavigableContainerType: Boolean get_IsModule()
+FSharp.Compiler.EditorServices.NavigableContainerType: Boolean get_IsNamespace()
+FSharp.Compiler.EditorServices.NavigableContainerType: Boolean get_IsType()
+FSharp.Compiler.EditorServices.NavigableContainerType: FSharp.Compiler.EditorServices.NavigableContainerType Exception
+FSharp.Compiler.EditorServices.NavigableContainerType: FSharp.Compiler.EditorServices.NavigableContainerType File
+FSharp.Compiler.EditorServices.NavigableContainerType: FSharp.Compiler.EditorServices.NavigableContainerType Module
+FSharp.Compiler.EditorServices.NavigableContainerType: FSharp.Compiler.EditorServices.NavigableContainerType Namespace
+FSharp.Compiler.EditorServices.NavigableContainerType: FSharp.Compiler.EditorServices.NavigableContainerType Type
+FSharp.Compiler.EditorServices.NavigableContainerType: FSharp.Compiler.EditorServices.NavigableContainerType get_Exception()
+FSharp.Compiler.EditorServices.NavigableContainerType: FSharp.Compiler.EditorServices.NavigableContainerType get_File()
+FSharp.Compiler.EditorServices.NavigableContainerType: FSharp.Compiler.EditorServices.NavigableContainerType get_Module()
+FSharp.Compiler.EditorServices.NavigableContainerType: FSharp.Compiler.EditorServices.NavigableContainerType get_Namespace()
+FSharp.Compiler.EditorServices.NavigableContainerType: FSharp.Compiler.EditorServices.NavigableContainerType get_Type()
+FSharp.Compiler.EditorServices.NavigableContainerType: FSharp.Compiler.EditorServices.NavigableContainerType+Tags
+FSharp.Compiler.EditorServices.NavigableContainerType: Int32 CompareTo(FSharp.Compiler.EditorServices.NavigableContainerType)
+FSharp.Compiler.EditorServices.NavigableContainerType: Int32 CompareTo(System.Object)
+FSharp.Compiler.EditorServices.NavigableContainerType: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.EditorServices.NavigableContainerType: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.NavigableContainerType: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.NavigableContainerType: Int32 Tag
+FSharp.Compiler.EditorServices.NavigableContainerType: Int32 get_Tag()
+FSharp.Compiler.EditorServices.NavigableContainerType: System.String ToString()
+FSharp.Compiler.EditorServices.NavigableItem: Boolean Equals(FSharp.Compiler.EditorServices.NavigableItem)
+FSharp.Compiler.EditorServices.NavigableItem: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.NavigableItem: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.NavigableItem: Boolean IsSignature
+FSharp.Compiler.EditorServices.NavigableItem: Boolean get_IsSignature()
+FSharp.Compiler.EditorServices.NavigableItem: FSharp.Compiler.EditorServices.NavigableContainer Container
+FSharp.Compiler.EditorServices.NavigableItem: FSharp.Compiler.EditorServices.NavigableContainer get_Container()
+FSharp.Compiler.EditorServices.NavigableItem: FSharp.Compiler.EditorServices.NavigableItemKind Kind
+FSharp.Compiler.EditorServices.NavigableItem: FSharp.Compiler.EditorServices.NavigableItemKind get_Kind()
+FSharp.Compiler.EditorServices.NavigableItem: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.EditorServices.NavigableItem: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.EditorServices.NavigableItem: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.NavigableItem: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.NavigableItem: System.String LogicalName
+FSharp.Compiler.EditorServices.NavigableItem: System.String ToString()
+FSharp.Compiler.EditorServices.NavigableItem: System.String get_LogicalName()
+FSharp.Compiler.EditorServices.NavigableItem: Void .ctor(System.String, FSharp.Compiler.Text.Range, Boolean, FSharp.Compiler.EditorServices.NavigableItemKind, FSharp.Compiler.EditorServices.NavigableContainer)
+FSharp.Compiler.EditorServices.NavigableItemKind+Tags: Int32 Constructor
+FSharp.Compiler.EditorServices.NavigableItemKind+Tags: Int32 EnumCase
+FSharp.Compiler.EditorServices.NavigableItemKind+Tags: Int32 Exception
+FSharp.Compiler.EditorServices.NavigableItemKind+Tags: Int32 Field
+FSharp.Compiler.EditorServices.NavigableItemKind+Tags: Int32 Member
+FSharp.Compiler.EditorServices.NavigableItemKind+Tags: Int32 Module
+FSharp.Compiler.EditorServices.NavigableItemKind+Tags: Int32 ModuleAbbreviation
+FSharp.Compiler.EditorServices.NavigableItemKind+Tags: Int32 ModuleValue
+FSharp.Compiler.EditorServices.NavigableItemKind+Tags: Int32 Property
+FSharp.Compiler.EditorServices.NavigableItemKind+Tags: Int32 Type
+FSharp.Compiler.EditorServices.NavigableItemKind+Tags: Int32 UnionCase
+FSharp.Compiler.EditorServices.NavigableItemKind: Boolean Equals(FSharp.Compiler.EditorServices.NavigableItemKind)
+FSharp.Compiler.EditorServices.NavigableItemKind: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.NavigableItemKind: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.NavigableItemKind: Boolean IsConstructor
+FSharp.Compiler.EditorServices.NavigableItemKind: Boolean IsEnumCase
+FSharp.Compiler.EditorServices.NavigableItemKind: Boolean IsException
+FSharp.Compiler.EditorServices.NavigableItemKind: Boolean IsField
+FSharp.Compiler.EditorServices.NavigableItemKind: Boolean IsMember
+FSharp.Compiler.EditorServices.NavigableItemKind: Boolean IsModule
+FSharp.Compiler.EditorServices.NavigableItemKind: Boolean IsModuleAbbreviation
+FSharp.Compiler.EditorServices.NavigableItemKind: Boolean IsModuleValue
+FSharp.Compiler.EditorServices.NavigableItemKind: Boolean IsProperty
+FSharp.Compiler.EditorServices.NavigableItemKind: Boolean IsType
+FSharp.Compiler.EditorServices.NavigableItemKind: Boolean IsUnionCase
+FSharp.Compiler.EditorServices.NavigableItemKind: Boolean get_IsConstructor()
+FSharp.Compiler.EditorServices.NavigableItemKind: Boolean get_IsEnumCase()
+FSharp.Compiler.EditorServices.NavigableItemKind: Boolean get_IsException()
+FSharp.Compiler.EditorServices.NavigableItemKind: Boolean get_IsField()
+FSharp.Compiler.EditorServices.NavigableItemKind: Boolean get_IsMember()
+FSharp.Compiler.EditorServices.NavigableItemKind: Boolean get_IsModule()
+FSharp.Compiler.EditorServices.NavigableItemKind: Boolean get_IsModuleAbbreviation()
+FSharp.Compiler.EditorServices.NavigableItemKind: Boolean get_IsModuleValue()
+FSharp.Compiler.EditorServices.NavigableItemKind: Boolean get_IsProperty()
+FSharp.Compiler.EditorServices.NavigableItemKind: Boolean get_IsType()
+FSharp.Compiler.EditorServices.NavigableItemKind: Boolean get_IsUnionCase()
+FSharp.Compiler.EditorServices.NavigableItemKind: FSharp.Compiler.EditorServices.NavigableItemKind Constructor
+FSharp.Compiler.EditorServices.NavigableItemKind: FSharp.Compiler.EditorServices.NavigableItemKind EnumCase
+FSharp.Compiler.EditorServices.NavigableItemKind: FSharp.Compiler.EditorServices.NavigableItemKind Exception
+FSharp.Compiler.EditorServices.NavigableItemKind: FSharp.Compiler.EditorServices.NavigableItemKind Field
+FSharp.Compiler.EditorServices.NavigableItemKind: FSharp.Compiler.EditorServices.NavigableItemKind Member
+FSharp.Compiler.EditorServices.NavigableItemKind: FSharp.Compiler.EditorServices.NavigableItemKind Module
+FSharp.Compiler.EditorServices.NavigableItemKind: FSharp.Compiler.EditorServices.NavigableItemKind ModuleAbbreviation
+FSharp.Compiler.EditorServices.NavigableItemKind: FSharp.Compiler.EditorServices.NavigableItemKind ModuleValue
+FSharp.Compiler.EditorServices.NavigableItemKind: FSharp.Compiler.EditorServices.NavigableItemKind Property
+FSharp.Compiler.EditorServices.NavigableItemKind: FSharp.Compiler.EditorServices.NavigableItemKind Type
+FSharp.Compiler.EditorServices.NavigableItemKind: FSharp.Compiler.EditorServices.NavigableItemKind UnionCase
+FSharp.Compiler.EditorServices.NavigableItemKind: FSharp.Compiler.EditorServices.NavigableItemKind get_Constructor()
+FSharp.Compiler.EditorServices.NavigableItemKind: FSharp.Compiler.EditorServices.NavigableItemKind get_EnumCase()
+FSharp.Compiler.EditorServices.NavigableItemKind: FSharp.Compiler.EditorServices.NavigableItemKind get_Exception()
+FSharp.Compiler.EditorServices.NavigableItemKind: FSharp.Compiler.EditorServices.NavigableItemKind get_Field()
+FSharp.Compiler.EditorServices.NavigableItemKind: FSharp.Compiler.EditorServices.NavigableItemKind get_Member()
+FSharp.Compiler.EditorServices.NavigableItemKind: FSharp.Compiler.EditorServices.NavigableItemKind get_Module()
+FSharp.Compiler.EditorServices.NavigableItemKind: FSharp.Compiler.EditorServices.NavigableItemKind get_ModuleAbbreviation()
+FSharp.Compiler.EditorServices.NavigableItemKind: FSharp.Compiler.EditorServices.NavigableItemKind get_ModuleValue()
+FSharp.Compiler.EditorServices.NavigableItemKind: FSharp.Compiler.EditorServices.NavigableItemKind get_Property()
+FSharp.Compiler.EditorServices.NavigableItemKind: FSharp.Compiler.EditorServices.NavigableItemKind get_Type()
+FSharp.Compiler.EditorServices.NavigableItemKind: FSharp.Compiler.EditorServices.NavigableItemKind get_UnionCase()
+FSharp.Compiler.EditorServices.NavigableItemKind: FSharp.Compiler.EditorServices.NavigableItemKind+Tags
+FSharp.Compiler.EditorServices.NavigableItemKind: Int32 CompareTo(FSharp.Compiler.EditorServices.NavigableItemKind)
+FSharp.Compiler.EditorServices.NavigableItemKind: Int32 CompareTo(System.Object)
+FSharp.Compiler.EditorServices.NavigableItemKind: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.EditorServices.NavigableItemKind: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.NavigableItemKind: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.NavigableItemKind: Int32 Tag
+FSharp.Compiler.EditorServices.NavigableItemKind: Int32 get_Tag()
+FSharp.Compiler.EditorServices.NavigableItemKind: System.String ToString()
+FSharp.Compiler.EditorServices.NavigateTo: FSharp.Compiler.EditorServices.NavigableItem[] GetNavigableItems(FSharp.Compiler.Syntax.ParsedInput)
+FSharp.Compiler.EditorServices.Navigation: FSharp.Compiler.EditorServices.NavigationItems getNavigation(FSharp.Compiler.Syntax.ParsedInput)
+FSharp.Compiler.EditorServices.NavigationEntityKind+Tags: Int32 Class
+FSharp.Compiler.EditorServices.NavigationEntityKind+Tags: Int32 Enum
+FSharp.Compiler.EditorServices.NavigationEntityKind+Tags: Int32 Exception
+FSharp.Compiler.EditorServices.NavigationEntityKind+Tags: Int32 Interface
+FSharp.Compiler.EditorServices.NavigationEntityKind+Tags: Int32 Module
+FSharp.Compiler.EditorServices.NavigationEntityKind+Tags: Int32 Namespace
+FSharp.Compiler.EditorServices.NavigationEntityKind+Tags: Int32 Record
+FSharp.Compiler.EditorServices.NavigationEntityKind+Tags: Int32 Union
+FSharp.Compiler.EditorServices.NavigationEntityKind: Boolean Equals(FSharp.Compiler.EditorServices.NavigationEntityKind)
+FSharp.Compiler.EditorServices.NavigationEntityKind: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.NavigationEntityKind: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.NavigationEntityKind: Boolean IsClass
+FSharp.Compiler.EditorServices.NavigationEntityKind: Boolean IsEnum
+FSharp.Compiler.EditorServices.NavigationEntityKind: Boolean IsException
+FSharp.Compiler.EditorServices.NavigationEntityKind: Boolean IsInterface
+FSharp.Compiler.EditorServices.NavigationEntityKind: Boolean IsModule
+FSharp.Compiler.EditorServices.NavigationEntityKind: Boolean IsNamespace
+FSharp.Compiler.EditorServices.NavigationEntityKind: Boolean IsRecord
+FSharp.Compiler.EditorServices.NavigationEntityKind: Boolean IsUnion
+FSharp.Compiler.EditorServices.NavigationEntityKind: Boolean get_IsClass()
+FSharp.Compiler.EditorServices.NavigationEntityKind: Boolean get_IsEnum()
+FSharp.Compiler.EditorServices.NavigationEntityKind: Boolean get_IsException()
+FSharp.Compiler.EditorServices.NavigationEntityKind: Boolean get_IsInterface()
+FSharp.Compiler.EditorServices.NavigationEntityKind: Boolean get_IsModule()
+FSharp.Compiler.EditorServices.NavigationEntityKind: Boolean get_IsNamespace()
+FSharp.Compiler.EditorServices.NavigationEntityKind: Boolean get_IsRecord()
+FSharp.Compiler.EditorServices.NavigationEntityKind: Boolean get_IsUnion()
+FSharp.Compiler.EditorServices.NavigationEntityKind: FSharp.Compiler.EditorServices.NavigationEntityKind Class
+FSharp.Compiler.EditorServices.NavigationEntityKind: FSharp.Compiler.EditorServices.NavigationEntityKind Enum
+FSharp.Compiler.EditorServices.NavigationEntityKind: FSharp.Compiler.EditorServices.NavigationEntityKind Exception
+FSharp.Compiler.EditorServices.NavigationEntityKind: FSharp.Compiler.EditorServices.NavigationEntityKind Interface
+FSharp.Compiler.EditorServices.NavigationEntityKind: FSharp.Compiler.EditorServices.NavigationEntityKind Module
+FSharp.Compiler.EditorServices.NavigationEntityKind: FSharp.Compiler.EditorServices.NavigationEntityKind Namespace
+FSharp.Compiler.EditorServices.NavigationEntityKind: FSharp.Compiler.EditorServices.NavigationEntityKind Record
+FSharp.Compiler.EditorServices.NavigationEntityKind: FSharp.Compiler.EditorServices.NavigationEntityKind Union
+FSharp.Compiler.EditorServices.NavigationEntityKind: FSharp.Compiler.EditorServices.NavigationEntityKind get_Class()
+FSharp.Compiler.EditorServices.NavigationEntityKind: FSharp.Compiler.EditorServices.NavigationEntityKind get_Enum()
+FSharp.Compiler.EditorServices.NavigationEntityKind: FSharp.Compiler.EditorServices.NavigationEntityKind get_Exception()
+FSharp.Compiler.EditorServices.NavigationEntityKind: FSharp.Compiler.EditorServices.NavigationEntityKind get_Interface()
+FSharp.Compiler.EditorServices.NavigationEntityKind: FSharp.Compiler.EditorServices.NavigationEntityKind get_Module()
+FSharp.Compiler.EditorServices.NavigationEntityKind: FSharp.Compiler.EditorServices.NavigationEntityKind get_Namespace()
+FSharp.Compiler.EditorServices.NavigationEntityKind: FSharp.Compiler.EditorServices.NavigationEntityKind get_Record()
+FSharp.Compiler.EditorServices.NavigationEntityKind: FSharp.Compiler.EditorServices.NavigationEntityKind get_Union()
+FSharp.Compiler.EditorServices.NavigationEntityKind: FSharp.Compiler.EditorServices.NavigationEntityKind+Tags
+FSharp.Compiler.EditorServices.NavigationEntityKind: Int32 CompareTo(FSharp.Compiler.EditorServices.NavigationEntityKind)
+FSharp.Compiler.EditorServices.NavigationEntityKind: Int32 CompareTo(System.Object)
+FSharp.Compiler.EditorServices.NavigationEntityKind: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.EditorServices.NavigationEntityKind: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.NavigationEntityKind: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.NavigationEntityKind: Int32 Tag
+FSharp.Compiler.EditorServices.NavigationEntityKind: Int32 get_Tag()
+FSharp.Compiler.EditorServices.NavigationEntityKind: System.String ToString()
+FSharp.Compiler.EditorServices.NavigationItem: Boolean IsAbstract
+FSharp.Compiler.EditorServices.NavigationItem: Boolean IsSingleTopLevel
+FSharp.Compiler.EditorServices.NavigationItem: Boolean get_IsAbstract()
+FSharp.Compiler.EditorServices.NavigationItem: Boolean get_IsSingleTopLevel()
+FSharp.Compiler.EditorServices.NavigationItem: FSharp.Compiler.EditorServices.FSharpGlyph Glyph
+FSharp.Compiler.EditorServices.NavigationItem: FSharp.Compiler.EditorServices.FSharpGlyph get_Glyph()
+FSharp.Compiler.EditorServices.NavigationItem: FSharp.Compiler.EditorServices.NavigationEntityKind EnclosingEntityKind
+FSharp.Compiler.EditorServices.NavigationItem: FSharp.Compiler.EditorServices.NavigationEntityKind get_EnclosingEntityKind()
+FSharp.Compiler.EditorServices.NavigationItem: FSharp.Compiler.EditorServices.NavigationItemKind Kind
+FSharp.Compiler.EditorServices.NavigationItem: FSharp.Compiler.EditorServices.NavigationItemKind get_Kind()
+FSharp.Compiler.EditorServices.NavigationItem: FSharp.Compiler.Text.Range BodyRange
+FSharp.Compiler.EditorServices.NavigationItem: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.EditorServices.NavigationItem: FSharp.Compiler.Text.Range get_BodyRange()
+FSharp.Compiler.EditorServices.NavigationItem: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.EditorServices.NavigationItem: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] Access
+FSharp.Compiler.EditorServices.NavigationItem: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] get_Access()
+FSharp.Compiler.EditorServices.NavigationItem: System.String LogicalName
+FSharp.Compiler.EditorServices.NavigationItem: System.String UniqueName
+FSharp.Compiler.EditorServices.NavigationItem: System.String get_LogicalName()
+FSharp.Compiler.EditorServices.NavigationItem: System.String get_UniqueName()
+FSharp.Compiler.EditorServices.NavigationItemKind+Tags: Int32 Exception
+FSharp.Compiler.EditorServices.NavigationItemKind+Tags: Int32 Field
+FSharp.Compiler.EditorServices.NavigationItemKind+Tags: Int32 Method
+FSharp.Compiler.EditorServices.NavigationItemKind+Tags: Int32 Module
+FSharp.Compiler.EditorServices.NavigationItemKind+Tags: Int32 ModuleFile
+FSharp.Compiler.EditorServices.NavigationItemKind+Tags: Int32 Namespace
+FSharp.Compiler.EditorServices.NavigationItemKind+Tags: Int32 Other
+FSharp.Compiler.EditorServices.NavigationItemKind+Tags: Int32 Property
+FSharp.Compiler.EditorServices.NavigationItemKind+Tags: Int32 Type
+FSharp.Compiler.EditorServices.NavigationItemKind: Boolean Equals(FSharp.Compiler.EditorServices.NavigationItemKind)
+FSharp.Compiler.EditorServices.NavigationItemKind: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.NavigationItemKind: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.NavigationItemKind: Boolean IsException
+FSharp.Compiler.EditorServices.NavigationItemKind: Boolean IsField
+FSharp.Compiler.EditorServices.NavigationItemKind: Boolean IsMethod
+FSharp.Compiler.EditorServices.NavigationItemKind: Boolean IsModule
+FSharp.Compiler.EditorServices.NavigationItemKind: Boolean IsModuleFile
+FSharp.Compiler.EditorServices.NavigationItemKind: Boolean IsNamespace
+FSharp.Compiler.EditorServices.NavigationItemKind: Boolean IsOther
+FSharp.Compiler.EditorServices.NavigationItemKind: Boolean IsProperty
+FSharp.Compiler.EditorServices.NavigationItemKind: Boolean IsType
+FSharp.Compiler.EditorServices.NavigationItemKind: Boolean get_IsException()
+FSharp.Compiler.EditorServices.NavigationItemKind: Boolean get_IsField()
+FSharp.Compiler.EditorServices.NavigationItemKind: Boolean get_IsMethod()
+FSharp.Compiler.EditorServices.NavigationItemKind: Boolean get_IsModule()
+FSharp.Compiler.EditorServices.NavigationItemKind: Boolean get_IsModuleFile()
+FSharp.Compiler.EditorServices.NavigationItemKind: Boolean get_IsNamespace()
+FSharp.Compiler.EditorServices.NavigationItemKind: Boolean get_IsOther()
+FSharp.Compiler.EditorServices.NavigationItemKind: Boolean get_IsProperty()
+FSharp.Compiler.EditorServices.NavigationItemKind: Boolean get_IsType()
+FSharp.Compiler.EditorServices.NavigationItemKind: FSharp.Compiler.EditorServices.NavigationItemKind Exception
+FSharp.Compiler.EditorServices.NavigationItemKind: FSharp.Compiler.EditorServices.NavigationItemKind Field
+FSharp.Compiler.EditorServices.NavigationItemKind: FSharp.Compiler.EditorServices.NavigationItemKind Method
+FSharp.Compiler.EditorServices.NavigationItemKind: FSharp.Compiler.EditorServices.NavigationItemKind Module
+FSharp.Compiler.EditorServices.NavigationItemKind: FSharp.Compiler.EditorServices.NavigationItemKind ModuleFile
+FSharp.Compiler.EditorServices.NavigationItemKind: FSharp.Compiler.EditorServices.NavigationItemKind Namespace
+FSharp.Compiler.EditorServices.NavigationItemKind: FSharp.Compiler.EditorServices.NavigationItemKind Other
+FSharp.Compiler.EditorServices.NavigationItemKind: FSharp.Compiler.EditorServices.NavigationItemKind Property
+FSharp.Compiler.EditorServices.NavigationItemKind: FSharp.Compiler.EditorServices.NavigationItemKind Type
+FSharp.Compiler.EditorServices.NavigationItemKind: FSharp.Compiler.EditorServices.NavigationItemKind get_Exception()
+FSharp.Compiler.EditorServices.NavigationItemKind: FSharp.Compiler.EditorServices.NavigationItemKind get_Field()
+FSharp.Compiler.EditorServices.NavigationItemKind: FSharp.Compiler.EditorServices.NavigationItemKind get_Method()
+FSharp.Compiler.EditorServices.NavigationItemKind: FSharp.Compiler.EditorServices.NavigationItemKind get_Module()
+FSharp.Compiler.EditorServices.NavigationItemKind: FSharp.Compiler.EditorServices.NavigationItemKind get_ModuleFile()
+FSharp.Compiler.EditorServices.NavigationItemKind: FSharp.Compiler.EditorServices.NavigationItemKind get_Namespace()
+FSharp.Compiler.EditorServices.NavigationItemKind: FSharp.Compiler.EditorServices.NavigationItemKind get_Other()
+FSharp.Compiler.EditorServices.NavigationItemKind: FSharp.Compiler.EditorServices.NavigationItemKind get_Property()
+FSharp.Compiler.EditorServices.NavigationItemKind: FSharp.Compiler.EditorServices.NavigationItemKind get_Type()
+FSharp.Compiler.EditorServices.NavigationItemKind: FSharp.Compiler.EditorServices.NavigationItemKind+Tags
+FSharp.Compiler.EditorServices.NavigationItemKind: Int32 CompareTo(FSharp.Compiler.EditorServices.NavigationItemKind)
+FSharp.Compiler.EditorServices.NavigationItemKind: Int32 CompareTo(System.Object)
+FSharp.Compiler.EditorServices.NavigationItemKind: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.EditorServices.NavigationItemKind: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.NavigationItemKind: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.NavigationItemKind: Int32 Tag
+FSharp.Compiler.EditorServices.NavigationItemKind: Int32 get_Tag()
+FSharp.Compiler.EditorServices.NavigationItemKind: System.String ToString()
+FSharp.Compiler.EditorServices.NavigationItems: FSharp.Compiler.EditorServices.NavigationTopLevelDeclaration[] Declarations
+FSharp.Compiler.EditorServices.NavigationItems: FSharp.Compiler.EditorServices.NavigationTopLevelDeclaration[] get_Declarations()
+FSharp.Compiler.EditorServices.NavigationTopLevelDeclaration: FSharp.Compiler.EditorServices.NavigationItem Declaration
+FSharp.Compiler.EditorServices.NavigationTopLevelDeclaration: FSharp.Compiler.EditorServices.NavigationItem get_Declaration()
+FSharp.Compiler.EditorServices.NavigationTopLevelDeclaration: FSharp.Compiler.EditorServices.NavigationItem[] Nested
+FSharp.Compiler.EditorServices.NavigationTopLevelDeclaration: FSharp.Compiler.EditorServices.NavigationItem[] get_Nested()
+FSharp.Compiler.EditorServices.NavigationTopLevelDeclaration: System.String ToString()
+FSharp.Compiler.EditorServices.NavigationTopLevelDeclaration: Void .ctor(FSharp.Compiler.EditorServices.NavigationItem, FSharp.Compiler.EditorServices.NavigationItem[])
+FSharp.Compiler.EditorServices.OpenStatementInsertionPoint+Tags: Int32 Nearest
+FSharp.Compiler.EditorServices.OpenStatementInsertionPoint+Tags: Int32 TopLevel
+FSharp.Compiler.EditorServices.OpenStatementInsertionPoint: Boolean Equals(FSharp.Compiler.EditorServices.OpenStatementInsertionPoint)
+FSharp.Compiler.EditorServices.OpenStatementInsertionPoint: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.OpenStatementInsertionPoint: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.OpenStatementInsertionPoint: Boolean IsNearest
+FSharp.Compiler.EditorServices.OpenStatementInsertionPoint: Boolean IsTopLevel
+FSharp.Compiler.EditorServices.OpenStatementInsertionPoint: Boolean get_IsNearest()
+FSharp.Compiler.EditorServices.OpenStatementInsertionPoint: Boolean get_IsTopLevel()
+FSharp.Compiler.EditorServices.OpenStatementInsertionPoint: FSharp.Compiler.EditorServices.OpenStatementInsertionPoint Nearest
+FSharp.Compiler.EditorServices.OpenStatementInsertionPoint: FSharp.Compiler.EditorServices.OpenStatementInsertionPoint TopLevel
+FSharp.Compiler.EditorServices.OpenStatementInsertionPoint: FSharp.Compiler.EditorServices.OpenStatementInsertionPoint get_Nearest()
+FSharp.Compiler.EditorServices.OpenStatementInsertionPoint: FSharp.Compiler.EditorServices.OpenStatementInsertionPoint get_TopLevel()
+FSharp.Compiler.EditorServices.OpenStatementInsertionPoint: FSharp.Compiler.EditorServices.OpenStatementInsertionPoint+Tags
+FSharp.Compiler.EditorServices.OpenStatementInsertionPoint: Int32 CompareTo(FSharp.Compiler.EditorServices.OpenStatementInsertionPoint)
+FSharp.Compiler.EditorServices.OpenStatementInsertionPoint: Int32 CompareTo(System.Object)
+FSharp.Compiler.EditorServices.OpenStatementInsertionPoint: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.EditorServices.OpenStatementInsertionPoint: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.OpenStatementInsertionPoint: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.OpenStatementInsertionPoint: Int32 Tag
+FSharp.Compiler.EditorServices.OpenStatementInsertionPoint: Int32 get_Tag()
+FSharp.Compiler.EditorServices.OpenStatementInsertionPoint: System.String ToString()
+FSharp.Compiler.EditorServices.ParameterLocations: Boolean IsThereACloseParen
+FSharp.Compiler.EditorServices.ParameterLocations: Boolean get_IsThereACloseParen()
+FSharp.Compiler.EditorServices.ParameterLocations: FSharp.Compiler.EditorServices.TupledArgumentLocation[] ArgumentLocations
+FSharp.Compiler.EditorServices.ParameterLocations: FSharp.Compiler.EditorServices.TupledArgumentLocation[] get_ArgumentLocations()
+FSharp.Compiler.EditorServices.ParameterLocations: FSharp.Compiler.Text.Position LongIdEndLocation
+FSharp.Compiler.EditorServices.ParameterLocations: FSharp.Compiler.Text.Position LongIdStartLocation
+FSharp.Compiler.EditorServices.ParameterLocations: FSharp.Compiler.Text.Position OpenParenLocation
+FSharp.Compiler.EditorServices.ParameterLocations: FSharp.Compiler.Text.Position get_LongIdEndLocation()
+FSharp.Compiler.EditorServices.ParameterLocations: FSharp.Compiler.Text.Position get_LongIdStartLocation()
+FSharp.Compiler.EditorServices.ParameterLocations: FSharp.Compiler.Text.Position get_OpenParenLocation()
+FSharp.Compiler.EditorServices.ParameterLocations: FSharp.Compiler.Text.Position[] TupleEndLocations
+FSharp.Compiler.EditorServices.ParameterLocations: FSharp.Compiler.Text.Position[] get_TupleEndLocations()
+FSharp.Compiler.EditorServices.ParameterLocations: Microsoft.FSharp.Collections.FSharpList`1[System.String] LongId
+FSharp.Compiler.EditorServices.ParameterLocations: Microsoft.FSharp.Collections.FSharpList`1[System.String] get_LongId()
+FSharp.Compiler.EditorServices.ParameterLocations: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.EditorServices.ParameterLocations] Find(FSharp.Compiler.Text.Position, FSharp.Compiler.Syntax.ParsedInput)
+FSharp.Compiler.EditorServices.ParameterLocations: Microsoft.FSharp.Core.FSharpOption`1[System.String][] NamedParamNames
+FSharp.Compiler.EditorServices.ParameterLocations: Microsoft.FSharp.Core.FSharpOption`1[System.String][] get_NamedParamNames()
+FSharp.Compiler.EditorServices.ParsedInput: FSharp.Compiler.EditorServices.InsertionContext FindNearestPointToInsertOpenDeclaration(Int32, FSharp.Compiler.Syntax.ParsedInput, System.String[], FSharp.Compiler.EditorServices.OpenStatementInsertionPoint)
+FSharp.Compiler.EditorServices.ParsedInput: FSharp.Compiler.Text.Position AdjustInsertionPoint(Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.String], FSharp.Compiler.EditorServices.InsertionContext)
+FSharp.Compiler.EditorServices.ParsedInput: Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`4[Microsoft.FSharp.Core.FSharpOption`1[System.String[]],Microsoft.FSharp.Core.FSharpOption`1[System.String[]],Microsoft.FSharp.Core.FSharpOption`1[System.String[]],System.String[]],System.Tuple`2[FSharp.Compiler.EditorServices.InsertionContextEntity,FSharp.Compiler.EditorServices.InsertionContext][]] TryFindInsertionContext(Int32, FSharp.Compiler.Syntax.ParsedInput, FSharp.Compiler.EditorServices.MaybeUnresolvedIdent[], FSharp.Compiler.EditorServices.OpenStatementInsertionPoint)
+FSharp.Compiler.EditorServices.ParsedInput: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.EditorServices.CompletionContext] TryGetCompletionContext(FSharp.Compiler.Text.Position, FSharp.Compiler.Syntax.ParsedInput, System.String)
+FSharp.Compiler.EditorServices.ParsedInput: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.EditorServices.EntityKind] GetEntityKind(FSharp.Compiler.Text.Position, FSharp.Compiler.Syntax.ParsedInput)
+FSharp.Compiler.EditorServices.ParsedInput: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] GetRangeOfExprLeftOfDot(FSharp.Compiler.Text.Position, FSharp.Compiler.Syntax.ParsedInput)
+FSharp.Compiler.EditorServices.ParsedInput: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident]] GetLongIdentAt(FSharp.Compiler.Syntax.ParsedInput, FSharp.Compiler.Text.Position)
+FSharp.Compiler.EditorServices.ParsedInput: Microsoft.FSharp.Core.FSharpOption`1[System.String] TryFindExpressionIslandInPosition(FSharp.Compiler.Text.Position, FSharp.Compiler.Syntax.ParsedInput)
+FSharp.Compiler.EditorServices.ParsedInput: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Text.Position,System.Boolean]] TryFindExpressionASTLeftOfDotLeftOfCursor(FSharp.Compiler.Text.Position, FSharp.Compiler.Syntax.ParsedInput)
+FSharp.Compiler.EditorServices.ParsedInput: System.String[] GetFullNameOfSmallestModuleOrNamespaceAtPoint(FSharp.Compiler.Text.Position, FSharp.Compiler.Syntax.ParsedInput)
+FSharp.Compiler.EditorServices.PartialLongName: Boolean Equals(FSharp.Compiler.EditorServices.PartialLongName)
+FSharp.Compiler.EditorServices.PartialLongName: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.PartialLongName: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.PartialLongName: FSharp.Compiler.EditorServices.PartialLongName Empty(Int32)
+FSharp.Compiler.EditorServices.PartialLongName: Int32 CompareTo(FSharp.Compiler.EditorServices.PartialLongName)
+FSharp.Compiler.EditorServices.PartialLongName: Int32 CompareTo(System.Object)
+FSharp.Compiler.EditorServices.PartialLongName: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.EditorServices.PartialLongName: Int32 EndColumn
+FSharp.Compiler.EditorServices.PartialLongName: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.PartialLongName: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.PartialLongName: Int32 get_EndColumn()
+FSharp.Compiler.EditorServices.PartialLongName: Microsoft.FSharp.Collections.FSharpList`1[System.String] QualifyingIdents
+FSharp.Compiler.EditorServices.PartialLongName: Microsoft.FSharp.Collections.FSharpList`1[System.String] get_QualifyingIdents()
+FSharp.Compiler.EditorServices.PartialLongName: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] LastDotPos
+FSharp.Compiler.EditorServices.PartialLongName: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] get_LastDotPos()
+FSharp.Compiler.EditorServices.PartialLongName: System.String PartialIdent
+FSharp.Compiler.EditorServices.PartialLongName: System.String ToString()
+FSharp.Compiler.EditorServices.PartialLongName: System.String get_PartialIdent()
+FSharp.Compiler.EditorServices.PartialLongName: Void .ctor(Microsoft.FSharp.Collections.FSharpList`1[System.String], System.String, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+FSharp.Compiler.EditorServices.QuickParse: Boolean TestMemberOrOverrideDeclaration(FSharp.Compiler.Tokenization.FSharpTokenInfo[])
+FSharp.Compiler.EditorServices.QuickParse: FSharp.Compiler.EditorServices.PartialLongName GetPartialLongNameEx(System.String, Int32)
+FSharp.Compiler.EditorServices.QuickParse: Int32 CorrectIdentifierToken(System.String, Int32)
+FSharp.Compiler.EditorServices.QuickParse: Int32 MagicalAdjustmentConstant
+FSharp.Compiler.EditorServices.QuickParse: Int32 get_MagicalAdjustmentConstant()
+FSharp.Compiler.EditorServices.QuickParse: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.String,System.Int32,System.Boolean]] GetCompleteIdentifierIsland(Boolean, System.String, Int32)
+FSharp.Compiler.EditorServices.QuickParse: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[System.String],System.String] GetPartialLongName(System.String, Int32)
+FSharp.Compiler.EditorServices.RecordContext+Constructor: System.String get_typeName()
+FSharp.Compiler.EditorServices.RecordContext+Constructor: System.String typeName
+FSharp.Compiler.EditorServices.RecordContext+CopyOnUpdate: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.EditorServices.RecordContext+CopyOnUpdate: FSharp.Compiler.Text.Range range
+FSharp.Compiler.EditorServices.RecordContext+CopyOnUpdate: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[System.String],Microsoft.FSharp.Core.FSharpOption`1[System.String]] get_path()
+FSharp.Compiler.EditorServices.RecordContext+CopyOnUpdate: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[System.String],Microsoft.FSharp.Core.FSharpOption`1[System.String]] path
+FSharp.Compiler.EditorServices.RecordContext+Declaration: Boolean get_isInIdentifier()
+FSharp.Compiler.EditorServices.RecordContext+Declaration: Boolean isInIdentifier
+FSharp.Compiler.EditorServices.RecordContext+New: Boolean get_isFirstField()
+FSharp.Compiler.EditorServices.RecordContext+New: Boolean isFirstField
+FSharp.Compiler.EditorServices.RecordContext+New: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[System.String],Microsoft.FSharp.Core.FSharpOption`1[System.String]] get_path()
+FSharp.Compiler.EditorServices.RecordContext+New: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[System.String],Microsoft.FSharp.Core.FSharpOption`1[System.String]] path
+FSharp.Compiler.EditorServices.RecordContext+Tags: Int32 Constructor
+FSharp.Compiler.EditorServices.RecordContext+Tags: Int32 CopyOnUpdate
+FSharp.Compiler.EditorServices.RecordContext+Tags: Int32 Declaration
+FSharp.Compiler.EditorServices.RecordContext+Tags: Int32 Empty
+FSharp.Compiler.EditorServices.RecordContext+Tags: Int32 New
+FSharp.Compiler.EditorServices.RecordContext: Boolean Equals(FSharp.Compiler.EditorServices.RecordContext)
+FSharp.Compiler.EditorServices.RecordContext: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.RecordContext: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.RecordContext: Boolean IsConstructor
+FSharp.Compiler.EditorServices.RecordContext: Boolean IsCopyOnUpdate
+FSharp.Compiler.EditorServices.RecordContext: Boolean IsDeclaration
+FSharp.Compiler.EditorServices.RecordContext: Boolean IsEmpty
+FSharp.Compiler.EditorServices.RecordContext: Boolean IsNew
+FSharp.Compiler.EditorServices.RecordContext: Boolean get_IsConstructor()
+FSharp.Compiler.EditorServices.RecordContext: Boolean get_IsCopyOnUpdate()
+FSharp.Compiler.EditorServices.RecordContext: Boolean get_IsDeclaration()
+FSharp.Compiler.EditorServices.RecordContext: Boolean get_IsEmpty()
+FSharp.Compiler.EditorServices.RecordContext: Boolean get_IsNew()
+FSharp.Compiler.EditorServices.RecordContext: FSharp.Compiler.EditorServices.RecordContext Empty
+FSharp.Compiler.EditorServices.RecordContext: FSharp.Compiler.EditorServices.RecordContext NewConstructor(System.String)
+FSharp.Compiler.EditorServices.RecordContext: FSharp.Compiler.EditorServices.RecordContext NewCopyOnUpdate(FSharp.Compiler.Text.Range, System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[System.String],Microsoft.FSharp.Core.FSharpOption`1[System.String]])
+FSharp.Compiler.EditorServices.RecordContext: FSharp.Compiler.EditorServices.RecordContext NewDeclaration(Boolean)
+FSharp.Compiler.EditorServices.RecordContext: FSharp.Compiler.EditorServices.RecordContext NewNew(System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[System.String],Microsoft.FSharp.Core.FSharpOption`1[System.String]], Boolean)
+FSharp.Compiler.EditorServices.RecordContext: FSharp.Compiler.EditorServices.RecordContext get_Empty()
+FSharp.Compiler.EditorServices.RecordContext: FSharp.Compiler.EditorServices.RecordContext+Constructor
+FSharp.Compiler.EditorServices.RecordContext: FSharp.Compiler.EditorServices.RecordContext+CopyOnUpdate
+FSharp.Compiler.EditorServices.RecordContext: FSharp.Compiler.EditorServices.RecordContext+Declaration
+FSharp.Compiler.EditorServices.RecordContext: FSharp.Compiler.EditorServices.RecordContext+New
+FSharp.Compiler.EditorServices.RecordContext: FSharp.Compiler.EditorServices.RecordContext+Tags
+FSharp.Compiler.EditorServices.RecordContext: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.RecordContext: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.RecordContext: Int32 Tag
+FSharp.Compiler.EditorServices.RecordContext: Int32 get_Tag()
+FSharp.Compiler.EditorServices.RecordContext: System.String ToString()
+FSharp.Compiler.EditorServices.ScopeKind+Tags: Int32 HashDirective
+FSharp.Compiler.EditorServices.ScopeKind+Tags: Int32 Namespace
+FSharp.Compiler.EditorServices.ScopeKind+Tags: Int32 NestedModule
+FSharp.Compiler.EditorServices.ScopeKind+Tags: Int32 OpenDeclaration
+FSharp.Compiler.EditorServices.ScopeKind+Tags: Int32 TopModule
+FSharp.Compiler.EditorServices.ScopeKind: Boolean Equals(FSharp.Compiler.EditorServices.ScopeKind)
+FSharp.Compiler.EditorServices.ScopeKind: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.ScopeKind: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.ScopeKind: Boolean IsHashDirective
+FSharp.Compiler.EditorServices.ScopeKind: Boolean IsNamespace
+FSharp.Compiler.EditorServices.ScopeKind: Boolean IsNestedModule
+FSharp.Compiler.EditorServices.ScopeKind: Boolean IsOpenDeclaration
+FSharp.Compiler.EditorServices.ScopeKind: Boolean IsTopModule
+FSharp.Compiler.EditorServices.ScopeKind: Boolean get_IsHashDirective()
+FSharp.Compiler.EditorServices.ScopeKind: Boolean get_IsNamespace()
+FSharp.Compiler.EditorServices.ScopeKind: Boolean get_IsNestedModule()
+FSharp.Compiler.EditorServices.ScopeKind: Boolean get_IsOpenDeclaration()
+FSharp.Compiler.EditorServices.ScopeKind: Boolean get_IsTopModule()
+FSharp.Compiler.EditorServices.ScopeKind: FSharp.Compiler.EditorServices.ScopeKind HashDirective
+FSharp.Compiler.EditorServices.ScopeKind: FSharp.Compiler.EditorServices.ScopeKind Namespace
+FSharp.Compiler.EditorServices.ScopeKind: FSharp.Compiler.EditorServices.ScopeKind NestedModule
+FSharp.Compiler.EditorServices.ScopeKind: FSharp.Compiler.EditorServices.ScopeKind OpenDeclaration
+FSharp.Compiler.EditorServices.ScopeKind: FSharp.Compiler.EditorServices.ScopeKind TopModule
+FSharp.Compiler.EditorServices.ScopeKind: FSharp.Compiler.EditorServices.ScopeKind get_HashDirective()
+FSharp.Compiler.EditorServices.ScopeKind: FSharp.Compiler.EditorServices.ScopeKind get_Namespace()
+FSharp.Compiler.EditorServices.ScopeKind: FSharp.Compiler.EditorServices.ScopeKind get_NestedModule()
+FSharp.Compiler.EditorServices.ScopeKind: FSharp.Compiler.EditorServices.ScopeKind get_OpenDeclaration()
+FSharp.Compiler.EditorServices.ScopeKind: FSharp.Compiler.EditorServices.ScopeKind get_TopModule()
+FSharp.Compiler.EditorServices.ScopeKind: FSharp.Compiler.EditorServices.ScopeKind+Tags
+FSharp.Compiler.EditorServices.ScopeKind: Int32 CompareTo(FSharp.Compiler.EditorServices.ScopeKind)
+FSharp.Compiler.EditorServices.ScopeKind: Int32 CompareTo(System.Object)
+FSharp.Compiler.EditorServices.ScopeKind: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.EditorServices.ScopeKind: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.ScopeKind: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.ScopeKind: Int32 Tag
+FSharp.Compiler.EditorServices.ScopeKind: Int32 get_Tag()
+FSharp.Compiler.EditorServices.ScopeKind: System.String ToString()
+FSharp.Compiler.EditorServices.SemanticClassificationItem: Boolean Equals(FSharp.Compiler.EditorServices.SemanticClassificationItem)
+FSharp.Compiler.EditorServices.SemanticClassificationItem: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.SemanticClassificationItem: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.SemanticClassificationItem: FSharp.Compiler.EditorServices.SemanticClassificationType Type
+FSharp.Compiler.EditorServices.SemanticClassificationItem: FSharp.Compiler.EditorServices.SemanticClassificationType get_Type()
+FSharp.Compiler.EditorServices.SemanticClassificationItem: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.EditorServices.SemanticClassificationItem: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.EditorServices.SemanticClassificationItem: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.SemanticClassificationItem: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.SemanticClassificationItem: Void .ctor(System.Tuple`2[FSharp.Compiler.Text.Range,FSharp.Compiler.EditorServices.SemanticClassificationType])
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType ComputationExpression
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType ConstructorForReferenceType
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType ConstructorForValueType
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType Delegate
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType DisposableLocalValue
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType DisposableTopLevelValue
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType DisposableType
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType Enumeration
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType Event
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType Exception
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType ExtensionMethod
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType Field
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType Function
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType Interface
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType IntrinsicFunction
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType Literal
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType LocalValue
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType Method
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType Module
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType MutableRecordField
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType MutableVar
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType NamedArgument
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType Namespace
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType Operator
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType Plaintext
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType Printf
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType Property
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType RecordField
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType RecordFieldAsFunction
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType ReferenceType
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType Type
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType TypeArgument
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType TypeDef
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType UnionCase
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType UnionCaseField
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType Value
+FSharp.Compiler.EditorServices.SemanticClassificationType: FSharp.Compiler.EditorServices.SemanticClassificationType ValueType
+FSharp.Compiler.EditorServices.SemanticClassificationType: Int32 value__
+FSharp.Compiler.EditorServices.SemanticClassificationView: Void ForEach(Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.EditorServices.SemanticClassificationItem,Microsoft.FSharp.Core.Unit])
+FSharp.Compiler.EditorServices.SimplifyNames+SimplifiableRange: Boolean Equals(SimplifiableRange)
+FSharp.Compiler.EditorServices.SimplifyNames+SimplifiableRange: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.SimplifyNames+SimplifiableRange: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.SimplifyNames+SimplifiableRange: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.EditorServices.SimplifyNames+SimplifiableRange: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.EditorServices.SimplifyNames+SimplifiableRange: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.SimplifyNames+SimplifiableRange: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.SimplifyNames+SimplifiableRange: System.String RelativeName
+FSharp.Compiler.EditorServices.SimplifyNames+SimplifiableRange: System.String ToString()
+FSharp.Compiler.EditorServices.SimplifyNames+SimplifiableRange: System.String get_RelativeName()
+FSharp.Compiler.EditorServices.SimplifyNames+SimplifiableRange: Void .ctor(FSharp.Compiler.Text.Range, System.String)
+FSharp.Compiler.EditorServices.SimplifyNames: FSharp.Compiler.EditorServices.SimplifyNames+SimplifiableRange
+FSharp.Compiler.EditorServices.SimplifyNames: Microsoft.FSharp.Control.FSharpAsync`1[System.Collections.Generic.IEnumerable`1[FSharp.Compiler.EditorServices.SimplifyNames+SimplifiableRange]] getSimplifiableNames(FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.String])
+FSharp.Compiler.EditorServices.Structure+Collapse+Tags: Int32 Below
+FSharp.Compiler.EditorServices.Structure+Collapse+Tags: Int32 Same
+FSharp.Compiler.EditorServices.Structure+Collapse: Boolean Equals(Collapse)
+FSharp.Compiler.EditorServices.Structure+Collapse: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.Structure+Collapse: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.Structure+Collapse: Boolean IsBelow
+FSharp.Compiler.EditorServices.Structure+Collapse: Boolean IsSame
+FSharp.Compiler.EditorServices.Structure+Collapse: Boolean get_IsBelow()
+FSharp.Compiler.EditorServices.Structure+Collapse: Boolean get_IsSame()
+FSharp.Compiler.EditorServices.Structure+Collapse: Collapse Below
+FSharp.Compiler.EditorServices.Structure+Collapse: Collapse Same
+FSharp.Compiler.EditorServices.Structure+Collapse: Collapse get_Below()
+FSharp.Compiler.EditorServices.Structure+Collapse: Collapse get_Same()
+FSharp.Compiler.EditorServices.Structure+Collapse: FSharp.Compiler.EditorServices.Structure+Collapse+Tags
+FSharp.Compiler.EditorServices.Structure+Collapse: Int32 CompareTo(Collapse)
+FSharp.Compiler.EditorServices.Structure+Collapse: Int32 CompareTo(System.Object)
+FSharp.Compiler.EditorServices.Structure+Collapse: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.EditorServices.Structure+Collapse: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.Structure+Collapse: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.Structure+Collapse: Int32 Tag
+FSharp.Compiler.EditorServices.Structure+Collapse: Int32 get_Tag()
+FSharp.Compiler.EditorServices.Structure+Collapse: System.String ToString()
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 ArrayOrList
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 Attribute
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 Comment
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 ComputationExpr
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 Do
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 ElseInIfThenElse
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 EnumCase
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 FinallyInTryFinally
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 For
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 HashDirective
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 IfThenElse
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 Interface
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 Lambda
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 LetOrUse
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 LetOrUseBang
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 Match
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 MatchBang
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 MatchClause
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 MatchLambda
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 Member
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 Module
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 Namespace
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 New
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 ObjExpr
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 Open
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 Quote
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 Record
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 RecordDefn
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 RecordField
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 SpecialFunc
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 ThenInIfThenElse
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 TryFinally
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 TryInTryFinally
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 TryInTryWith
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 TryWith
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 Tuple
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 Type
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 TypeExtension
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 UnionCase
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 UnionDefn
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 Val
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 While
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 WithInTryWith
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 XmlDocComment
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 YieldOrReturn
+FSharp.Compiler.EditorServices.Structure+Scope+Tags: Int32 YieldOrReturnBang
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean Equals(Scope)
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsArrayOrList
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsAttribute
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsComment
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsComputationExpr
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsDo
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsElseInIfThenElse
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsEnumCase
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsFinallyInTryFinally
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsFor
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsHashDirective
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsIfThenElse
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsInterface
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsLambda
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsLetOrUse
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsLetOrUseBang
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsMatch
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsMatchBang
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsMatchClause
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsMatchLambda
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsMember
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsModule
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsNamespace
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsNew
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsObjExpr
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsOpen
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsQuote
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsRecord
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsRecordDefn
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsRecordField
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsSpecialFunc
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsThenInIfThenElse
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsTryFinally
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsTryInTryFinally
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsTryInTryWith
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsTryWith
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsTuple
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsType
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsTypeExtension
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsUnionCase
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsUnionDefn
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsVal
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsWhile
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsWithInTryWith
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsXmlDocComment
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsYieldOrReturn
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean IsYieldOrReturnBang
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsArrayOrList()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsAttribute()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsComment()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsComputationExpr()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsDo()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsElseInIfThenElse()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsEnumCase()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsFinallyInTryFinally()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsFor()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsHashDirective()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsIfThenElse()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsInterface()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsLambda()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsLetOrUse()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsLetOrUseBang()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsMatch()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsMatchBang()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsMatchClause()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsMatchLambda()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsMember()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsModule()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsNamespace()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsNew()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsObjExpr()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsOpen()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsQuote()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsRecord()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsRecordDefn()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsRecordField()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsSpecialFunc()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsThenInIfThenElse()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsTryFinally()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsTryInTryFinally()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsTryInTryWith()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsTryWith()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsTuple()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsType()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsTypeExtension()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsUnionCase()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsUnionDefn()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsVal()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsWhile()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsWithInTryWith()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsXmlDocComment()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsYieldOrReturn()
+FSharp.Compiler.EditorServices.Structure+Scope: Boolean get_IsYieldOrReturnBang()
+FSharp.Compiler.EditorServices.Structure+Scope: FSharp.Compiler.EditorServices.Structure+Scope+Tags
+FSharp.Compiler.EditorServices.Structure+Scope: Int32 CompareTo(Scope)
+FSharp.Compiler.EditorServices.Structure+Scope: Int32 CompareTo(System.Object)
+FSharp.Compiler.EditorServices.Structure+Scope: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.EditorServices.Structure+Scope: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.Structure+Scope: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.Structure+Scope: Int32 Tag
+FSharp.Compiler.EditorServices.Structure+Scope: Int32 get_Tag()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope ArrayOrList
+FSharp.Compiler.EditorServices.Structure+Scope: Scope Attribute
+FSharp.Compiler.EditorServices.Structure+Scope: Scope Comment
+FSharp.Compiler.EditorServices.Structure+Scope: Scope ComputationExpr
+FSharp.Compiler.EditorServices.Structure+Scope: Scope Do
+FSharp.Compiler.EditorServices.Structure+Scope: Scope ElseInIfThenElse
+FSharp.Compiler.EditorServices.Structure+Scope: Scope EnumCase
+FSharp.Compiler.EditorServices.Structure+Scope: Scope FinallyInTryFinally
+FSharp.Compiler.EditorServices.Structure+Scope: Scope For
+FSharp.Compiler.EditorServices.Structure+Scope: Scope HashDirective
+FSharp.Compiler.EditorServices.Structure+Scope: Scope IfThenElse
+FSharp.Compiler.EditorServices.Structure+Scope: Scope Interface
+FSharp.Compiler.EditorServices.Structure+Scope: Scope Lambda
+FSharp.Compiler.EditorServices.Structure+Scope: Scope LetOrUse
+FSharp.Compiler.EditorServices.Structure+Scope: Scope LetOrUseBang
+FSharp.Compiler.EditorServices.Structure+Scope: Scope Match
+FSharp.Compiler.EditorServices.Structure+Scope: Scope MatchBang
+FSharp.Compiler.EditorServices.Structure+Scope: Scope MatchClause
+FSharp.Compiler.EditorServices.Structure+Scope: Scope MatchLambda
+FSharp.Compiler.EditorServices.Structure+Scope: Scope Member
+FSharp.Compiler.EditorServices.Structure+Scope: Scope Module
+FSharp.Compiler.EditorServices.Structure+Scope: Scope Namespace
+FSharp.Compiler.EditorServices.Structure+Scope: Scope New
+FSharp.Compiler.EditorServices.Structure+Scope: Scope ObjExpr
+FSharp.Compiler.EditorServices.Structure+Scope: Scope Open
+FSharp.Compiler.EditorServices.Structure+Scope: Scope Quote
+FSharp.Compiler.EditorServices.Structure+Scope: Scope Record
+FSharp.Compiler.EditorServices.Structure+Scope: Scope RecordDefn
+FSharp.Compiler.EditorServices.Structure+Scope: Scope RecordField
+FSharp.Compiler.EditorServices.Structure+Scope: Scope SpecialFunc
+FSharp.Compiler.EditorServices.Structure+Scope: Scope ThenInIfThenElse
+FSharp.Compiler.EditorServices.Structure+Scope: Scope TryFinally
+FSharp.Compiler.EditorServices.Structure+Scope: Scope TryInTryFinally
+FSharp.Compiler.EditorServices.Structure+Scope: Scope TryInTryWith
+FSharp.Compiler.EditorServices.Structure+Scope: Scope TryWith
+FSharp.Compiler.EditorServices.Structure+Scope: Scope Tuple
+FSharp.Compiler.EditorServices.Structure+Scope: Scope Type
+FSharp.Compiler.EditorServices.Structure+Scope: Scope TypeExtension
+FSharp.Compiler.EditorServices.Structure+Scope: Scope UnionCase
+FSharp.Compiler.EditorServices.Structure+Scope: Scope UnionDefn
+FSharp.Compiler.EditorServices.Structure+Scope: Scope Val
+FSharp.Compiler.EditorServices.Structure+Scope: Scope While
+FSharp.Compiler.EditorServices.Structure+Scope: Scope WithInTryWith
+FSharp.Compiler.EditorServices.Structure+Scope: Scope XmlDocComment
+FSharp.Compiler.EditorServices.Structure+Scope: Scope YieldOrReturn
+FSharp.Compiler.EditorServices.Structure+Scope: Scope YieldOrReturnBang
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_ArrayOrList()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_Attribute()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_Comment()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_ComputationExpr()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_Do()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_ElseInIfThenElse()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_EnumCase()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_FinallyInTryFinally()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_For()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_HashDirective()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_IfThenElse()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_Interface()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_Lambda()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_LetOrUse()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_LetOrUseBang()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_Match()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_MatchBang()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_MatchClause()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_MatchLambda()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_Member()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_Module()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_Namespace()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_New()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_ObjExpr()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_Open()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_Quote()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_Record()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_RecordDefn()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_RecordField()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_SpecialFunc()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_ThenInIfThenElse()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_TryFinally()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_TryInTryFinally()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_TryInTryWith()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_TryWith()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_Tuple()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_Type()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_TypeExtension()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_UnionCase()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_UnionDefn()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_Val()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_While()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_WithInTryWith()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_XmlDocComment()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_YieldOrReturn()
+FSharp.Compiler.EditorServices.Structure+Scope: Scope get_YieldOrReturnBang()
+FSharp.Compiler.EditorServices.Structure+Scope: System.String ToString()
+FSharp.Compiler.EditorServices.Structure+ScopeRange: Boolean Equals(ScopeRange)
+FSharp.Compiler.EditorServices.Structure+ScopeRange: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.Structure+ScopeRange: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.Structure+ScopeRange: Collapse Collapse
+FSharp.Compiler.EditorServices.Structure+ScopeRange: Collapse get_Collapse()
+FSharp.Compiler.EditorServices.Structure+ScopeRange: FSharp.Compiler.Text.Range CollapseRange
+FSharp.Compiler.EditorServices.Structure+ScopeRange: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.EditorServices.Structure+ScopeRange: FSharp.Compiler.Text.Range get_CollapseRange()
+FSharp.Compiler.EditorServices.Structure+ScopeRange: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.EditorServices.Structure+ScopeRange: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.Structure+ScopeRange: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.Structure+ScopeRange: Scope Scope
+FSharp.Compiler.EditorServices.Structure+ScopeRange: Scope get_Scope()
+FSharp.Compiler.EditorServices.Structure+ScopeRange: System.String ToString()
+FSharp.Compiler.EditorServices.Structure+ScopeRange: Void .ctor(Scope, Collapse, FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.EditorServices.Structure: FSharp.Compiler.EditorServices.Structure+Collapse
+FSharp.Compiler.EditorServices.Structure: FSharp.Compiler.EditorServices.Structure+Scope
+FSharp.Compiler.EditorServices.Structure: FSharp.Compiler.EditorServices.Structure+ScopeRange
+FSharp.Compiler.EditorServices.Structure: System.Collections.Generic.IEnumerable`1[FSharp.Compiler.EditorServices.Structure+ScopeRange] getOutliningRanges(System.String[], FSharp.Compiler.Syntax.ParsedInput)
+FSharp.Compiler.EditorServices.ToolTipElement+CompositionError: System.String errorText
+FSharp.Compiler.EditorServices.ToolTipElement+CompositionError: System.String get_errorText()
+FSharp.Compiler.EditorServices.ToolTipElement+Group: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.ToolTipElementData] elements
+FSharp.Compiler.EditorServices.ToolTipElement+Group: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.ToolTipElementData] get_elements()
+FSharp.Compiler.EditorServices.ToolTipElement+Tags: Int32 CompositionError
+FSharp.Compiler.EditorServices.ToolTipElement+Tags: Int32 Group
+FSharp.Compiler.EditorServices.ToolTipElement+Tags: Int32 None
+FSharp.Compiler.EditorServices.ToolTipElement: Boolean Equals(FSharp.Compiler.EditorServices.ToolTipElement)
+FSharp.Compiler.EditorServices.ToolTipElement: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.ToolTipElement: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.ToolTipElement: Boolean IsCompositionError
+FSharp.Compiler.EditorServices.ToolTipElement: Boolean IsGroup
+FSharp.Compiler.EditorServices.ToolTipElement: Boolean IsNone
+FSharp.Compiler.EditorServices.ToolTipElement: Boolean get_IsCompositionError()
+FSharp.Compiler.EditorServices.ToolTipElement: Boolean get_IsGroup()
+FSharp.Compiler.EditorServices.ToolTipElement: Boolean get_IsNone()
+FSharp.Compiler.EditorServices.ToolTipElement: FSharp.Compiler.EditorServices.ToolTipElement NewCompositionError(System.String)
+FSharp.Compiler.EditorServices.ToolTipElement: FSharp.Compiler.EditorServices.ToolTipElement NewGroup(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.ToolTipElementData])
+FSharp.Compiler.EditorServices.ToolTipElement: FSharp.Compiler.EditorServices.ToolTipElement None
+FSharp.Compiler.EditorServices.ToolTipElement: FSharp.Compiler.EditorServices.ToolTipElement Single(FSharp.Compiler.Text.TaggedText[], FSharp.Compiler.Symbols.FSharpXmlDoc, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.TaggedText[]]], Microsoft.FSharp.Core.FSharpOption`1[System.String], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.TaggedText[]])
+FSharp.Compiler.EditorServices.ToolTipElement: FSharp.Compiler.EditorServices.ToolTipElement get_None()
+FSharp.Compiler.EditorServices.ToolTipElement: FSharp.Compiler.EditorServices.ToolTipElement+CompositionError
+FSharp.Compiler.EditorServices.ToolTipElement: FSharp.Compiler.EditorServices.ToolTipElement+Group
+FSharp.Compiler.EditorServices.ToolTipElement: FSharp.Compiler.EditorServices.ToolTipElement+Tags
+FSharp.Compiler.EditorServices.ToolTipElement: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.ToolTipElement: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.ToolTipElement: Int32 Tag
+FSharp.Compiler.EditorServices.ToolTipElement: Int32 get_Tag()
+FSharp.Compiler.EditorServices.ToolTipElement: System.String ToString()
+FSharp.Compiler.EditorServices.ToolTipElementData: Boolean Equals(FSharp.Compiler.EditorServices.ToolTipElementData)
+FSharp.Compiler.EditorServices.ToolTipElementData: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.ToolTipElementData: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.ToolTipElementData: FSharp.Compiler.Symbols.FSharpXmlDoc XmlDoc
+FSharp.Compiler.EditorServices.ToolTipElementData: FSharp.Compiler.Symbols.FSharpXmlDoc get_XmlDoc()
+FSharp.Compiler.EditorServices.ToolTipElementData: FSharp.Compiler.Text.TaggedText[] MainDescription
+FSharp.Compiler.EditorServices.ToolTipElementData: FSharp.Compiler.Text.TaggedText[] get_MainDescription()
+FSharp.Compiler.EditorServices.ToolTipElementData: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.ToolTipElementData: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.ToolTipElementData: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.TaggedText[]] TypeMapping
+FSharp.Compiler.EditorServices.ToolTipElementData: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.TaggedText[]] get_TypeMapping()
+FSharp.Compiler.EditorServices.ToolTipElementData: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.TaggedText[]] Remarks
+FSharp.Compiler.EditorServices.ToolTipElementData: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.TaggedText[]] get_Remarks()
+FSharp.Compiler.EditorServices.ToolTipElementData: Microsoft.FSharp.Core.FSharpOption`1[System.String] ParamName
+FSharp.Compiler.EditorServices.ToolTipElementData: Microsoft.FSharp.Core.FSharpOption`1[System.String] get_ParamName()
+FSharp.Compiler.EditorServices.ToolTipElementData: System.String ToString()
+FSharp.Compiler.EditorServices.ToolTipElementData: Void .ctor(FSharp.Compiler.Text.TaggedText[], FSharp.Compiler.Symbols.FSharpXmlDoc, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.TaggedText[]], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.TaggedText[]], Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.EditorServices.ToolTipText: Boolean Equals(FSharp.Compiler.EditorServices.ToolTipText)
+FSharp.Compiler.EditorServices.ToolTipText: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.ToolTipText: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.ToolTipText: FSharp.Compiler.EditorServices.ToolTipText NewToolTipText(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.ToolTipElement])
+FSharp.Compiler.EditorServices.ToolTipText: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.ToolTipText: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.ToolTipText: Int32 Tag
+FSharp.Compiler.EditorServices.ToolTipText: Int32 get_Tag()
+FSharp.Compiler.EditorServices.ToolTipText: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.ToolTipElement] Item
+FSharp.Compiler.EditorServices.ToolTipText: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.ToolTipElement] get_Item()
+FSharp.Compiler.EditorServices.ToolTipText: System.String ToString()
+FSharp.Compiler.EditorServices.TupledArgumentLocation: Boolean Equals(FSharp.Compiler.EditorServices.TupledArgumentLocation)
+FSharp.Compiler.EditorServices.TupledArgumentLocation: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.TupledArgumentLocation: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.TupledArgumentLocation: Boolean IsNamedArgument
+FSharp.Compiler.EditorServices.TupledArgumentLocation: Boolean get_IsNamedArgument()
+FSharp.Compiler.EditorServices.TupledArgumentLocation: FSharp.Compiler.Text.Range ArgumentRange
+FSharp.Compiler.EditorServices.TupledArgumentLocation: FSharp.Compiler.Text.Range get_ArgumentRange()
+FSharp.Compiler.EditorServices.TupledArgumentLocation: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.TupledArgumentLocation: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.TupledArgumentLocation: System.String ToString()
+FSharp.Compiler.EditorServices.TupledArgumentLocation: Void .ctor(Boolean, FSharp.Compiler.Text.Range)
+FSharp.Compiler.EditorServices.UnresolvedSymbol: Boolean Equals(FSharp.Compiler.EditorServices.UnresolvedSymbol)
+FSharp.Compiler.EditorServices.UnresolvedSymbol: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.UnresolvedSymbol: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.UnresolvedSymbol: Int32 CompareTo(FSharp.Compiler.EditorServices.UnresolvedSymbol)
+FSharp.Compiler.EditorServices.UnresolvedSymbol: Int32 CompareTo(System.Object)
+FSharp.Compiler.EditorServices.UnresolvedSymbol: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.EditorServices.UnresolvedSymbol: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.UnresolvedSymbol: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.UnresolvedSymbol: System.String DisplayName
+FSharp.Compiler.EditorServices.UnresolvedSymbol: System.String FullName
+FSharp.Compiler.EditorServices.UnresolvedSymbol: System.String ToString()
+FSharp.Compiler.EditorServices.UnresolvedSymbol: System.String get_DisplayName()
+FSharp.Compiler.EditorServices.UnresolvedSymbol: System.String get_FullName()
+FSharp.Compiler.EditorServices.UnresolvedSymbol: System.String[] Namespace
+FSharp.Compiler.EditorServices.UnresolvedSymbol: System.String[] get_Namespace()
+FSharp.Compiler.EditorServices.UnresolvedSymbol: Void .ctor(System.String, System.String, System.String[])
+FSharp.Compiler.EditorServices.UnusedDeclarations: Microsoft.FSharp.Control.FSharpAsync`1[System.Collections.Generic.IEnumerable`1[FSharp.Compiler.Text.Range]] getUnusedDeclarations(FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults, Boolean)
+FSharp.Compiler.EditorServices.UnusedOpens: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.Range]] getUnusedOpens(FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.String])
+FSharp.Compiler.EditorServices.XmlDocComment: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] IsBlank(System.String)
+FSharp.Compiler.EditorServices.XmlDocParser: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.EditorServices.XmlDocable] GetXmlDocables(FSharp.Compiler.Text.ISourceText, FSharp.Compiler.Syntax.ParsedInput)
+FSharp.Compiler.EditorServices.XmlDocable: Boolean Equals(FSharp.Compiler.EditorServices.XmlDocable)
+FSharp.Compiler.EditorServices.XmlDocable: Boolean Equals(System.Object)
+FSharp.Compiler.EditorServices.XmlDocable: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.XmlDocable: FSharp.Compiler.EditorServices.XmlDocable NewXmlDocable(Int32, Int32, Microsoft.FSharp.Collections.FSharpList`1[System.String])
+FSharp.Compiler.EditorServices.XmlDocable: Int32 CompareTo(FSharp.Compiler.EditorServices.XmlDocable)
+FSharp.Compiler.EditorServices.XmlDocable: Int32 CompareTo(System.Object)
+FSharp.Compiler.EditorServices.XmlDocable: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.EditorServices.XmlDocable: Int32 GetHashCode()
+FSharp.Compiler.EditorServices.XmlDocable: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.EditorServices.XmlDocable: Int32 Tag
+FSharp.Compiler.EditorServices.XmlDocable: Int32 get_Tag()
+FSharp.Compiler.EditorServices.XmlDocable: Int32 get_indent()
+FSharp.Compiler.EditorServices.XmlDocable: Int32 get_line()
+FSharp.Compiler.EditorServices.XmlDocable: Int32 indent
+FSharp.Compiler.EditorServices.XmlDocable: Int32 line
+FSharp.Compiler.EditorServices.XmlDocable: Microsoft.FSharp.Collections.FSharpList`1[System.String] get_paramNames()
+FSharp.Compiler.EditorServices.XmlDocable: Microsoft.FSharp.Collections.FSharpList`1[System.String] paramNames
+FSharp.Compiler.EditorServices.XmlDocable: System.String ToString()
+FSharp.Compiler.IO.ByteMemory: Byte Item [Int32]
+FSharp.Compiler.IO.ByteMemory: Byte get_Item(Int32)
+FSharp.Compiler.IO.ByteMemory: Byte[] ReadAllBytes()
+FSharp.Compiler.IO.ByteMemory: Byte[] ReadBytes(Int32, Int32)
+FSharp.Compiler.IO.ByteMemory: Byte[] ToArray()
+FSharp.Compiler.IO.ByteMemory: FSharp.Compiler.IO.ByteMemory Empty
+FSharp.Compiler.IO.ByteMemory: FSharp.Compiler.IO.ByteMemory FromArray(Byte[])
+FSharp.Compiler.IO.ByteMemory: FSharp.Compiler.IO.ByteMemory FromArray(Byte[], Int32, Int32)
+FSharp.Compiler.IO.ByteMemory: FSharp.Compiler.IO.ByteMemory FromMemoryMappedFile(System.IO.MemoryMappedFiles.MemoryMappedFile)
+FSharp.Compiler.IO.ByteMemory: FSharp.Compiler.IO.ByteMemory FromUnsafePointer(IntPtr, Int32, System.Object)
+FSharp.Compiler.IO.ByteMemory: FSharp.Compiler.IO.ByteMemory Slice(Int32, Int32)
+FSharp.Compiler.IO.ByteMemory: FSharp.Compiler.IO.ByteMemory get_Empty()
+FSharp.Compiler.IO.ByteMemory: FSharp.Compiler.IO.ReadOnlyByteMemory AsReadOnly()
+FSharp.Compiler.IO.ByteMemory: Int32 Length
+FSharp.Compiler.IO.ByteMemory: Int32 ReadInt32(Int32)
+FSharp.Compiler.IO.ByteMemory: Int32 get_Length()
+FSharp.Compiler.IO.ByteMemory: System.IO.Stream AsReadOnlyStream()
+FSharp.Compiler.IO.ByteMemory: System.IO.Stream AsStream()
+FSharp.Compiler.IO.ByteMemory: System.String ReadUtf8String(Int32, Int32)
+FSharp.Compiler.IO.ByteMemory: UInt16 ReadUInt16(Int32)
+FSharp.Compiler.IO.ByteMemory: Void Copy(Int32, Byte[], Int32, Int32)
+FSharp.Compiler.IO.ByteMemory: Void CopyTo(System.IO.Stream)
+FSharp.Compiler.IO.ByteMemory: Void set_Item(Int32, Byte)
+FSharp.Compiler.IO.DefaultAssemblyLoader: Void .ctor()
+FSharp.Compiler.IO.DefaultFileSystem: Boolean DirectoryExistsShim(System.String)
+FSharp.Compiler.IO.DefaultFileSystem: Boolean FileExistsShim(System.String)
+FSharp.Compiler.IO.DefaultFileSystem: Boolean IsInvalidPathShim(System.String)
+FSharp.Compiler.IO.DefaultFileSystem: Boolean IsPathRootedShim(System.String)
+FSharp.Compiler.IO.DefaultFileSystem: Boolean IsStableFileHeuristic(System.String)
+FSharp.Compiler.IO.DefaultFileSystem: FSharp.Compiler.IO.IAssemblyLoader AssemblyLoader
+FSharp.Compiler.IO.DefaultFileSystem: FSharp.Compiler.IO.IAssemblyLoader get_AssemblyLoader()
+FSharp.Compiler.IO.DefaultFileSystem: System.Collections.Generic.IEnumerable`1[System.String] EnumerateDirectoriesShim(System.String)
+FSharp.Compiler.IO.DefaultFileSystem: System.Collections.Generic.IEnumerable`1[System.String] EnumerateFilesShim(System.String, System.String)
+FSharp.Compiler.IO.DefaultFileSystem: System.DateTime GetCreationTimeShim(System.String)
+FSharp.Compiler.IO.DefaultFileSystem: System.DateTime GetLastWriteTimeShim(System.String)
+FSharp.Compiler.IO.DefaultFileSystem: System.IO.Stream OpenFileForReadShim(System.String, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+FSharp.Compiler.IO.DefaultFileSystem: System.IO.Stream OpenFileForWriteShim(System.String, Microsoft.FSharp.Core.FSharpOption`1[System.IO.FileMode], Microsoft.FSharp.Core.FSharpOption`1[System.IO.FileAccess], Microsoft.FSharp.Core.FSharpOption`1[System.IO.FileShare])
+FSharp.Compiler.IO.DefaultFileSystem: System.String DirectoryCreateShim(System.String)
+FSharp.Compiler.IO.DefaultFileSystem: System.String GetDirectoryNameShim(System.String)
+FSharp.Compiler.IO.DefaultFileSystem: System.String GetFullFilePathInDirectoryShim(System.String, System.String)
+FSharp.Compiler.IO.DefaultFileSystem: System.String GetFullPathShim(System.String)
+FSharp.Compiler.IO.DefaultFileSystem: System.String GetTempPathShim()
+FSharp.Compiler.IO.DefaultFileSystem: System.String NormalizePathShim(System.String)
+FSharp.Compiler.IO.DefaultFileSystem: Void .ctor()
+FSharp.Compiler.IO.DefaultFileSystem: Void CopyShim(System.String, System.String, Boolean)
+FSharp.Compiler.IO.DefaultFileSystem: Void DirectoryDeleteShim(System.String)
+FSharp.Compiler.IO.DefaultFileSystem: Void FileDeleteShim(System.String)
+FSharp.Compiler.IO.FileSystemAutoOpens: FSharp.Compiler.IO.IFileSystem FileSystem
+FSharp.Compiler.IO.FileSystemAutoOpens: FSharp.Compiler.IO.IFileSystem get_FileSystem()
+FSharp.Compiler.IO.FileSystemAutoOpens: Void set_FileSystem(FSharp.Compiler.IO.IFileSystem)
+FSharp.Compiler.IO.IAssemblyLoader: System.Reflection.Assembly AssemblyLoad(System.Reflection.AssemblyName)
+FSharp.Compiler.IO.IAssemblyLoader: System.Reflection.Assembly AssemblyLoadFrom(System.String)
+FSharp.Compiler.IO.IFileSystem: Boolean DirectoryExistsShim(System.String)
+FSharp.Compiler.IO.IFileSystem: Boolean FileExistsShim(System.String)
+FSharp.Compiler.IO.IFileSystem: Boolean IsInvalidPathShim(System.String)
+FSharp.Compiler.IO.IFileSystem: Boolean IsPathRootedShim(System.String)
+FSharp.Compiler.IO.IFileSystem: Boolean IsStableFileHeuristic(System.String)
+FSharp.Compiler.IO.IFileSystem: FSharp.Compiler.IO.IAssemblyLoader AssemblyLoader
+FSharp.Compiler.IO.IFileSystem: FSharp.Compiler.IO.IAssemblyLoader get_AssemblyLoader()
+FSharp.Compiler.IO.IFileSystem: System.Collections.Generic.IEnumerable`1[System.String] EnumerateDirectoriesShim(System.String)
+FSharp.Compiler.IO.IFileSystem: System.Collections.Generic.IEnumerable`1[System.String] EnumerateFilesShim(System.String, System.String)
+FSharp.Compiler.IO.IFileSystem: System.DateTime GetCreationTimeShim(System.String)
+FSharp.Compiler.IO.IFileSystem: System.DateTime GetLastWriteTimeShim(System.String)
+FSharp.Compiler.IO.IFileSystem: System.IO.Stream OpenFileForReadShim(System.String, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+FSharp.Compiler.IO.IFileSystem: System.IO.Stream OpenFileForWriteShim(System.String, Microsoft.FSharp.Core.FSharpOption`1[System.IO.FileMode], Microsoft.FSharp.Core.FSharpOption`1[System.IO.FileAccess], Microsoft.FSharp.Core.FSharpOption`1[System.IO.FileShare])
+FSharp.Compiler.IO.IFileSystem: System.String DirectoryCreateShim(System.String)
+FSharp.Compiler.IO.IFileSystem: System.String GetDirectoryNameShim(System.String)
+FSharp.Compiler.IO.IFileSystem: System.String GetFullFilePathInDirectoryShim(System.String, System.String)
+FSharp.Compiler.IO.IFileSystem: System.String GetFullPathShim(System.String)
+FSharp.Compiler.IO.IFileSystem: System.String GetTempPathShim()
+FSharp.Compiler.IO.IFileSystem: System.String NormalizePathShim(System.String)
+FSharp.Compiler.IO.IFileSystem: Void CopyShim(System.String, System.String, Boolean)
+FSharp.Compiler.IO.IFileSystem: Void DirectoryDeleteShim(System.String)
+FSharp.Compiler.IO.IFileSystem: Void FileDeleteShim(System.String)
+FSharp.Compiler.IO.StreamExtensions: Byte[] Stream.ReadAllBytes(System.IO.Stream)
+FSharp.Compiler.IO.StreamExtensions: Byte[] Stream.ReadBytes(System.IO.Stream, Int32, Int32)
+FSharp.Compiler.IO.StreamExtensions: FSharp.Compiler.IO.ByteMemory Stream.AsByteMemory(System.IO.Stream)
+FSharp.Compiler.IO.StreamExtensions: System.Collections.Generic.IEnumerable`1[System.String] Stream.ReadLines(System.IO.Stream, Microsoft.FSharp.Core.FSharpOption`1[System.Text.Encoding])
+FSharp.Compiler.IO.StreamExtensions: System.IO.StreamReader Stream.GetReader(System.IO.Stream, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+FSharp.Compiler.IO.StreamExtensions: System.IO.TextWriter Stream.GetWriter(System.IO.Stream, Microsoft.FSharp.Core.FSharpOption`1[System.Text.Encoding])
+FSharp.Compiler.IO.StreamExtensions: System.String Stream.ReadAllText(System.IO.Stream, Microsoft.FSharp.Core.FSharpOption`1[System.Text.Encoding])
+FSharp.Compiler.IO.StreamExtensions: System.String[] Stream.ReadAllLines(System.IO.Stream, Microsoft.FSharp.Core.FSharpOption`1[System.Text.Encoding])
+FSharp.Compiler.IO.StreamExtensions: Void Stream.WriteAllLines(System.IO.Stream, System.Collections.Generic.IEnumerable`1[System.String], Microsoft.FSharp.Core.FSharpOption`1[System.Text.Encoding])
+FSharp.Compiler.IO.StreamExtensions: Void Stream.WriteAllText(System.IO.Stream, System.String)
+FSharp.Compiler.IO.StreamExtensions: Void Stream.Write[a](System.IO.Stream, a)
+FSharp.Compiler.Interactive.CtrlBreakHandlers+CtrlBreakClient: Void .ctor(System.String)
+FSharp.Compiler.Interactive.CtrlBreakHandlers+CtrlBreakClient: Void Interrupt()
+FSharp.Compiler.Interactive.CtrlBreakHandlers+CtrlBreakService: Void .ctor(System.String)
+FSharp.Compiler.Interactive.CtrlBreakHandlers+CtrlBreakService: Void Interrupt()
+FSharp.Compiler.Interactive.CtrlBreakHandlers+CtrlBreakService: Void Run()
+FSharp.Compiler.Interactive.CtrlBreakHandlers: FSharp.Compiler.Interactive.CtrlBreakHandlers+CtrlBreakClient
+FSharp.Compiler.Interactive.CtrlBreakHandlers: FSharp.Compiler.Interactive.CtrlBreakHandlers+CtrlBreakService
+FSharp.Compiler.Interactive.Shell+CompilerInputStream: Boolean CanRead
+FSharp.Compiler.Interactive.Shell+CompilerInputStream: Boolean CanSeek
+FSharp.Compiler.Interactive.Shell+CompilerInputStream: Boolean CanWrite
+FSharp.Compiler.Interactive.Shell+CompilerInputStream: Boolean get_CanRead()
+FSharp.Compiler.Interactive.Shell+CompilerInputStream: Boolean get_CanSeek()
+FSharp.Compiler.Interactive.Shell+CompilerInputStream: Boolean get_CanWrite()
+FSharp.Compiler.Interactive.Shell+CompilerInputStream: Int32 Read(Byte[], Int32, Int32)
+FSharp.Compiler.Interactive.Shell+CompilerInputStream: Int64 Length
+FSharp.Compiler.Interactive.Shell+CompilerInputStream: Int64 Position
+FSharp.Compiler.Interactive.Shell+CompilerInputStream: Int64 Seek(Int64, System.IO.SeekOrigin)
+FSharp.Compiler.Interactive.Shell+CompilerInputStream: Int64 get_Length()
+FSharp.Compiler.Interactive.Shell+CompilerInputStream: Int64 get_Position()
+FSharp.Compiler.Interactive.Shell+CompilerInputStream: Void .ctor()
+FSharp.Compiler.Interactive.Shell+CompilerInputStream: Void Add(System.String)
+FSharp.Compiler.Interactive.Shell+CompilerInputStream: Void Flush()
+FSharp.Compiler.Interactive.Shell+CompilerInputStream: Void SetLength(Int64)
+FSharp.Compiler.Interactive.Shell+CompilerInputStream: Void Write(Byte[], Int32, Int32)
+FSharp.Compiler.Interactive.Shell+CompilerInputStream: Void set_Position(Int64)
+FSharp.Compiler.Interactive.Shell+CompilerOutputStream: Boolean CanRead
+FSharp.Compiler.Interactive.Shell+CompilerOutputStream: Boolean CanSeek
+FSharp.Compiler.Interactive.Shell+CompilerOutputStream: Boolean CanWrite
+FSharp.Compiler.Interactive.Shell+CompilerOutputStream: Boolean get_CanRead()
+FSharp.Compiler.Interactive.Shell+CompilerOutputStream: Boolean get_CanSeek()
+FSharp.Compiler.Interactive.Shell+CompilerOutputStream: Boolean get_CanWrite()
+FSharp.Compiler.Interactive.Shell+CompilerOutputStream: Int32 Read(Byte[], Int32, Int32)
+FSharp.Compiler.Interactive.Shell+CompilerOutputStream: Int64 Length
+FSharp.Compiler.Interactive.Shell+CompilerOutputStream: Int64 Position
+FSharp.Compiler.Interactive.Shell+CompilerOutputStream: Int64 Seek(Int64, System.IO.SeekOrigin)
+FSharp.Compiler.Interactive.Shell+CompilerOutputStream: Int64 get_Length()
+FSharp.Compiler.Interactive.Shell+CompilerOutputStream: Int64 get_Position()
+FSharp.Compiler.Interactive.Shell+CompilerOutputStream: System.String Read()
+FSharp.Compiler.Interactive.Shell+CompilerOutputStream: Void .ctor()
+FSharp.Compiler.Interactive.Shell+CompilerOutputStream: Void Flush()
+FSharp.Compiler.Interactive.Shell+CompilerOutputStream: Void SetLength(Int64)
+FSharp.Compiler.Interactive.Shell+CompilerOutputStream: Void Write(Byte[], Int32, Int32)
+FSharp.Compiler.Interactive.Shell+CompilerOutputStream: Void set_Position(Int64)
+FSharp.Compiler.Interactive.Shell+EvaluationEventArgs: FSharp.Compiler.CodeAnalysis.FSharpSymbolUse SymbolUse
+FSharp.Compiler.Interactive.Shell+EvaluationEventArgs: FSharp.Compiler.CodeAnalysis.FSharpSymbolUse get_SymbolUse()
+FSharp.Compiler.Interactive.Shell+EvaluationEventArgs: FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration ImplementationDeclaration
+FSharp.Compiler.Interactive.Shell+EvaluationEventArgs: FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration get_ImplementationDeclaration()
+FSharp.Compiler.Interactive.Shell+EvaluationEventArgs: FSharp.Compiler.Symbols.FSharpSymbol Symbol
+FSharp.Compiler.Interactive.Shell+EvaluationEventArgs: FSharp.Compiler.Symbols.FSharpSymbol get_Symbol()
+FSharp.Compiler.Interactive.Shell+EvaluationEventArgs: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Interactive.Shell+FsiValue] FsiValue
+FSharp.Compiler.Interactive.Shell+EvaluationEventArgs: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Interactive.Shell+FsiValue] get_FsiValue()
+FSharp.Compiler.Interactive.Shell+EvaluationEventArgs: System.String Name
+FSharp.Compiler.Interactive.Shell+EvaluationEventArgs: System.String get_Name()
+FSharp.Compiler.Interactive.Shell+FsiBoundValue: FsiValue Value
+FSharp.Compiler.Interactive.Shell+FsiBoundValue: FsiValue get_Value()
+FSharp.Compiler.Interactive.Shell+FsiBoundValue: System.String Name
+FSharp.Compiler.Interactive.Shell+FsiBoundValue: System.String get_Name()
+FSharp.Compiler.Interactive.Shell+FsiCompilationException: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Diagnostics.FSharpDiagnostic[]] ErrorInfos
+FSharp.Compiler.Interactive.Shell+FsiCompilationException: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Diagnostics.FSharpDiagnostic[]] get_ErrorInfos()
+FSharp.Compiler.Interactive.Shell+FsiCompilationException: Void .ctor(System.String, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Diagnostics.FSharpDiagnostic[]])
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: Boolean IsGui
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: Boolean get_IsGui()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: FSharp.Compiler.CodeAnalysis.FSharpChecker InteractiveChecker
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: FSharp.Compiler.CodeAnalysis.FSharpChecker get_InteractiveChecker()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: FSharp.Compiler.Symbols.FSharpAssemblySignature CurrentPartialAssemblySignature
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: FSharp.Compiler.Symbols.FSharpAssemblySignature get_CurrentPartialAssemblySignature()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: FsiEvaluationSession Create(FsiEvaluationSessionHostConfig, System.String[], System.IO.TextReader, System.IO.TextWriter, System.IO.TextWriter, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.CodeAnalysis.LegacyReferenceResolver])
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: FsiEvaluationSessionHostConfig GetDefaultConfiguration()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: FsiEvaluationSessionHostConfig GetDefaultConfiguration(System.Object)
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: FsiEvaluationSessionHostConfig GetDefaultConfiguration(System.Object, Boolean)
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Interactive.Shell+FsiBoundValue] GetBoundValues()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[Microsoft.FSharp.Core.Unit],Microsoft.FSharp.Core.Unit] PartialAssemblySignatureUpdated
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[Microsoft.FSharp.Core.Unit],Microsoft.FSharp.Core.Unit] get_PartialAssemblySignatureUpdated()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[System.Tuple`3[System.Object,System.Type,System.String]],System.Tuple`3[System.Object,System.Type,System.String]] ValueBound
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[System.Tuple`3[System.Object,System.Type,System.String]],System.Tuple`3[System.Object,System.Type,System.String]] get_ValueBound()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Interactive.Shell+FsiBoundValue] TryFindBoundValue(System.String)
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Interactive.Shell+FsiValue] EvalExpression(System.String)
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] LCID
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] get_LCID()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: System.Collections.Generic.IEnumerable`1[System.String] GetCompletions(System.String)
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: System.Reflection.Assembly[] DynamicAssemblies
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: System.Reflection.Assembly[] get_DynamicAssemblies()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: System.String FormatValue(System.Object, System.Type)
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: System.Tuple`2[Microsoft.FSharp.Core.FSharpChoice`2[Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Interactive.Shell+FsiValue],System.Exception],FSharp.Compiler.Diagnostics.FSharpDiagnostic[]] EvalExpressionNonThrowing(System.String)
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: System.Tuple`2[Microsoft.FSharp.Core.FSharpChoice`2[Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Interactive.Shell+FsiValue],System.Exception],FSharp.Compiler.Diagnostics.FSharpDiagnostic[]] EvalInteractionNonThrowing(System.String, Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: System.Tuple`2[Microsoft.FSharp.Core.FSharpChoice`2[Microsoft.FSharp.Core.Unit,System.Exception],FSharp.Compiler.Diagnostics.FSharpDiagnostic[]] EvalScriptNonThrowing(System.String)
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: System.Tuple`3[FSharp.Compiler.CodeAnalysis.FSharpParseFileResults,FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults,FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults] ParseAndCheckInteraction(System.String)
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: Void AddBoundValue(System.String, System.Object)
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: Void EvalInteraction(System.String, Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: Void EvalScript(System.String)
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: Void Interrupt()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: Void ReportUnhandledException(System.Exception)
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSession: Void Run()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Boolean EventLoopRun()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Boolean ShowDeclarationValues
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Boolean ShowIEnumerable
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Boolean ShowProperties
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Boolean UseFsiAuxLib
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Boolean get_ShowDeclarationValues()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Boolean get_ShowIEnumerable()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Boolean get_ShowProperties()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Boolean get_UseFsiAuxLib()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Int32 PrintDepth
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Int32 PrintLength
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Int32 PrintSize
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Int32 PrintWidth
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Int32 get_PrintDepth()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Int32 get_PrintLength()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Int32 get_PrintSize()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Int32 get_PrintWidth()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Core.FSharpChoice`2[System.Tuple`2[System.Type,Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.String]],System.Tuple`2[System.Type,Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object]]]] AddedPrinters
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Core.FSharpChoice`2[System.Tuple`2[System.Type,Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.String]],System.Tuple`2[System.Type,Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object]]]] get_AddedPrinters()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[FSharp.Compiler.Interactive.Shell+EvaluationEventArgs],FSharp.Compiler.Interactive.Shell+EvaluationEventArgs] OnEvaluation
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[FSharp.Compiler.Interactive.Shell+EvaluationEventArgs],FSharp.Compiler.Interactive.Shell+EvaluationEventArgs] get_OnEvaluation()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.String]] GetOptionalConsoleReadLine(Boolean)
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: System.IFormatProvider FormatProvider
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: System.IFormatProvider get_FormatProvider()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: System.String FloatingPointFormat
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: System.String get_FloatingPointFormat()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: T EventLoopInvoke[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T])
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Void .ctor()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Void EventLoopScheduleRestart()
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Void ReportUserCommandLineArgs(System.String[])
+FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig: Void StartServer(System.String)
+FSharp.Compiler.Interactive.Shell+FsiValue: FSharp.Compiler.Symbols.FSharpType FSharpType
+FSharp.Compiler.Interactive.Shell+FsiValue: FSharp.Compiler.Symbols.FSharpType get_FSharpType()
+FSharp.Compiler.Interactive.Shell+FsiValue: System.Object ReflectionValue
+FSharp.Compiler.Interactive.Shell+FsiValue: System.Object get_ReflectionValue()
+FSharp.Compiler.Interactive.Shell+FsiValue: System.Type ReflectionType
+FSharp.Compiler.Interactive.Shell+FsiValue: System.Type get_ReflectionType()
+FSharp.Compiler.Interactive.Shell+Settings+IEventLoop: Boolean Run()
+FSharp.Compiler.Interactive.Shell+Settings+IEventLoop: T Invoke[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T])
+FSharp.Compiler.Interactive.Shell+Settings+IEventLoop: Void ScheduleRestart()
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Boolean ShowDeclarationValues
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Boolean ShowIEnumerable
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Boolean ShowProperties
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Boolean get_ShowDeclarationValues()
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Boolean get_ShowIEnumerable()
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Boolean get_ShowProperties()
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: IEventLoop EventLoop
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: IEventLoop get_EventLoop()
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Int32 PrintDepth
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Int32 PrintLength
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Int32 PrintSize
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Int32 PrintWidth
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Int32 get_PrintDepth()
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Int32 get_PrintLength()
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Int32 get_PrintSize()
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Int32 get_PrintWidth()
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: System.IFormatProvider FormatProvider
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: System.IFormatProvider get_FormatProvider()
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: System.String FloatingPointFormat
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: System.String get_FloatingPointFormat()
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: System.String[] CommandLineArgs
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: System.String[] get_CommandLineArgs()
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Void AddPrintTransformer[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Object])
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Void AddPrinter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.String])
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Void set_CommandLineArgs(System.String[])
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Void set_EventLoop(IEventLoop)
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Void set_FloatingPointFormat(System.String)
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Void set_FormatProvider(System.IFormatProvider)
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Void set_PrintDepth(Int32)
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Void set_PrintLength(Int32)
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Void set_PrintSize(Int32)
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Void set_PrintWidth(Int32)
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Void set_ShowDeclarationValues(Boolean)
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Void set_ShowIEnumerable(Boolean)
+FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings: Void set_ShowProperties(Boolean)
+FSharp.Compiler.Interactive.Shell+Settings: FSharp.Compiler.Interactive.Shell+Settings+IEventLoop
+FSharp.Compiler.Interactive.Shell+Settings: FSharp.Compiler.Interactive.Shell+Settings+InteractiveSettings
+FSharp.Compiler.Interactive.Shell+Settings: InteractiveSettings fsi
+FSharp.Compiler.Interactive.Shell+Settings: InteractiveSettings get_fsi()
+FSharp.Compiler.Interactive.Shell: FSharp.Compiler.Interactive.Shell+CompilerInputStream
+FSharp.Compiler.Interactive.Shell: FSharp.Compiler.Interactive.Shell+CompilerOutputStream
+FSharp.Compiler.Interactive.Shell: FSharp.Compiler.Interactive.Shell+EvaluationEventArgs
+FSharp.Compiler.Interactive.Shell: FSharp.Compiler.Interactive.Shell+FsiBoundValue
+FSharp.Compiler.Interactive.Shell: FSharp.Compiler.Interactive.Shell+FsiCompilationException
+FSharp.Compiler.Interactive.Shell: FSharp.Compiler.Interactive.Shell+FsiEvaluationSession
+FSharp.Compiler.Interactive.Shell: FSharp.Compiler.Interactive.Shell+FsiEvaluationSessionHostConfig
+FSharp.Compiler.Interactive.Shell: FSharp.Compiler.Interactive.Shell+FsiValue
+FSharp.Compiler.Interactive.Shell: FSharp.Compiler.Interactive.Shell+Settings
+FSharp.Compiler.Symbols.FSharpAbstractParameter: Boolean IsInArg
+FSharp.Compiler.Symbols.FSharpAbstractParameter: Boolean IsOptionalArg
+FSharp.Compiler.Symbols.FSharpAbstractParameter: Boolean IsOutArg
+FSharp.Compiler.Symbols.FSharpAbstractParameter: Boolean get_IsInArg()
+FSharp.Compiler.Symbols.FSharpAbstractParameter: Boolean get_IsOptionalArg()
+FSharp.Compiler.Symbols.FSharpAbstractParameter: Boolean get_IsOutArg()
+FSharp.Compiler.Symbols.FSharpAbstractParameter: FSharp.Compiler.Symbols.FSharpType Type
+FSharp.Compiler.Symbols.FSharpAbstractParameter: FSharp.Compiler.Symbols.FSharpType get_Type()
+FSharp.Compiler.Symbols.FSharpAbstractParameter: Microsoft.FSharp.Core.FSharpOption`1[System.String] Name
+FSharp.Compiler.Symbols.FSharpAbstractParameter: Microsoft.FSharp.Core.FSharpOption`1[System.String] get_Name()
+FSharp.Compiler.Symbols.FSharpAbstractParameter: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAttribute] Attributes
+FSharp.Compiler.Symbols.FSharpAbstractParameter: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAttribute] get_Attributes()
+FSharp.Compiler.Symbols.FSharpAbstractSignature: FSharp.Compiler.Symbols.FSharpType AbstractReturnType
+FSharp.Compiler.Symbols.FSharpAbstractSignature: FSharp.Compiler.Symbols.FSharpType DeclaringType
+FSharp.Compiler.Symbols.FSharpAbstractSignature: FSharp.Compiler.Symbols.FSharpType get_AbstractReturnType()
+FSharp.Compiler.Symbols.FSharpAbstractSignature: FSharp.Compiler.Symbols.FSharpType get_DeclaringType()
+FSharp.Compiler.Symbols.FSharpAbstractSignature: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpGenericParameter] DeclaringTypeGenericParameters
+FSharp.Compiler.Symbols.FSharpAbstractSignature: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpGenericParameter] MethodGenericParameters
+FSharp.Compiler.Symbols.FSharpAbstractSignature: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpGenericParameter] get_DeclaringTypeGenericParameters()
+FSharp.Compiler.Symbols.FSharpAbstractSignature: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpGenericParameter] get_MethodGenericParameters()
+FSharp.Compiler.Symbols.FSharpAbstractSignature: System.Collections.Generic.IList`1[System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAbstractParameter]] AbstractArguments
+FSharp.Compiler.Symbols.FSharpAbstractSignature: System.Collections.Generic.IList`1[System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAbstractParameter]] get_AbstractArguments()
+FSharp.Compiler.Symbols.FSharpAbstractSignature: System.String Name
+FSharp.Compiler.Symbols.FSharpAbstractSignature: System.String get_Name()
+FSharp.Compiler.Symbols.FSharpAccessibility: Boolean IsInternal
+FSharp.Compiler.Symbols.FSharpAccessibility: Boolean IsPrivate
+FSharp.Compiler.Symbols.FSharpAccessibility: Boolean IsProtected
+FSharp.Compiler.Symbols.FSharpAccessibility: Boolean IsPublic
+FSharp.Compiler.Symbols.FSharpAccessibility: Boolean get_IsInternal()
+FSharp.Compiler.Symbols.FSharpAccessibility: Boolean get_IsPrivate()
+FSharp.Compiler.Symbols.FSharpAccessibility: Boolean get_IsProtected()
+FSharp.Compiler.Symbols.FSharpAccessibility: Boolean get_IsPublic()
+FSharp.Compiler.Symbols.FSharpAccessibility: System.String ToString()
+FSharp.Compiler.Symbols.FSharpActivePatternCase: FSharp.Compiler.Symbols.FSharpActivePatternGroup Group
+FSharp.Compiler.Symbols.FSharpActivePatternCase: FSharp.Compiler.Symbols.FSharpActivePatternGroup get_Group()
+FSharp.Compiler.Symbols.FSharpActivePatternCase: FSharp.Compiler.Symbols.FSharpXmlDoc XmlDoc
+FSharp.Compiler.Symbols.FSharpActivePatternCase: FSharp.Compiler.Symbols.FSharpXmlDoc get_XmlDoc()
+FSharp.Compiler.Symbols.FSharpActivePatternCase: FSharp.Compiler.Text.Range DeclarationLocation
+FSharp.Compiler.Symbols.FSharpActivePatternCase: FSharp.Compiler.Text.Range get_DeclarationLocation()
+FSharp.Compiler.Symbols.FSharpActivePatternCase: Int32 Index
+FSharp.Compiler.Symbols.FSharpActivePatternCase: Int32 get_Index()
+FSharp.Compiler.Symbols.FSharpActivePatternCase: System.String Name
+FSharp.Compiler.Symbols.FSharpActivePatternCase: System.String XmlDocSig
+FSharp.Compiler.Symbols.FSharpActivePatternCase: System.String get_Name()
+FSharp.Compiler.Symbols.FSharpActivePatternCase: System.String get_XmlDocSig()
+FSharp.Compiler.Symbols.FSharpActivePatternGroup: Boolean IsTotal
+FSharp.Compiler.Symbols.FSharpActivePatternGroup: Boolean get_IsTotal()
+FSharp.Compiler.Symbols.FSharpActivePatternGroup: FSharp.Compiler.Symbols.FSharpType OverallType
+FSharp.Compiler.Symbols.FSharpActivePatternGroup: FSharp.Compiler.Symbols.FSharpType get_OverallType()
+FSharp.Compiler.Symbols.FSharpActivePatternGroup: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpEntity] DeclaringEntity
+FSharp.Compiler.Symbols.FSharpActivePatternGroup: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpEntity] get_DeclaringEntity()
+FSharp.Compiler.Symbols.FSharpActivePatternGroup: Microsoft.FSharp.Core.FSharpOption`1[System.String] Name
+FSharp.Compiler.Symbols.FSharpActivePatternGroup: Microsoft.FSharp.Core.FSharpOption`1[System.String] get_Name()
+FSharp.Compiler.Symbols.FSharpActivePatternGroup: System.Collections.Generic.IList`1[System.String] Names
+FSharp.Compiler.Symbols.FSharpActivePatternGroup: System.Collections.Generic.IList`1[System.String] get_Names()
+FSharp.Compiler.Symbols.FSharpAnonRecordTypeDetails: FSharp.Compiler.Symbols.FSharpAssembly Assembly
+FSharp.Compiler.Symbols.FSharpAnonRecordTypeDetails: FSharp.Compiler.Symbols.FSharpAssembly get_Assembly()
+FSharp.Compiler.Symbols.FSharpAnonRecordTypeDetails: Microsoft.FSharp.Collections.FSharpList`1[System.String] EnclosingCompiledTypeNames
+FSharp.Compiler.Symbols.FSharpAnonRecordTypeDetails: Microsoft.FSharp.Collections.FSharpList`1[System.String] get_EnclosingCompiledTypeNames()
+FSharp.Compiler.Symbols.FSharpAnonRecordTypeDetails: System.String CompiledName
+FSharp.Compiler.Symbols.FSharpAnonRecordTypeDetails: System.String get_CompiledName()
+FSharp.Compiler.Symbols.FSharpAnonRecordTypeDetails: System.String[] SortedFieldNames
+FSharp.Compiler.Symbols.FSharpAnonRecordTypeDetails: System.String[] get_SortedFieldNames()
+FSharp.Compiler.Symbols.FSharpAssembly: Boolean IsProviderGenerated
+FSharp.Compiler.Symbols.FSharpAssembly: Boolean get_IsProviderGenerated()
+FSharp.Compiler.Symbols.FSharpAssembly: FSharp.Compiler.Symbols.FSharpAssemblySignature Contents
+FSharp.Compiler.Symbols.FSharpAssembly: FSharp.Compiler.Symbols.FSharpAssemblySignature get_Contents()
+FSharp.Compiler.Symbols.FSharpAssembly: Microsoft.FSharp.Core.FSharpOption`1[System.String] FileName
+FSharp.Compiler.Symbols.FSharpAssembly: Microsoft.FSharp.Core.FSharpOption`1[System.String] get_FileName()
+FSharp.Compiler.Symbols.FSharpAssembly: System.String QualifiedName
+FSharp.Compiler.Symbols.FSharpAssembly: System.String SimpleName
+FSharp.Compiler.Symbols.FSharpAssembly: System.String ToString()
+FSharp.Compiler.Symbols.FSharpAssembly: System.String get_QualifiedName()
+FSharp.Compiler.Symbols.FSharpAssembly: System.String get_SimpleName()
+FSharp.Compiler.Symbols.FSharpAssemblyContents: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpImplementationFileContents] ImplementationFiles
+FSharp.Compiler.Symbols.FSharpAssemblyContents: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpImplementationFileContents] get_ImplementationFiles()
+FSharp.Compiler.Symbols.FSharpAssemblySignature: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpEntity] FindEntityByPath(Microsoft.FSharp.Collections.FSharpList`1[System.String])
+FSharp.Compiler.Symbols.FSharpAssemblySignature: System.Collections.Generic.IEnumerable`1[FSharp.Compiler.Symbols.FSharpEntity] TryGetEntities()
+FSharp.Compiler.Symbols.FSharpAssemblySignature: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAttribute] Attributes
+FSharp.Compiler.Symbols.FSharpAssemblySignature: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAttribute] get_Attributes()
+FSharp.Compiler.Symbols.FSharpAssemblySignature: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpEntity] Entities
+FSharp.Compiler.Symbols.FSharpAssemblySignature: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpEntity] get_Entities()
+FSharp.Compiler.Symbols.FSharpAssemblySignature: System.String ToString()
+FSharp.Compiler.Symbols.FSharpAttribute: Boolean IsAttribute[T]()
+FSharp.Compiler.Symbols.FSharpAttribute: Boolean IsUnresolved
+FSharp.Compiler.Symbols.FSharpAttribute: Boolean get_IsUnresolved()
+FSharp.Compiler.Symbols.FSharpAttribute: FSharp.Compiler.Symbols.FSharpEntity AttributeType
+FSharp.Compiler.Symbols.FSharpAttribute: FSharp.Compiler.Symbols.FSharpEntity get_AttributeType()
+FSharp.Compiler.Symbols.FSharpAttribute: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Symbols.FSharpAttribute: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Symbols.FSharpAttribute: System.Collections.Generic.IList`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpType,System.Object]] ConstructorArguments
+FSharp.Compiler.Symbols.FSharpAttribute: System.Collections.Generic.IList`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpType,System.Object]] get_ConstructorArguments()
+FSharp.Compiler.Symbols.FSharpAttribute: System.Collections.Generic.IList`1[System.Tuple`4[FSharp.Compiler.Symbols.FSharpType,System.String,System.Boolean,System.Object]] NamedArguments
+FSharp.Compiler.Symbols.FSharpAttribute: System.Collections.Generic.IList`1[System.Tuple`4[FSharp.Compiler.Symbols.FSharpType,System.String,System.Boolean,System.Object]] get_NamedArguments()
+FSharp.Compiler.Symbols.FSharpAttribute: System.String Format(FSharp.Compiler.Symbols.FSharpDisplayContext)
+FSharp.Compiler.Symbols.FSharpAttribute: System.String ToString()
+FSharp.Compiler.Symbols.FSharpDelegateSignature: FSharp.Compiler.Symbols.FSharpType DelegateReturnType
+FSharp.Compiler.Symbols.FSharpDelegateSignature: FSharp.Compiler.Symbols.FSharpType get_DelegateReturnType()
+FSharp.Compiler.Symbols.FSharpDelegateSignature: System.Collections.Generic.IList`1[System.Tuple`2[Microsoft.FSharp.Core.FSharpOption`1[System.String],FSharp.Compiler.Symbols.FSharpType]] DelegateArguments
+FSharp.Compiler.Symbols.FSharpDelegateSignature: System.Collections.Generic.IList`1[System.Tuple`2[Microsoft.FSharp.Core.FSharpOption`1[System.String],FSharp.Compiler.Symbols.FSharpType]] get_DelegateArguments()
+FSharp.Compiler.Symbols.FSharpDelegateSignature: System.String ToString()
+FSharp.Compiler.Symbols.FSharpDisplayContext: FSharp.Compiler.Symbols.FSharpDisplayContext Empty
+FSharp.Compiler.Symbols.FSharpDisplayContext: FSharp.Compiler.Symbols.FSharpDisplayContext WithPrefixGenericParameters()
+FSharp.Compiler.Symbols.FSharpDisplayContext: FSharp.Compiler.Symbols.FSharpDisplayContext WithShortTypeNames(Boolean)
+FSharp.Compiler.Symbols.FSharpDisplayContext: FSharp.Compiler.Symbols.FSharpDisplayContext WithSuffixGenericParameters()
+FSharp.Compiler.Symbols.FSharpDisplayContext: FSharp.Compiler.Symbols.FSharpDisplayContext get_Empty()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean Equals(System.Object)
+FSharp.Compiler.Symbols.FSharpEntity: Boolean HasAssemblyCodeRepresentation
+FSharp.Compiler.Symbols.FSharpEntity: Boolean HasFSharpModuleSuffix
+FSharp.Compiler.Symbols.FSharpEntity: Boolean IsAbstractClass
+FSharp.Compiler.Symbols.FSharpEntity: Boolean IsArrayType
+FSharp.Compiler.Symbols.FSharpEntity: Boolean IsAttributeType
+FSharp.Compiler.Symbols.FSharpEntity: Boolean IsByRef
+FSharp.Compiler.Symbols.FSharpEntity: Boolean IsClass
+FSharp.Compiler.Symbols.FSharpEntity: Boolean IsDelegate
+FSharp.Compiler.Symbols.FSharpEntity: Boolean IsEnum
+FSharp.Compiler.Symbols.FSharpEntity: Boolean IsFSharp
+FSharp.Compiler.Symbols.FSharpEntity: Boolean IsFSharpAbbreviation
+FSharp.Compiler.Symbols.FSharpEntity: Boolean IsFSharpExceptionDeclaration
+FSharp.Compiler.Symbols.FSharpEntity: Boolean IsFSharpModule
+FSharp.Compiler.Symbols.FSharpEntity: Boolean IsFSharpRecord
+FSharp.Compiler.Symbols.FSharpEntity: Boolean IsFSharpUnion
+FSharp.Compiler.Symbols.FSharpEntity: Boolean IsInterface
+FSharp.Compiler.Symbols.FSharpEntity: Boolean IsMeasure
+FSharp.Compiler.Symbols.FSharpEntity: Boolean IsNamespace
+FSharp.Compiler.Symbols.FSharpEntity: Boolean IsOpaque
+FSharp.Compiler.Symbols.FSharpEntity: Boolean IsProvided
+FSharp.Compiler.Symbols.FSharpEntity: Boolean IsProvidedAndErased
+FSharp.Compiler.Symbols.FSharpEntity: Boolean IsProvidedAndGenerated
+FSharp.Compiler.Symbols.FSharpEntity: Boolean IsStaticInstantiation
+FSharp.Compiler.Symbols.FSharpEntity: Boolean IsUnresolved
+FSharp.Compiler.Symbols.FSharpEntity: Boolean IsValueType
+FSharp.Compiler.Symbols.FSharpEntity: Boolean UsesPrefixDisplay
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_HasAssemblyCodeRepresentation()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_HasFSharpModuleSuffix()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_IsAbstractClass()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_IsArrayType()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_IsAttributeType()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_IsByRef()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_IsClass()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_IsDelegate()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_IsEnum()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_IsFSharp()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_IsFSharpAbbreviation()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_IsFSharpExceptionDeclaration()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_IsFSharpModule()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_IsFSharpRecord()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_IsFSharpUnion()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_IsInterface()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_IsMeasure()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_IsNamespace()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_IsOpaque()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_IsProvided()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_IsProvidedAndErased()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_IsProvidedAndGenerated()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_IsStaticInstantiation()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_IsUnresolved()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_IsValueType()
+FSharp.Compiler.Symbols.FSharpEntity: Boolean get_UsesPrefixDisplay()
+FSharp.Compiler.Symbols.FSharpEntity: FSharp.Compiler.Symbols.FSharpAccessibility Accessibility
+FSharp.Compiler.Symbols.FSharpEntity: FSharp.Compiler.Symbols.FSharpAccessibility RepresentationAccessibility
+FSharp.Compiler.Symbols.FSharpEntity: FSharp.Compiler.Symbols.FSharpAccessibility get_Accessibility()
+FSharp.Compiler.Symbols.FSharpEntity: FSharp.Compiler.Symbols.FSharpAccessibility get_RepresentationAccessibility()
+FSharp.Compiler.Symbols.FSharpEntity: FSharp.Compiler.Symbols.FSharpDelegateSignature FSharpDelegateSignature
+FSharp.Compiler.Symbols.FSharpEntity: FSharp.Compiler.Symbols.FSharpDelegateSignature get_FSharpDelegateSignature()
+FSharp.Compiler.Symbols.FSharpEntity: FSharp.Compiler.Symbols.FSharpType AbbreviatedType
+FSharp.Compiler.Symbols.FSharpEntity: FSharp.Compiler.Symbols.FSharpType AsType()
+FSharp.Compiler.Symbols.FSharpEntity: FSharp.Compiler.Symbols.FSharpType get_AbbreviatedType()
+FSharp.Compiler.Symbols.FSharpEntity: FSharp.Compiler.Symbols.FSharpXmlDoc XmlDoc
+FSharp.Compiler.Symbols.FSharpEntity: FSharp.Compiler.Symbols.FSharpXmlDoc get_XmlDoc()
+FSharp.Compiler.Symbols.FSharpEntity: FSharp.Compiler.Text.Range DeclarationLocation
+FSharp.Compiler.Symbols.FSharpEntity: FSharp.Compiler.Text.Range get_DeclarationLocation()
+FSharp.Compiler.Symbols.FSharpEntity: Int32 ArrayRank
+FSharp.Compiler.Symbols.FSharpEntity: Int32 GetHashCode()
+FSharp.Compiler.Symbols.FSharpEntity: Int32 get_ArrayRank()
+FSharp.Compiler.Symbols.FSharpEntity: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpActivePatternCase] ActivePatternCases
+FSharp.Compiler.Symbols.FSharpEntity: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpActivePatternCase] get_ActivePatternCases()
+FSharp.Compiler.Symbols.FSharpEntity: Microsoft.FSharp.Collections.FSharpList`1[System.String] AllCompilationPaths
+FSharp.Compiler.Symbols.FSharpEntity: Microsoft.FSharp.Collections.FSharpList`1[System.String] get_AllCompilationPaths()
+FSharp.Compiler.Symbols.FSharpEntity: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpEntity] DeclaringEntity
+FSharp.Compiler.Symbols.FSharpEntity: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpEntity] get_DeclaringEntity()
+FSharp.Compiler.Symbols.FSharpEntity: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpType] BaseType
+FSharp.Compiler.Symbols.FSharpEntity: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpType] get_BaseType()
+FSharp.Compiler.Symbols.FSharpEntity: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.ISourceText] TryGetMetadataText()
+FSharp.Compiler.Symbols.FSharpEntity: Microsoft.FSharp.Core.FSharpOption`1[System.String] Namespace
+FSharp.Compiler.Symbols.FSharpEntity: Microsoft.FSharp.Core.FSharpOption`1[System.String] TryFullName
+FSharp.Compiler.Symbols.FSharpEntity: Microsoft.FSharp.Core.FSharpOption`1[System.String] TryGetFullCompiledName()
+FSharp.Compiler.Symbols.FSharpEntity: Microsoft.FSharp.Core.FSharpOption`1[System.String] TryGetFullDisplayName()
+FSharp.Compiler.Symbols.FSharpEntity: Microsoft.FSharp.Core.FSharpOption`1[System.String] TryGetFullName()
+FSharp.Compiler.Symbols.FSharpEntity: Microsoft.FSharp.Core.FSharpOption`1[System.String] get_Namespace()
+FSharp.Compiler.Symbols.FSharpEntity: Microsoft.FSharp.Core.FSharpOption`1[System.String] get_TryFullName()
+FSharp.Compiler.Symbols.FSharpEntity: System.Collections.Generic.IEnumerable`1[FSharp.Compiler.Symbols.FSharpEntity] GetPublicNestedEntities()
+FSharp.Compiler.Symbols.FSharpEntity: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAttribute] Attributes
+FSharp.Compiler.Symbols.FSharpEntity: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAttribute] get_Attributes()
+FSharp.Compiler.Symbols.FSharpEntity: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpEntity] NestedEntities
+FSharp.Compiler.Symbols.FSharpEntity: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpEntity] get_NestedEntities()
+FSharp.Compiler.Symbols.FSharpEntity: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpField] FSharpFields
+FSharp.Compiler.Symbols.FSharpEntity: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpField] get_FSharpFields()
+FSharp.Compiler.Symbols.FSharpEntity: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpGenericParameter] GenericParameters
+FSharp.Compiler.Symbols.FSharpEntity: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpGenericParameter] get_GenericParameters()
+FSharp.Compiler.Symbols.FSharpEntity: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue] MembersFunctionsAndValues
+FSharp.Compiler.Symbols.FSharpEntity: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue] TryGetMembersFunctionsAndValues()
+FSharp.Compiler.Symbols.FSharpEntity: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue] get_MembersFunctionsAndValues()
+FSharp.Compiler.Symbols.FSharpEntity: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpStaticParameter] StaticParameters
+FSharp.Compiler.Symbols.FSharpEntity: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpStaticParameter] get_StaticParameters()
+FSharp.Compiler.Symbols.FSharpEntity: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpType] AllInterfaces
+FSharp.Compiler.Symbols.FSharpEntity: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpType] DeclaredInterfaces
+FSharp.Compiler.Symbols.FSharpEntity: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpType] get_AllInterfaces()
+FSharp.Compiler.Symbols.FSharpEntity: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpType] get_DeclaredInterfaces()
+FSharp.Compiler.Symbols.FSharpEntity: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpUnionCase] UnionCases
+FSharp.Compiler.Symbols.FSharpEntity: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpUnionCase] get_UnionCases()
+FSharp.Compiler.Symbols.FSharpEntity: System.String AccessPath
+FSharp.Compiler.Symbols.FSharpEntity: System.String BasicQualifiedName
+FSharp.Compiler.Symbols.FSharpEntity: System.String CompiledName
+FSharp.Compiler.Symbols.FSharpEntity: System.String DisplayName
+FSharp.Compiler.Symbols.FSharpEntity: System.String FullName
+FSharp.Compiler.Symbols.FSharpEntity: System.String LogicalName
+FSharp.Compiler.Symbols.FSharpEntity: System.String QualifiedName
+FSharp.Compiler.Symbols.FSharpEntity: System.String ToString()
+FSharp.Compiler.Symbols.FSharpEntity: System.String XmlDocSig
+FSharp.Compiler.Symbols.FSharpEntity: System.String get_AccessPath()
+FSharp.Compiler.Symbols.FSharpEntity: System.String get_BasicQualifiedName()
+FSharp.Compiler.Symbols.FSharpEntity: System.String get_CompiledName()
+FSharp.Compiler.Symbols.FSharpEntity: System.String get_DisplayName()
+FSharp.Compiler.Symbols.FSharpEntity: System.String get_FullName()
+FSharp.Compiler.Symbols.FSharpEntity: System.String get_LogicalName()
+FSharp.Compiler.Symbols.FSharpEntity: System.String get_QualifiedName()
+FSharp.Compiler.Symbols.FSharpEntity: System.String get_XmlDocSig()
+FSharp.Compiler.Symbols.FSharpExpr: FSharp.Compiler.Symbols.FSharpType Type
+FSharp.Compiler.Symbols.FSharpExpr: FSharp.Compiler.Symbols.FSharpType get_Type()
+FSharp.Compiler.Symbols.FSharpExpr: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Symbols.FSharpExpr: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Symbols.FSharpExpr: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpExpr] ImmediateSubExpressions
+FSharp.Compiler.Symbols.FSharpExpr: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpExpr] get_ImmediateSubExpressions()
+FSharp.Compiler.Symbols.FSharpExpr: System.String ToString()
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpExpr] |AddressOf|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpExpr] |Quote|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue] |Value|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpType] |BaseValue|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpType] |DefaultValue|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpType] |ThisValue|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] |WitnessArg|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpExpr,FSharp.Compiler.Symbols.FSharpExpr]] |AddressSet|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpExpr,FSharp.Compiler.Symbols.FSharpExpr]] |Sequential|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpExpr,FSharp.Compiler.Symbols.FSharpType]] |UnionCaseTag|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpExpr,Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue],FSharp.Compiler.Symbols.FSharpExpr]]]] |DecisionTree|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue,FSharp.Compiler.Symbols.FSharpExpr]] |Lambda|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue,FSharp.Compiler.Symbols.FSharpExpr]] |ValueSet|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpType,FSharp.Compiler.Symbols.FSharpExpr]] |Coerce|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpType,FSharp.Compiler.Symbols.FSharpExpr]] |NewDelegate|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpType,FSharp.Compiler.Symbols.FSharpExpr]] |TypeTest|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpType,Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpExpr]]] |NewAnonRecord|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpType,Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpExpr]]] |NewArray|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpType,Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpExpr]]] |NewRecord|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpType,Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpExpr]]] |NewTuple|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Syntax.DebugPointAtLeafExpr,FSharp.Compiler.Symbols.FSharpExpr]] |DebugPoint|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpGenericParameter],FSharp.Compiler.Symbols.FSharpExpr]] |TypeLambda|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue,FSharp.Compiler.Symbols.FSharpExpr,FSharp.Compiler.Syntax.DebugPointAtBinding]],FSharp.Compiler.Symbols.FSharpExpr]] |LetRec|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Int32,Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpExpr]]] |DecisionTreeSuccess|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Object,FSharp.Compiler.Symbols.FSharpType]] |Const|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Tuple`3[FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue,FSharp.Compiler.Symbols.FSharpExpr,FSharp.Compiler.Syntax.DebugPointAtBinding],FSharp.Compiler.Symbols.FSharpExpr]] |Let|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[FSharp.Compiler.Symbols.FSharpExpr,FSharp.Compiler.Symbols.FSharpExpr,FSharp.Compiler.Symbols.FSharpExpr]] |IfThenElse|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[FSharp.Compiler.Symbols.FSharpExpr,FSharp.Compiler.Symbols.FSharpExpr,FSharp.Compiler.Syntax.DebugPointAtWhile]] |WhileLoop|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[FSharp.Compiler.Symbols.FSharpExpr,FSharp.Compiler.Symbols.FSharpType,FSharp.Compiler.Symbols.FSharpUnionCase]] |UnionCaseTest|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[FSharp.Compiler.Symbols.FSharpExpr,FSharp.Compiler.Symbols.FSharpType,System.Int32]] |AnonRecordGet|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[FSharp.Compiler.Symbols.FSharpExpr,Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpType],Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpExpr]]] |Application|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue,Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpType],Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpExpr]]] |NewObject|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[FSharp.Compiler.Symbols.FSharpType,FSharp.Compiler.Symbols.FSharpUnionCase,Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpExpr]]] |NewUnionCase|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[FSharp.Compiler.Symbols.FSharpType,System.Int32,FSharp.Compiler.Symbols.FSharpExpr]] |TupleGet|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpExpr],FSharp.Compiler.Symbols.FSharpType,FSharp.Compiler.Symbols.FSharpField]] |FSharpFieldGet|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpExpr],FSharp.Compiler.Symbols.FSharpType,System.String]] |ILFieldGet|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.String,Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpType],Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpExpr]]] |ILAsm|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`4[FSharp.Compiler.Symbols.FSharpExpr,FSharp.Compiler.Symbols.FSharpExpr,FSharp.Compiler.Syntax.DebugPointAtTry,FSharp.Compiler.Syntax.DebugPointAtFinally]] |TryFinally|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`4[FSharp.Compiler.Symbols.FSharpExpr,FSharp.Compiler.Symbols.FSharpType,FSharp.Compiler.Symbols.FSharpUnionCase,FSharp.Compiler.Symbols.FSharpField]] |UnionCaseGet|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`4[FSharp.Compiler.Symbols.FSharpType,FSharp.Compiler.Symbols.FSharpExpr,Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpObjectExprOverride],Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpType,Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpObjectExprOverride]]]]] |ObjectExpr|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`4[Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpExpr],FSharp.Compiler.Symbols.FSharpType,FSharp.Compiler.Symbols.FSharpField,FSharp.Compiler.Symbols.FSharpExpr]] |FSharpFieldSet|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`4[Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpExpr],FSharp.Compiler.Symbols.FSharpType,System.String,FSharp.Compiler.Symbols.FSharpExpr]] |ILFieldSet|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`5[FSharp.Compiler.Symbols.FSharpExpr,FSharp.Compiler.Symbols.FSharpType,FSharp.Compiler.Symbols.FSharpUnionCase,FSharp.Compiler.Symbols.FSharpField,FSharp.Compiler.Symbols.FSharpExpr]] |UnionCaseSet|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`5[Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpExpr],FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue,Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpType],Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpType],Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpExpr]]] |Call|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`6[FSharp.Compiler.Symbols.FSharpExpr,FSharp.Compiler.Symbols.FSharpExpr,FSharp.Compiler.Symbols.FSharpExpr,System.Boolean,FSharp.Compiler.Syntax.DebugPointAtFor,FSharp.Compiler.Syntax.DebugPointAtInOrTo]] |FastIntegerForLoop|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`6[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpType],System.String,FSharp.Compiler.Syntax.SynMemberFlags,Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpType],Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpType],Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpExpr]]] |TraitCall|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`6[Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpExpr],FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue,Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpType],Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpType],Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpExpr],Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpExpr]]] |CallWithWitnesses|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpExprPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`7[FSharp.Compiler.Symbols.FSharpExpr,FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue,FSharp.Compiler.Symbols.FSharpExpr,FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue,FSharp.Compiler.Symbols.FSharpExpr,FSharp.Compiler.Syntax.DebugPointAtTry,FSharp.Compiler.Syntax.DebugPointAtWith]] |TryWith|_|(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpField: Boolean Equals(System.Object)
+FSharp.Compiler.Symbols.FSharpField: Boolean IsAnonRecordField
+FSharp.Compiler.Symbols.FSharpField: Boolean IsCompilerGenerated
+FSharp.Compiler.Symbols.FSharpField: Boolean IsDefaultValue
+FSharp.Compiler.Symbols.FSharpField: Boolean IsLiteral
+FSharp.Compiler.Symbols.FSharpField: Boolean IsMutable
+FSharp.Compiler.Symbols.FSharpField: Boolean IsNameGenerated
+FSharp.Compiler.Symbols.FSharpField: Boolean IsStatic
+FSharp.Compiler.Symbols.FSharpField: Boolean IsUnionCaseField
+FSharp.Compiler.Symbols.FSharpField: Boolean IsUnresolved
+FSharp.Compiler.Symbols.FSharpField: Boolean IsVolatile
+FSharp.Compiler.Symbols.FSharpField: Boolean get_IsAnonRecordField()
+FSharp.Compiler.Symbols.FSharpField: Boolean get_IsCompilerGenerated()
+FSharp.Compiler.Symbols.FSharpField: Boolean get_IsDefaultValue()
+FSharp.Compiler.Symbols.FSharpField: Boolean get_IsLiteral()
+FSharp.Compiler.Symbols.FSharpField: Boolean get_IsMutable()
+FSharp.Compiler.Symbols.FSharpField: Boolean get_IsNameGenerated()
+FSharp.Compiler.Symbols.FSharpField: Boolean get_IsStatic()
+FSharp.Compiler.Symbols.FSharpField: Boolean get_IsUnionCaseField()
+FSharp.Compiler.Symbols.FSharpField: Boolean get_IsUnresolved()
+FSharp.Compiler.Symbols.FSharpField: Boolean get_IsVolatile()
+FSharp.Compiler.Symbols.FSharpField: FSharp.Compiler.Symbols.FSharpAccessibility Accessibility
+FSharp.Compiler.Symbols.FSharpField: FSharp.Compiler.Symbols.FSharpAccessibility get_Accessibility()
+FSharp.Compiler.Symbols.FSharpField: FSharp.Compiler.Symbols.FSharpType FieldType
+FSharp.Compiler.Symbols.FSharpField: FSharp.Compiler.Symbols.FSharpType get_FieldType()
+FSharp.Compiler.Symbols.FSharpField: FSharp.Compiler.Symbols.FSharpXmlDoc XmlDoc
+FSharp.Compiler.Symbols.FSharpField: FSharp.Compiler.Symbols.FSharpXmlDoc get_XmlDoc()
+FSharp.Compiler.Symbols.FSharpField: FSharp.Compiler.Text.Range DeclarationLocation
+FSharp.Compiler.Symbols.FSharpField: FSharp.Compiler.Text.Range get_DeclarationLocation()
+FSharp.Compiler.Symbols.FSharpField: Int32 GetHashCode()
+FSharp.Compiler.Symbols.FSharpField: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpEntity] DeclaringEntity
+FSharp.Compiler.Symbols.FSharpField: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpEntity] get_DeclaringEntity()
+FSharp.Compiler.Symbols.FSharpField: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpUnionCase] DeclaringUnionCase
+FSharp.Compiler.Symbols.FSharpField: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpUnionCase] get_DeclaringUnionCase()
+FSharp.Compiler.Symbols.FSharpField: Microsoft.FSharp.Core.FSharpOption`1[System.Object] LiteralValue
+FSharp.Compiler.Symbols.FSharpField: Microsoft.FSharp.Core.FSharpOption`1[System.Object] get_LiteralValue()
+FSharp.Compiler.Symbols.FSharpField: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAttribute] FieldAttributes
+FSharp.Compiler.Symbols.FSharpField: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAttribute] PropertyAttributes
+FSharp.Compiler.Symbols.FSharpField: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAttribute] get_FieldAttributes()
+FSharp.Compiler.Symbols.FSharpField: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAttribute] get_PropertyAttributes()
+FSharp.Compiler.Symbols.FSharpField: System.String Name
+FSharp.Compiler.Symbols.FSharpField: System.String ToString()
+FSharp.Compiler.Symbols.FSharpField: System.String XmlDocSig
+FSharp.Compiler.Symbols.FSharpField: System.String get_Name()
+FSharp.Compiler.Symbols.FSharpField: System.String get_XmlDocSig()
+FSharp.Compiler.Symbols.FSharpField: System.Tuple`3[FSharp.Compiler.Symbols.FSharpAnonRecordTypeDetails,FSharp.Compiler.Symbols.FSharpType[],System.Int32] AnonRecordFieldDetails
+FSharp.Compiler.Symbols.FSharpField: System.Tuple`3[FSharp.Compiler.Symbols.FSharpAnonRecordTypeDetails,FSharp.Compiler.Symbols.FSharpType[],System.Int32] get_AnonRecordFieldDetails()
+FSharp.Compiler.Symbols.FSharpGenericParameter: Boolean Equals(System.Object)
+FSharp.Compiler.Symbols.FSharpGenericParameter: Boolean IsCompilerGenerated
+FSharp.Compiler.Symbols.FSharpGenericParameter: Boolean IsMeasure
+FSharp.Compiler.Symbols.FSharpGenericParameter: Boolean IsSolveAtCompileTime
+FSharp.Compiler.Symbols.FSharpGenericParameter: Boolean get_IsCompilerGenerated()
+FSharp.Compiler.Symbols.FSharpGenericParameter: Boolean get_IsMeasure()
+FSharp.Compiler.Symbols.FSharpGenericParameter: Boolean get_IsSolveAtCompileTime()
+FSharp.Compiler.Symbols.FSharpGenericParameter: FSharp.Compiler.Symbols.FSharpXmlDoc XmlDoc
+FSharp.Compiler.Symbols.FSharpGenericParameter: FSharp.Compiler.Symbols.FSharpXmlDoc get_XmlDoc()
+FSharp.Compiler.Symbols.FSharpGenericParameter: FSharp.Compiler.Text.Range DeclarationLocation
+FSharp.Compiler.Symbols.FSharpGenericParameter: FSharp.Compiler.Text.Range get_DeclarationLocation()
+FSharp.Compiler.Symbols.FSharpGenericParameter: Int32 GetHashCode()
+FSharp.Compiler.Symbols.FSharpGenericParameter: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAttribute] Attributes
+FSharp.Compiler.Symbols.FSharpGenericParameter: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAttribute] get_Attributes()
+FSharp.Compiler.Symbols.FSharpGenericParameter: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpGenericParameterConstraint] Constraints
+FSharp.Compiler.Symbols.FSharpGenericParameter: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpGenericParameterConstraint] get_Constraints()
+FSharp.Compiler.Symbols.FSharpGenericParameter: System.String Name
+FSharp.Compiler.Symbols.FSharpGenericParameter: System.String ToString()
+FSharp.Compiler.Symbols.FSharpGenericParameter: System.String get_Name()
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean IsCoercesToConstraint
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean IsComparisonConstraint
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean IsDefaultsToConstraint
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean IsDelegateConstraint
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean IsEnumConstraint
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean IsEqualityConstraint
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean IsMemberConstraint
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean IsNonNullableValueTypeConstraint
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean IsReferenceTypeConstraint
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean IsRequiresDefaultConstructorConstraint
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean IsSimpleChoiceConstraint
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean IsSupportsNullConstraint
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean IsUnmanagedConstraint
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean get_IsCoercesToConstraint()
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean get_IsComparisonConstraint()
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean get_IsDefaultsToConstraint()
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean get_IsDelegateConstraint()
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean get_IsEnumConstraint()
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean get_IsEqualityConstraint()
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean get_IsMemberConstraint()
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean get_IsNonNullableValueTypeConstraint()
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean get_IsReferenceTypeConstraint()
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean get_IsRequiresDefaultConstructorConstraint()
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean get_IsSimpleChoiceConstraint()
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean get_IsSupportsNullConstraint()
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: Boolean get_IsUnmanagedConstraint()
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: FSharp.Compiler.Symbols.FSharpGenericParameterDefaultsToConstraint DefaultsToConstraintData
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: FSharp.Compiler.Symbols.FSharpGenericParameterDefaultsToConstraint get_DefaultsToConstraintData()
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: FSharp.Compiler.Symbols.FSharpGenericParameterDelegateConstraint DelegateConstraintData
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: FSharp.Compiler.Symbols.FSharpGenericParameterDelegateConstraint get_DelegateConstraintData()
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: FSharp.Compiler.Symbols.FSharpGenericParameterMemberConstraint MemberConstraintData
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: FSharp.Compiler.Symbols.FSharpGenericParameterMemberConstraint get_MemberConstraintData()
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: FSharp.Compiler.Symbols.FSharpType CoercesToTarget
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: FSharp.Compiler.Symbols.FSharpType EnumConstraintTarget
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: FSharp.Compiler.Symbols.FSharpType get_CoercesToTarget()
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: FSharp.Compiler.Symbols.FSharpType get_EnumConstraintTarget()
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpType] SimpleChoices
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpType] get_SimpleChoices()
+FSharp.Compiler.Symbols.FSharpGenericParameterConstraint: System.String ToString()
+FSharp.Compiler.Symbols.FSharpGenericParameterDefaultsToConstraint: FSharp.Compiler.Symbols.FSharpType DefaultsToTarget
+FSharp.Compiler.Symbols.FSharpGenericParameterDefaultsToConstraint: FSharp.Compiler.Symbols.FSharpType get_DefaultsToTarget()
+FSharp.Compiler.Symbols.FSharpGenericParameterDefaultsToConstraint: Int32 DefaultsToPriority
+FSharp.Compiler.Symbols.FSharpGenericParameterDefaultsToConstraint: Int32 get_DefaultsToPriority()
+FSharp.Compiler.Symbols.FSharpGenericParameterDefaultsToConstraint: System.String ToString()
+FSharp.Compiler.Symbols.FSharpGenericParameterDelegateConstraint: FSharp.Compiler.Symbols.FSharpType DelegateReturnType
+FSharp.Compiler.Symbols.FSharpGenericParameterDelegateConstraint: FSharp.Compiler.Symbols.FSharpType DelegateTupledArgumentType
+FSharp.Compiler.Symbols.FSharpGenericParameterDelegateConstraint: FSharp.Compiler.Symbols.FSharpType get_DelegateReturnType()
+FSharp.Compiler.Symbols.FSharpGenericParameterDelegateConstraint: FSharp.Compiler.Symbols.FSharpType get_DelegateTupledArgumentType()
+FSharp.Compiler.Symbols.FSharpGenericParameterDelegateConstraint: System.String ToString()
+FSharp.Compiler.Symbols.FSharpGenericParameterMemberConstraint: Boolean MemberIsStatic
+FSharp.Compiler.Symbols.FSharpGenericParameterMemberConstraint: Boolean get_MemberIsStatic()
+FSharp.Compiler.Symbols.FSharpGenericParameterMemberConstraint: FSharp.Compiler.Symbols.FSharpType MemberReturnType
+FSharp.Compiler.Symbols.FSharpGenericParameterMemberConstraint: FSharp.Compiler.Symbols.FSharpType get_MemberReturnType()
+FSharp.Compiler.Symbols.FSharpGenericParameterMemberConstraint: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpType] MemberArgumentTypes
+FSharp.Compiler.Symbols.FSharpGenericParameterMemberConstraint: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpType] MemberSources
+FSharp.Compiler.Symbols.FSharpGenericParameterMemberConstraint: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpType] get_MemberArgumentTypes()
+FSharp.Compiler.Symbols.FSharpGenericParameterMemberConstraint: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpType] get_MemberSources()
+FSharp.Compiler.Symbols.FSharpGenericParameterMemberConstraint: System.String MemberName
+FSharp.Compiler.Symbols.FSharpGenericParameterMemberConstraint: System.String ToString()
+FSharp.Compiler.Symbols.FSharpGenericParameterMemberConstraint: System.String get_MemberName()
+FSharp.Compiler.Symbols.FSharpImplementationFileContents: Boolean HasExplicitEntryPoint
+FSharp.Compiler.Symbols.FSharpImplementationFileContents: Boolean IsScript
+FSharp.Compiler.Symbols.FSharpImplementationFileContents: Boolean get_HasExplicitEntryPoint()
+FSharp.Compiler.Symbols.FSharpImplementationFileContents: Boolean get_IsScript()
+FSharp.Compiler.Symbols.FSharpImplementationFileContents: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration] Declarations
+FSharp.Compiler.Symbols.FSharpImplementationFileContents: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration] get_Declarations()
+FSharp.Compiler.Symbols.FSharpImplementationFileContents: System.String FileName
+FSharp.Compiler.Symbols.FSharpImplementationFileContents: System.String QualifiedName
+FSharp.Compiler.Symbols.FSharpImplementationFileContents: System.String get_FileName()
+FSharp.Compiler.Symbols.FSharpImplementationFileContents: System.String get_QualifiedName()
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration+Entity: FSharp.Compiler.Symbols.FSharpEntity entity
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration+Entity: FSharp.Compiler.Symbols.FSharpEntity get_entity()
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration+Entity: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration] declarations
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration+Entity: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration] get_declarations()
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration+InitAction: FSharp.Compiler.Symbols.FSharpExpr action
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration+InitAction: FSharp.Compiler.Symbols.FSharpExpr get_action()
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration+MemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpExpr body
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration+MemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpExpr get_body()
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration+MemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue get_value()
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration+MemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue value
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration+MemberOrFunctionOrValue: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue]] curriedArgs
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration+MemberOrFunctionOrValue: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue]] get_curriedArgs()
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration+Tags: Int32 Entity
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration+Tags: Int32 InitAction
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration+Tags: Int32 MemberOrFunctionOrValue
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration: Boolean Equals(FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration)
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration: Boolean Equals(System.Object)
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration: Boolean IsEntity
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration: Boolean IsInitAction
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration: Boolean IsMemberOrFunctionOrValue
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration: Boolean get_IsEntity()
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration: Boolean get_IsInitAction()
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration: Boolean get_IsMemberOrFunctionOrValue()
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration: FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration NewEntity(FSharp.Compiler.Symbols.FSharpEntity, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration])
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration: FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration NewInitAction(FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration: FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration NewMemberOrFunctionOrValue(FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue]], FSharp.Compiler.Symbols.FSharpExpr)
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration: FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration+Entity
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration: FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration+InitAction
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration: FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration+MemberOrFunctionOrValue
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration: FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration+Tags
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration: Int32 GetHashCode()
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration: Int32 Tag
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration: Int32 get_Tag()
+FSharp.Compiler.Symbols.FSharpImplementationFileDeclaration: System.String ToString()
+FSharp.Compiler.Symbols.FSharpInlineAnnotation+Tags: Int32 AggressiveInline
+FSharp.Compiler.Symbols.FSharpInlineAnnotation+Tags: Int32 AlwaysInline
+FSharp.Compiler.Symbols.FSharpInlineAnnotation+Tags: Int32 NeverInline
+FSharp.Compiler.Symbols.FSharpInlineAnnotation+Tags: Int32 OptionalInline
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: Boolean Equals(FSharp.Compiler.Symbols.FSharpInlineAnnotation)
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: Boolean Equals(System.Object)
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: Boolean IsAggressiveInline
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: Boolean IsAlwaysInline
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: Boolean IsNeverInline
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: Boolean IsOptionalInline
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: Boolean get_IsAggressiveInline()
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: Boolean get_IsAlwaysInline()
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: Boolean get_IsNeverInline()
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: Boolean get_IsOptionalInline()
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: FSharp.Compiler.Symbols.FSharpInlineAnnotation AggressiveInline
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: FSharp.Compiler.Symbols.FSharpInlineAnnotation AlwaysInline
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: FSharp.Compiler.Symbols.FSharpInlineAnnotation NeverInline
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: FSharp.Compiler.Symbols.FSharpInlineAnnotation OptionalInline
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: FSharp.Compiler.Symbols.FSharpInlineAnnotation get_AggressiveInline()
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: FSharp.Compiler.Symbols.FSharpInlineAnnotation get_AlwaysInline()
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: FSharp.Compiler.Symbols.FSharpInlineAnnotation get_NeverInline()
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: FSharp.Compiler.Symbols.FSharpInlineAnnotation get_OptionalInline()
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: FSharp.Compiler.Symbols.FSharpInlineAnnotation+Tags
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: Int32 CompareTo(FSharp.Compiler.Symbols.FSharpInlineAnnotation)
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: Int32 CompareTo(System.Object)
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: Int32 GetHashCode()
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: Int32 Tag
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: Int32 get_Tag()
+FSharp.Compiler.Symbols.FSharpInlineAnnotation: System.String ToString()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean Equals(System.Object)
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean EventIsStandard
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean HasGetterMethod
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean HasSetterMethod
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean HasSignatureFile
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsActivePattern
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsBaseValue
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsCompilerGenerated
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsConstructor
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsConstructorThisValue
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsDispatchSlot
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsEvent
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsEventAddMethod
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsEventRemoveMethod
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsExplicitInterfaceImplementation
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsExtensionMember
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsFunction
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsImplicitConstructor
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsInstanceMember
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsInstanceMemberInCompiledCode
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsMember
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsMemberThisValue
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsMethod
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsModuleValueOrMember
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsMutable
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsOverrideOrExplicitInterfaceImplementation
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsProperty
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsPropertyGetterMethod
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsPropertySetterMethod
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsRefCell
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsTypeFunction
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsUnresolved
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsValCompiledAsMethod
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean IsValue
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_EventIsStandard()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_HasGetterMethod()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_HasSetterMethod()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_HasSignatureFile()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsActivePattern()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsBaseValue()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsCompilerGenerated()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsConstructor()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsConstructorThisValue()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsDispatchSlot()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsEvent()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsEventAddMethod()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsEventRemoveMethod()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsExplicitInterfaceImplementation()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsExtensionMember()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsFunction()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsImplicitConstructor()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsInstanceMember()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsInstanceMemberInCompiledCode()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsMember()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsMemberThisValue()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsMethod()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsModuleValueOrMember()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsMutable()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsOverrideOrExplicitInterfaceImplementation()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsProperty()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsPropertyGetterMethod()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsPropertySetterMethod()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsRefCell()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsTypeFunction()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsUnresolved()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsValCompiledAsMethod()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Boolean get_IsValue()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpAccessibility Accessibility
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpAccessibility get_Accessibility()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpEntity ApparentEnclosingEntity
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpEntity get_ApparentEnclosingEntity()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpInlineAnnotation InlineAnnotation
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpInlineAnnotation get_InlineAnnotation()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue EventAddMethod
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue EventRemoveMethod
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue GetterMethod
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue SetterMethod
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue get_EventAddMethod()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue get_EventRemoveMethod()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue get_GetterMethod()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue get_SetterMethod()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpParameter ReturnParameter
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpParameter get_ReturnParameter()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpType EventDelegateType
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpType FullType
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpType get_EventDelegateType()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpType get_FullType()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpXmlDoc XmlDoc
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: FSharp.Compiler.Symbols.FSharpXmlDoc get_XmlDoc()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: FSharp.Compiler.Text.Range DeclarationLocation
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: FSharp.Compiler.Text.Range get_DeclarationLocation()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: FSharp.Compiler.Text.TaggedText[] FormatLayout(FSharp.Compiler.Symbols.FSharpDisplayContext)
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Int32 GetHashCode()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpEntity] DeclaringEntity
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpEntity] get_DeclaringEntity()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue] EventForFSharpProperty
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue] get_EventForFSharpProperty()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpType] FullTypeSafe
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpType] get_FullTypeSafe()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.TaggedText[]] GetReturnTypeLayout(FSharp.Compiler.Symbols.FSharpDisplayContext)
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Microsoft.FSharp.Core.FSharpOption`1[System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue]] GetOverloads(Boolean)
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Microsoft.FSharp.Core.FSharpOption`1[System.Object] LiteralValue
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Microsoft.FSharp.Core.FSharpOption`1[System.Object] get_LiteralValue()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Microsoft.FSharp.Core.FSharpOption`1[System.String[]] TryGetFullCompiledOperatorNameIdents()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Microsoft.FSharp.Core.FSharpOption`1[System.String] TryGetFullDisplayName()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.String,System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpParameter]]] GetWitnessPassingInfo()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAbstractSignature] ImplementedAbstractSignatures
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAbstractSignature] get_ImplementedAbstractSignatures()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAttribute] Attributes
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAttribute] get_Attributes()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpGenericParameter] GenericParameters
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpGenericParameter] get_GenericParameters()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: System.Collections.Generic.IList`1[System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpParameter]] CurriedParameterGroups
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: System.Collections.Generic.IList`1[System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpParameter]] get_CurriedParameterGroups()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: System.String CompiledName
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: System.String DisplayName
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: System.String LogicalName
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: System.String ToString()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: System.String XmlDocSig
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: System.String get_CompiledName()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: System.String get_DisplayName()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: System.String get_LogicalName()
+FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue: System.String get_XmlDocSig()
+FSharp.Compiler.Symbols.FSharpObjectExprOverride: FSharp.Compiler.Symbols.FSharpAbstractSignature Signature
+FSharp.Compiler.Symbols.FSharpObjectExprOverride: FSharp.Compiler.Symbols.FSharpAbstractSignature get_Signature()
+FSharp.Compiler.Symbols.FSharpObjectExprOverride: FSharp.Compiler.Symbols.FSharpExpr Body
+FSharp.Compiler.Symbols.FSharpObjectExprOverride: FSharp.Compiler.Symbols.FSharpExpr get_Body()
+FSharp.Compiler.Symbols.FSharpObjectExprOverride: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpGenericParameter] GenericParameters
+FSharp.Compiler.Symbols.FSharpObjectExprOverride: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpGenericParameter] get_GenericParameters()
+FSharp.Compiler.Symbols.FSharpObjectExprOverride: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue]] CurriedParameterGroups
+FSharp.Compiler.Symbols.FSharpObjectExprOverride: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue]] get_CurriedParameterGroups()
+FSharp.Compiler.Symbols.FSharpOpenDeclaration: Boolean IsOwnNamespace
+FSharp.Compiler.Symbols.FSharpOpenDeclaration: Boolean get_IsOwnNamespace()
+FSharp.Compiler.Symbols.FSharpOpenDeclaration: FSharp.Compiler.Syntax.SynOpenDeclTarget Target
+FSharp.Compiler.Symbols.FSharpOpenDeclaration: FSharp.Compiler.Syntax.SynOpenDeclTarget get_Target()
+FSharp.Compiler.Symbols.FSharpOpenDeclaration: FSharp.Compiler.Text.Range AppliedScope
+FSharp.Compiler.Symbols.FSharpOpenDeclaration: FSharp.Compiler.Text.Range get_AppliedScope()
+FSharp.Compiler.Symbols.FSharpOpenDeclaration: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpEntity] Modules
+FSharp.Compiler.Symbols.FSharpOpenDeclaration: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpEntity] get_Modules()
+FSharp.Compiler.Symbols.FSharpOpenDeclaration: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpType] Types
+FSharp.Compiler.Symbols.FSharpOpenDeclaration: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Symbols.FSharpType] get_Types()
+FSharp.Compiler.Symbols.FSharpOpenDeclaration: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] LongId
+FSharp.Compiler.Symbols.FSharpOpenDeclaration: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] get_LongId()
+FSharp.Compiler.Symbols.FSharpOpenDeclaration: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] Range
+FSharp.Compiler.Symbols.FSharpOpenDeclaration: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_Range()
+FSharp.Compiler.Symbols.FSharpParameter: Boolean Equals(System.Object)
+FSharp.Compiler.Symbols.FSharpParameter: Boolean IsInArg
+FSharp.Compiler.Symbols.FSharpParameter: Boolean IsOptionalArg
+FSharp.Compiler.Symbols.FSharpParameter: Boolean IsOutArg
+FSharp.Compiler.Symbols.FSharpParameter: Boolean IsParamArrayArg
+FSharp.Compiler.Symbols.FSharpParameter: Boolean get_IsInArg()
+FSharp.Compiler.Symbols.FSharpParameter: Boolean get_IsOptionalArg()
+FSharp.Compiler.Symbols.FSharpParameter: Boolean get_IsOutArg()
+FSharp.Compiler.Symbols.FSharpParameter: Boolean get_IsParamArrayArg()
+FSharp.Compiler.Symbols.FSharpParameter: FSharp.Compiler.Symbols.FSharpType Type
+FSharp.Compiler.Symbols.FSharpParameter: FSharp.Compiler.Symbols.FSharpType get_Type()
+FSharp.Compiler.Symbols.FSharpParameter: FSharp.Compiler.Text.Range DeclarationLocation
+FSharp.Compiler.Symbols.FSharpParameter: FSharp.Compiler.Text.Range get_DeclarationLocation()
+FSharp.Compiler.Symbols.FSharpParameter: Int32 GetHashCode()
+FSharp.Compiler.Symbols.FSharpParameter: Microsoft.FSharp.Core.FSharpOption`1[System.String] Name
+FSharp.Compiler.Symbols.FSharpParameter: Microsoft.FSharp.Core.FSharpOption`1[System.String] get_Name()
+FSharp.Compiler.Symbols.FSharpParameter: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAttribute] Attributes
+FSharp.Compiler.Symbols.FSharpParameter: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAttribute] get_Attributes()
+FSharp.Compiler.Symbols.FSharpParameter: System.String ToString()
+FSharp.Compiler.Symbols.FSharpStaticParameter: Boolean Equals(System.Object)
+FSharp.Compiler.Symbols.FSharpStaticParameter: Boolean HasDefaultValue
+FSharp.Compiler.Symbols.FSharpStaticParameter: Boolean IsOptional
+FSharp.Compiler.Symbols.FSharpStaticParameter: Boolean get_HasDefaultValue()
+FSharp.Compiler.Symbols.FSharpStaticParameter: Boolean get_IsOptional()
+FSharp.Compiler.Symbols.FSharpStaticParameter: FSharp.Compiler.Symbols.FSharpType Kind
+FSharp.Compiler.Symbols.FSharpStaticParameter: FSharp.Compiler.Symbols.FSharpType get_Kind()
+FSharp.Compiler.Symbols.FSharpStaticParameter: FSharp.Compiler.Text.Range DeclarationLocation
+FSharp.Compiler.Symbols.FSharpStaticParameter: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Symbols.FSharpStaticParameter: FSharp.Compiler.Text.Range get_DeclarationLocation()
+FSharp.Compiler.Symbols.FSharpStaticParameter: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Symbols.FSharpStaticParameter: Int32 GetHashCode()
+FSharp.Compiler.Symbols.FSharpStaticParameter: System.Object DefaultValue
+FSharp.Compiler.Symbols.FSharpStaticParameter: System.Object get_DefaultValue()
+FSharp.Compiler.Symbols.FSharpStaticParameter: System.String Name
+FSharp.Compiler.Symbols.FSharpStaticParameter: System.String ToString()
+FSharp.Compiler.Symbols.FSharpStaticParameter: System.String get_Name()
+FSharp.Compiler.Symbols.FSharpSymbol: Boolean Equals(System.Object)
+FSharp.Compiler.Symbols.FSharpSymbol: Boolean HasAttribute[T]()
+FSharp.Compiler.Symbols.FSharpSymbol: Boolean IsAccessible(FSharp.Compiler.Symbols.FSharpAccessibilityRights)
+FSharp.Compiler.Symbols.FSharpSymbol: Boolean IsEffectivelySameAs(FSharp.Compiler.Symbols.FSharpSymbol)
+FSharp.Compiler.Symbols.FSharpSymbol: Boolean IsExplicitlySuppressed
+FSharp.Compiler.Symbols.FSharpSymbol: Boolean get_IsExplicitlySuppressed()
+FSharp.Compiler.Symbols.FSharpSymbol: FSharp.Compiler.Symbols.FSharpAccessibility Accessibility
+FSharp.Compiler.Symbols.FSharpSymbol: FSharp.Compiler.Symbols.FSharpAccessibility get_Accessibility()
+FSharp.Compiler.Symbols.FSharpSymbol: FSharp.Compiler.Symbols.FSharpAssembly Assembly
+FSharp.Compiler.Symbols.FSharpSymbol: FSharp.Compiler.Symbols.FSharpAssembly get_Assembly()
+FSharp.Compiler.Symbols.FSharpSymbol: Int32 GetEffectivelySameAsHash()
+FSharp.Compiler.Symbols.FSharpSymbol: Int32 GetHashCode()
+FSharp.Compiler.Symbols.FSharpSymbol: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpAttribute] TryGetAttribute[T]()
+FSharp.Compiler.Symbols.FSharpSymbol: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] DeclarationLocation
+FSharp.Compiler.Symbols.FSharpSymbol: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] ImplementationLocation
+FSharp.Compiler.Symbols.FSharpSymbol: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] SignatureLocation
+FSharp.Compiler.Symbols.FSharpSymbol: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_DeclarationLocation()
+FSharp.Compiler.Symbols.FSharpSymbol: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_ImplementationLocation()
+FSharp.Compiler.Symbols.FSharpSymbol: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_SignatureLocation()
+FSharp.Compiler.Symbols.FSharpSymbol: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAttribute] Attributes
+FSharp.Compiler.Symbols.FSharpSymbol: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAttribute] get_Attributes()
+FSharp.Compiler.Symbols.FSharpSymbol: System.String DisplayName
+FSharp.Compiler.Symbols.FSharpSymbol: System.String DisplayNameCore
+FSharp.Compiler.Symbols.FSharpSymbol: System.String FullName
+FSharp.Compiler.Symbols.FSharpSymbol: System.String ToString()
+FSharp.Compiler.Symbols.FSharpSymbol: System.String get_DisplayName()
+FSharp.Compiler.Symbols.FSharpSymbol: System.String get_DisplayNameCore()
+FSharp.Compiler.Symbols.FSharpSymbol: System.String get_FullName()
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpActivePatternCase] |ActivePatternCase|_|(FSharp.Compiler.Symbols.FSharpSymbol)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpEntity] |Constructor|_|(FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpEntity] |TypeWithDefinition|_|(FSharp.Compiler.Symbols.FSharpType)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpField] |RecordField|_|(FSharp.Compiler.Symbols.FSharpSymbol)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue] |MemberFunctionOrValue|_|(FSharp.Compiler.Symbols.FSharpSymbol)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpType] |AbbreviatedType|_|(FSharp.Compiler.Symbols.FSharpEntity)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpUnionCase] |UnionCase|_|(FSharp.Compiler.Symbols.FSharpSymbol)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |AbstractClass|_|(FSharp.Compiler.Symbols.FSharpEntity)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |Array|_|(FSharp.Compiler.Symbols.FSharpEntity)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |Attribute|_|(FSharp.Compiler.Symbols.FSharpEntity)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |ByRef|_|(FSharp.Compiler.Symbols.FSharpEntity)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |Class|_|[a](FSharp.Compiler.Symbols.FSharpEntity, FSharp.Compiler.Symbols.FSharpEntity, a)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |Delegate|_|(FSharp.Compiler.Symbols.FSharpEntity)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |Enum|_|(FSharp.Compiler.Symbols.FSharpEntity)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |Event|_|(FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |ExtensionMember|_|(FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |FSharpException|_|(FSharp.Compiler.Symbols.FSharpEntity)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |FSharpModule|_|(FSharp.Compiler.Symbols.FSharpEntity)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |FSharpType|_|(FSharp.Compiler.Symbols.FSharpEntity)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |FunctionType|_|(FSharp.Compiler.Symbols.FSharpType)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |Function|_|(Boolean, FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |Interface|_|(FSharp.Compiler.Symbols.FSharpEntity)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |MutableVar|_|(FSharp.Compiler.Symbols.FSharpSymbol)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |Namespace|_|(FSharp.Compiler.Symbols.FSharpEntity)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |Parameter|_|(FSharp.Compiler.Symbols.FSharpSymbol)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |Pattern|_|(FSharp.Compiler.Symbols.FSharpSymbol)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |ProvidedAndErasedType|_|(FSharp.Compiler.Symbols.FSharpEntity)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |ProvidedType|_|(FSharp.Compiler.Symbols.FSharpEntity)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |Record|_|(FSharp.Compiler.Symbols.FSharpEntity)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |RefCell|_|(FSharp.Compiler.Symbols.FSharpType)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |Tuple|_|(FSharp.Compiler.Symbols.FSharpType)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |UnionType|_|(FSharp.Compiler.Symbols.FSharpEntity)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] |ValueType|_|(FSharp.Compiler.Symbols.FSharpEntity)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpField,FSharp.Compiler.Symbols.FSharpType]] |Field|_|(FSharp.Compiler.Symbols.FSharpSymbol)
+FSharp.Compiler.Symbols.FSharpSymbolPatterns: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[FSharp.Compiler.Symbols.FSharpEntity,FSharp.Compiler.Symbols.FSharpEntity,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpType]]] |FSharpEntity|_|(FSharp.Compiler.Symbols.FSharpSymbol)
+FSharp.Compiler.Symbols.FSharpType: Boolean Equals(System.Object)
+FSharp.Compiler.Symbols.FSharpType: Boolean HasTypeDefinition
+FSharp.Compiler.Symbols.FSharpType: Boolean IsAbbreviation
+FSharp.Compiler.Symbols.FSharpType: Boolean IsAnonRecordType
+FSharp.Compiler.Symbols.FSharpType: Boolean IsFunctionType
+FSharp.Compiler.Symbols.FSharpType: Boolean IsGenericParameter
+FSharp.Compiler.Symbols.FSharpType: Boolean IsStructTupleType
+FSharp.Compiler.Symbols.FSharpType: Boolean IsTupleType
+FSharp.Compiler.Symbols.FSharpType: Boolean IsUnresolved
+FSharp.Compiler.Symbols.FSharpType: Boolean get_HasTypeDefinition()
+FSharp.Compiler.Symbols.FSharpType: Boolean get_IsAbbreviation()
+FSharp.Compiler.Symbols.FSharpType: Boolean get_IsAnonRecordType()
+FSharp.Compiler.Symbols.FSharpType: Boolean get_IsFunctionType()
+FSharp.Compiler.Symbols.FSharpType: Boolean get_IsGenericParameter()
+FSharp.Compiler.Symbols.FSharpType: Boolean get_IsStructTupleType()
+FSharp.Compiler.Symbols.FSharpType: Boolean get_IsTupleType()
+FSharp.Compiler.Symbols.FSharpType: Boolean get_IsUnresolved()
+FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Symbols.FSharpAnonRecordTypeDetails AnonRecordTypeDetails
+FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Symbols.FSharpAnonRecordTypeDetails get_AnonRecordTypeDetails()
+FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Symbols.FSharpEntity TypeDefinition
+FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Symbols.FSharpEntity get_TypeDefinition()
+FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Symbols.FSharpGenericParameter GenericParameter
+FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Symbols.FSharpGenericParameter get_GenericParameter()
+FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Symbols.FSharpParameter Prettify(FSharp.Compiler.Symbols.FSharpParameter)
+FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Symbols.FSharpType AbbreviatedType
+FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Symbols.FSharpType ErasedType
+FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Symbols.FSharpType Instantiate(Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[FSharp.Compiler.Symbols.FSharpGenericParameter,FSharp.Compiler.Symbols.FSharpType]])
+FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Symbols.FSharpType Prettify(FSharp.Compiler.Symbols.FSharpType)
+FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Symbols.FSharpType StripAbbreviations()
+FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Symbols.FSharpType get_AbbreviatedType()
+FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Symbols.FSharpType get_ErasedType()
+FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Text.TaggedText[] FormatLayout(FSharp.Compiler.Symbols.FSharpDisplayContext)
+FSharp.Compiler.Symbols.FSharpType: FSharp.Compiler.Text.TaggedText[] FormatLayoutWithConstraints(FSharp.Compiler.Symbols.FSharpDisplayContext)
+FSharp.Compiler.Symbols.FSharpType: Int32 GetHashCode()
+FSharp.Compiler.Symbols.FSharpType: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpType] BaseType
+FSharp.Compiler.Symbols.FSharpType: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Symbols.FSharpType] get_BaseType()
+FSharp.Compiler.Symbols.FSharpType: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpParameter] Prettify(System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpParameter])
+FSharp.Compiler.Symbols.FSharpType: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpType] AllInterfaces
+FSharp.Compiler.Symbols.FSharpType: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpType] GenericArguments
+FSharp.Compiler.Symbols.FSharpType: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpType] Prettify(System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpType])
+FSharp.Compiler.Symbols.FSharpType: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpType] get_AllInterfaces()
+FSharp.Compiler.Symbols.FSharpType: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpType] get_GenericArguments()
+FSharp.Compiler.Symbols.FSharpType: System.Collections.Generic.IList`1[System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpParameter]] Prettify(System.Collections.Generic.IList`1[System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpParameter]])
+FSharp.Compiler.Symbols.FSharpType: System.String BasicQualifiedName
+FSharp.Compiler.Symbols.FSharpType: System.String Format(FSharp.Compiler.Symbols.FSharpDisplayContext)
+FSharp.Compiler.Symbols.FSharpType: System.String FormatWithConstraints(FSharp.Compiler.Symbols.FSharpDisplayContext)
+FSharp.Compiler.Symbols.FSharpType: System.String ToString()
+FSharp.Compiler.Symbols.FSharpType: System.String get_BasicQualifiedName()
+FSharp.Compiler.Symbols.FSharpType: System.Tuple`2[System.Collections.Generic.IList`1[System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpParameter]],FSharp.Compiler.Symbols.FSharpParameter] Prettify(System.Collections.Generic.IList`1[System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpParameter]], FSharp.Compiler.Symbols.FSharpParameter)
+FSharp.Compiler.Symbols.FSharpUnionCase: Boolean Equals(System.Object)
+FSharp.Compiler.Symbols.FSharpUnionCase: Boolean HasFields
+FSharp.Compiler.Symbols.FSharpUnionCase: Boolean IsUnresolved
+FSharp.Compiler.Symbols.FSharpUnionCase: Boolean get_HasFields()
+FSharp.Compiler.Symbols.FSharpUnionCase: Boolean get_IsUnresolved()
+FSharp.Compiler.Symbols.FSharpUnionCase: FSharp.Compiler.Symbols.FSharpAccessibility Accessibility
+FSharp.Compiler.Symbols.FSharpUnionCase: FSharp.Compiler.Symbols.FSharpAccessibility get_Accessibility()
+FSharp.Compiler.Symbols.FSharpUnionCase: FSharp.Compiler.Symbols.FSharpType ReturnType
+FSharp.Compiler.Symbols.FSharpUnionCase: FSharp.Compiler.Symbols.FSharpType get_ReturnType()
+FSharp.Compiler.Symbols.FSharpUnionCase: FSharp.Compiler.Symbols.FSharpXmlDoc XmlDoc
+FSharp.Compiler.Symbols.FSharpUnionCase: FSharp.Compiler.Symbols.FSharpXmlDoc get_XmlDoc()
+FSharp.Compiler.Symbols.FSharpUnionCase: FSharp.Compiler.Text.Range DeclarationLocation
+FSharp.Compiler.Symbols.FSharpUnionCase: FSharp.Compiler.Text.Range get_DeclarationLocation()
+FSharp.Compiler.Symbols.FSharpUnionCase: Int32 GetHashCode()
+FSharp.Compiler.Symbols.FSharpUnionCase: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAttribute] Attributes
+FSharp.Compiler.Symbols.FSharpUnionCase: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpAttribute] get_Attributes()
+FSharp.Compiler.Symbols.FSharpUnionCase: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpField] Fields
+FSharp.Compiler.Symbols.FSharpUnionCase: System.Collections.Generic.IList`1[FSharp.Compiler.Symbols.FSharpField] get_Fields()
+FSharp.Compiler.Symbols.FSharpUnionCase: System.String CompiledName
+FSharp.Compiler.Symbols.FSharpUnionCase: System.String Name
+FSharp.Compiler.Symbols.FSharpUnionCase: System.String ToString()
+FSharp.Compiler.Symbols.FSharpUnionCase: System.String XmlDocSig
+FSharp.Compiler.Symbols.FSharpUnionCase: System.String get_CompiledName()
+FSharp.Compiler.Symbols.FSharpUnionCase: System.String get_Name()
+FSharp.Compiler.Symbols.FSharpUnionCase: System.String get_XmlDocSig()
+FSharp.Compiler.Symbols.FSharpXmlDoc+FromXmlFile: System.String dllName
+FSharp.Compiler.Symbols.FSharpXmlDoc+FromXmlFile: System.String get_dllName()
+FSharp.Compiler.Symbols.FSharpXmlDoc+FromXmlFile: System.String get_xmlSig()
+FSharp.Compiler.Symbols.FSharpXmlDoc+FromXmlFile: System.String xmlSig
+FSharp.Compiler.Symbols.FSharpXmlDoc+FromXmlText: FSharp.Compiler.Xml.XmlDoc Item
+FSharp.Compiler.Symbols.FSharpXmlDoc+FromXmlText: FSharp.Compiler.Xml.XmlDoc get_Item()
+FSharp.Compiler.Symbols.FSharpXmlDoc+Tags: Int32 FromXmlFile
+FSharp.Compiler.Symbols.FSharpXmlDoc+Tags: Int32 FromXmlText
+FSharp.Compiler.Symbols.FSharpXmlDoc+Tags: Int32 None
+FSharp.Compiler.Symbols.FSharpXmlDoc: Boolean Equals(FSharp.Compiler.Symbols.FSharpXmlDoc)
+FSharp.Compiler.Symbols.FSharpXmlDoc: Boolean Equals(System.Object)
+FSharp.Compiler.Symbols.FSharpXmlDoc: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Symbols.FSharpXmlDoc: Boolean IsFromXmlFile
+FSharp.Compiler.Symbols.FSharpXmlDoc: Boolean IsFromXmlText
+FSharp.Compiler.Symbols.FSharpXmlDoc: Boolean IsNone
+FSharp.Compiler.Symbols.FSharpXmlDoc: Boolean get_IsFromXmlFile()
+FSharp.Compiler.Symbols.FSharpXmlDoc: Boolean get_IsFromXmlText()
+FSharp.Compiler.Symbols.FSharpXmlDoc: Boolean get_IsNone()
+FSharp.Compiler.Symbols.FSharpXmlDoc: FSharp.Compiler.Symbols.FSharpXmlDoc NewFromXmlFile(System.String, System.String)
+FSharp.Compiler.Symbols.FSharpXmlDoc: FSharp.Compiler.Symbols.FSharpXmlDoc NewFromXmlText(FSharp.Compiler.Xml.XmlDoc)
+FSharp.Compiler.Symbols.FSharpXmlDoc: FSharp.Compiler.Symbols.FSharpXmlDoc None
+FSharp.Compiler.Symbols.FSharpXmlDoc: FSharp.Compiler.Symbols.FSharpXmlDoc get_None()
+FSharp.Compiler.Symbols.FSharpXmlDoc: FSharp.Compiler.Symbols.FSharpXmlDoc+FromXmlFile
+FSharp.Compiler.Symbols.FSharpXmlDoc: FSharp.Compiler.Symbols.FSharpXmlDoc+FromXmlText
+FSharp.Compiler.Symbols.FSharpXmlDoc: FSharp.Compiler.Symbols.FSharpXmlDoc+Tags
+FSharp.Compiler.Symbols.FSharpXmlDoc: Int32 GetHashCode()
+FSharp.Compiler.Symbols.FSharpXmlDoc: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Symbols.FSharpXmlDoc: Int32 Tag
+FSharp.Compiler.Symbols.FSharpXmlDoc: Int32 get_Tag()
+FSharp.Compiler.Symbols.FSharpXmlDoc: System.String ToString()
+FSharp.Compiler.Syntax.DebugPointAtBinding+Tags: Int32 NoneAtDo
+FSharp.Compiler.Syntax.DebugPointAtBinding+Tags: Int32 NoneAtInvisible
+FSharp.Compiler.Syntax.DebugPointAtBinding+Tags: Int32 NoneAtLet
+FSharp.Compiler.Syntax.DebugPointAtBinding+Tags: Int32 NoneAtSticky
+FSharp.Compiler.Syntax.DebugPointAtBinding+Tags: Int32 Yes
+FSharp.Compiler.Syntax.DebugPointAtBinding+Yes: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.DebugPointAtBinding+Yes: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.DebugPointAtBinding: Boolean Equals(FSharp.Compiler.Syntax.DebugPointAtBinding)
+FSharp.Compiler.Syntax.DebugPointAtBinding: Boolean Equals(System.Object)
+FSharp.Compiler.Syntax.DebugPointAtBinding: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.DebugPointAtBinding: Boolean IsNoneAtDo
+FSharp.Compiler.Syntax.DebugPointAtBinding: Boolean IsNoneAtInvisible
+FSharp.Compiler.Syntax.DebugPointAtBinding: Boolean IsNoneAtLet
+FSharp.Compiler.Syntax.DebugPointAtBinding: Boolean IsNoneAtSticky
+FSharp.Compiler.Syntax.DebugPointAtBinding: Boolean IsYes
+FSharp.Compiler.Syntax.DebugPointAtBinding: Boolean get_IsNoneAtDo()
+FSharp.Compiler.Syntax.DebugPointAtBinding: Boolean get_IsNoneAtInvisible()
+FSharp.Compiler.Syntax.DebugPointAtBinding: Boolean get_IsNoneAtLet()
+FSharp.Compiler.Syntax.DebugPointAtBinding: Boolean get_IsNoneAtSticky()
+FSharp.Compiler.Syntax.DebugPointAtBinding: Boolean get_IsYes()
+FSharp.Compiler.Syntax.DebugPointAtBinding: FSharp.Compiler.Syntax.DebugPointAtBinding Combine(FSharp.Compiler.Syntax.DebugPointAtBinding)
+FSharp.Compiler.Syntax.DebugPointAtBinding: FSharp.Compiler.Syntax.DebugPointAtBinding NewYes(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.DebugPointAtBinding: FSharp.Compiler.Syntax.DebugPointAtBinding NoneAtDo
+FSharp.Compiler.Syntax.DebugPointAtBinding: FSharp.Compiler.Syntax.DebugPointAtBinding NoneAtInvisible
+FSharp.Compiler.Syntax.DebugPointAtBinding: FSharp.Compiler.Syntax.DebugPointAtBinding NoneAtLet
+FSharp.Compiler.Syntax.DebugPointAtBinding: FSharp.Compiler.Syntax.DebugPointAtBinding NoneAtSticky
+FSharp.Compiler.Syntax.DebugPointAtBinding: FSharp.Compiler.Syntax.DebugPointAtBinding get_NoneAtDo()
+FSharp.Compiler.Syntax.DebugPointAtBinding: FSharp.Compiler.Syntax.DebugPointAtBinding get_NoneAtInvisible()
+FSharp.Compiler.Syntax.DebugPointAtBinding: FSharp.Compiler.Syntax.DebugPointAtBinding get_NoneAtLet()
+FSharp.Compiler.Syntax.DebugPointAtBinding: FSharp.Compiler.Syntax.DebugPointAtBinding get_NoneAtSticky()
+FSharp.Compiler.Syntax.DebugPointAtBinding: FSharp.Compiler.Syntax.DebugPointAtBinding+Tags
+FSharp.Compiler.Syntax.DebugPointAtBinding: FSharp.Compiler.Syntax.DebugPointAtBinding+Yes
+FSharp.Compiler.Syntax.DebugPointAtBinding: Int32 GetHashCode()
+FSharp.Compiler.Syntax.DebugPointAtBinding: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.DebugPointAtBinding: Int32 Tag
+FSharp.Compiler.Syntax.DebugPointAtBinding: Int32 get_Tag()
+FSharp.Compiler.Syntax.DebugPointAtBinding: System.String ToString()
+FSharp.Compiler.Syntax.DebugPointAtFinally+Tags: Int32 No
+FSharp.Compiler.Syntax.DebugPointAtFinally+Tags: Int32 Yes
+FSharp.Compiler.Syntax.DebugPointAtFinally+Yes: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.DebugPointAtFinally+Yes: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.DebugPointAtFinally: Boolean Equals(FSharp.Compiler.Syntax.DebugPointAtFinally)
+FSharp.Compiler.Syntax.DebugPointAtFinally: Boolean Equals(System.Object)
+FSharp.Compiler.Syntax.DebugPointAtFinally: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.DebugPointAtFinally: Boolean IsNo
+FSharp.Compiler.Syntax.DebugPointAtFinally: Boolean IsYes
+FSharp.Compiler.Syntax.DebugPointAtFinally: Boolean get_IsNo()
+FSharp.Compiler.Syntax.DebugPointAtFinally: Boolean get_IsYes()
+FSharp.Compiler.Syntax.DebugPointAtFinally: FSharp.Compiler.Syntax.DebugPointAtFinally NewYes(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.DebugPointAtFinally: FSharp.Compiler.Syntax.DebugPointAtFinally No
+FSharp.Compiler.Syntax.DebugPointAtFinally: FSharp.Compiler.Syntax.DebugPointAtFinally get_No()
+FSharp.Compiler.Syntax.DebugPointAtFinally: FSharp.Compiler.Syntax.DebugPointAtFinally+Tags
+FSharp.Compiler.Syntax.DebugPointAtFinally: FSharp.Compiler.Syntax.DebugPointAtFinally+Yes
+FSharp.Compiler.Syntax.DebugPointAtFinally: Int32 GetHashCode()
+FSharp.Compiler.Syntax.DebugPointAtFinally: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.DebugPointAtFinally: Int32 Tag
+FSharp.Compiler.Syntax.DebugPointAtFinally: Int32 get_Tag()
+FSharp.Compiler.Syntax.DebugPointAtFinally: System.String ToString()
+FSharp.Compiler.Syntax.DebugPointAtFor+Tags: Int32 No
+FSharp.Compiler.Syntax.DebugPointAtFor+Tags: Int32 Yes
+FSharp.Compiler.Syntax.DebugPointAtFor+Yes: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.DebugPointAtFor+Yes: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.DebugPointAtFor: Boolean Equals(FSharp.Compiler.Syntax.DebugPointAtFor)
+FSharp.Compiler.Syntax.DebugPointAtFor: Boolean Equals(System.Object)
+FSharp.Compiler.Syntax.DebugPointAtFor: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.DebugPointAtFor: Boolean IsNo
+FSharp.Compiler.Syntax.DebugPointAtFor: Boolean IsYes
+FSharp.Compiler.Syntax.DebugPointAtFor: Boolean get_IsNo()
+FSharp.Compiler.Syntax.DebugPointAtFor: Boolean get_IsYes()
+FSharp.Compiler.Syntax.DebugPointAtFor: FSharp.Compiler.Syntax.DebugPointAtFor NewYes(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.DebugPointAtFor: FSharp.Compiler.Syntax.DebugPointAtFor No
+FSharp.Compiler.Syntax.DebugPointAtFor: FSharp.Compiler.Syntax.DebugPointAtFor get_No()
+FSharp.Compiler.Syntax.DebugPointAtFor: FSharp.Compiler.Syntax.DebugPointAtFor+Tags
+FSharp.Compiler.Syntax.DebugPointAtFor: FSharp.Compiler.Syntax.DebugPointAtFor+Yes
+FSharp.Compiler.Syntax.DebugPointAtFor: Int32 GetHashCode()
+FSharp.Compiler.Syntax.DebugPointAtFor: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.DebugPointAtFor: Int32 Tag
+FSharp.Compiler.Syntax.DebugPointAtFor: Int32 get_Tag()
+FSharp.Compiler.Syntax.DebugPointAtFor: System.String ToString()
+FSharp.Compiler.Syntax.DebugPointAtInOrTo+Tags: Int32 No
+FSharp.Compiler.Syntax.DebugPointAtInOrTo+Tags: Int32 Yes
+FSharp.Compiler.Syntax.DebugPointAtInOrTo+Yes: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.DebugPointAtInOrTo+Yes: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.DebugPointAtInOrTo: Boolean Equals(FSharp.Compiler.Syntax.DebugPointAtInOrTo)
+FSharp.Compiler.Syntax.DebugPointAtInOrTo: Boolean Equals(System.Object)
+FSharp.Compiler.Syntax.DebugPointAtInOrTo: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.DebugPointAtInOrTo: Boolean IsNo
+FSharp.Compiler.Syntax.DebugPointAtInOrTo: Boolean IsYes
+FSharp.Compiler.Syntax.DebugPointAtInOrTo: Boolean get_IsNo()
+FSharp.Compiler.Syntax.DebugPointAtInOrTo: Boolean get_IsYes()
+FSharp.Compiler.Syntax.DebugPointAtInOrTo: FSharp.Compiler.Syntax.DebugPointAtInOrTo NewYes(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.DebugPointAtInOrTo: FSharp.Compiler.Syntax.DebugPointAtInOrTo No
+FSharp.Compiler.Syntax.DebugPointAtInOrTo: FSharp.Compiler.Syntax.DebugPointAtInOrTo get_No()
+FSharp.Compiler.Syntax.DebugPointAtInOrTo: FSharp.Compiler.Syntax.DebugPointAtInOrTo+Tags
+FSharp.Compiler.Syntax.DebugPointAtInOrTo: FSharp.Compiler.Syntax.DebugPointAtInOrTo+Yes
+FSharp.Compiler.Syntax.DebugPointAtInOrTo: Int32 GetHashCode()
+FSharp.Compiler.Syntax.DebugPointAtInOrTo: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.DebugPointAtInOrTo: Int32 Tag
+FSharp.Compiler.Syntax.DebugPointAtInOrTo: Int32 get_Tag()
+FSharp.Compiler.Syntax.DebugPointAtInOrTo: System.String ToString()
+FSharp.Compiler.Syntax.DebugPointAtLeafExpr: Boolean Equals(FSharp.Compiler.Syntax.DebugPointAtLeafExpr)
+FSharp.Compiler.Syntax.DebugPointAtLeafExpr: Boolean Equals(System.Object)
+FSharp.Compiler.Syntax.DebugPointAtLeafExpr: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.DebugPointAtLeafExpr: FSharp.Compiler.Syntax.DebugPointAtLeafExpr NewYes(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.DebugPointAtLeafExpr: FSharp.Compiler.Text.Range Item
+FSharp.Compiler.Syntax.DebugPointAtLeafExpr: FSharp.Compiler.Text.Range get_Item()
+FSharp.Compiler.Syntax.DebugPointAtLeafExpr: Int32 GetHashCode()
+FSharp.Compiler.Syntax.DebugPointAtLeafExpr: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.DebugPointAtLeafExpr: Int32 Tag
+FSharp.Compiler.Syntax.DebugPointAtLeafExpr: Int32 get_Tag()
+FSharp.Compiler.Syntax.DebugPointAtLeafExpr: System.String ToString()
+FSharp.Compiler.Syntax.DebugPointAtSequential+Tags: Int32 SuppressBoth
+FSharp.Compiler.Syntax.DebugPointAtSequential+Tags: Int32 SuppressExpr
+FSharp.Compiler.Syntax.DebugPointAtSequential+Tags: Int32 SuppressNeither
+FSharp.Compiler.Syntax.DebugPointAtSequential+Tags: Int32 SuppressStmt
+FSharp.Compiler.Syntax.DebugPointAtSequential: Boolean Equals(FSharp.Compiler.Syntax.DebugPointAtSequential)
+FSharp.Compiler.Syntax.DebugPointAtSequential: Boolean Equals(System.Object)
+FSharp.Compiler.Syntax.DebugPointAtSequential: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.DebugPointAtSequential: Boolean IsSuppressBoth
+FSharp.Compiler.Syntax.DebugPointAtSequential: Boolean IsSuppressExpr
+FSharp.Compiler.Syntax.DebugPointAtSequential: Boolean IsSuppressNeither
+FSharp.Compiler.Syntax.DebugPointAtSequential: Boolean IsSuppressStmt
+FSharp.Compiler.Syntax.DebugPointAtSequential: Boolean get_IsSuppressBoth()
+FSharp.Compiler.Syntax.DebugPointAtSequential: Boolean get_IsSuppressExpr()
+FSharp.Compiler.Syntax.DebugPointAtSequential: Boolean get_IsSuppressNeither()
+FSharp.Compiler.Syntax.DebugPointAtSequential: Boolean get_IsSuppressStmt()
+FSharp.Compiler.Syntax.DebugPointAtSequential: FSharp.Compiler.Syntax.DebugPointAtSequential SuppressBoth
+FSharp.Compiler.Syntax.DebugPointAtSequential: FSharp.Compiler.Syntax.DebugPointAtSequential SuppressExpr
+FSharp.Compiler.Syntax.DebugPointAtSequential: FSharp.Compiler.Syntax.DebugPointAtSequential SuppressNeither
+FSharp.Compiler.Syntax.DebugPointAtSequential: FSharp.Compiler.Syntax.DebugPointAtSequential SuppressStmt
+FSharp.Compiler.Syntax.DebugPointAtSequential: FSharp.Compiler.Syntax.DebugPointAtSequential get_SuppressBoth()
+FSharp.Compiler.Syntax.DebugPointAtSequential: FSharp.Compiler.Syntax.DebugPointAtSequential get_SuppressExpr()
+FSharp.Compiler.Syntax.DebugPointAtSequential: FSharp.Compiler.Syntax.DebugPointAtSequential get_SuppressNeither()
+FSharp.Compiler.Syntax.DebugPointAtSequential: FSharp.Compiler.Syntax.DebugPointAtSequential get_SuppressStmt()
+FSharp.Compiler.Syntax.DebugPointAtSequential: FSharp.Compiler.Syntax.DebugPointAtSequential+Tags
+FSharp.Compiler.Syntax.DebugPointAtSequential: Int32 CompareTo(FSharp.Compiler.Syntax.DebugPointAtSequential)
+FSharp.Compiler.Syntax.DebugPointAtSequential: Int32 CompareTo(System.Object)
+FSharp.Compiler.Syntax.DebugPointAtSequential: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.Syntax.DebugPointAtSequential: Int32 GetHashCode()
+FSharp.Compiler.Syntax.DebugPointAtSequential: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.DebugPointAtSequential: Int32 Tag
+FSharp.Compiler.Syntax.DebugPointAtSequential: Int32 get_Tag()
+FSharp.Compiler.Syntax.DebugPointAtSequential: System.String ToString()
+FSharp.Compiler.Syntax.DebugPointAtTarget+Tags: Int32 No
+FSharp.Compiler.Syntax.DebugPointAtTarget+Tags: Int32 Yes
+FSharp.Compiler.Syntax.DebugPointAtTarget: Boolean Equals(FSharp.Compiler.Syntax.DebugPointAtTarget)
+FSharp.Compiler.Syntax.DebugPointAtTarget: Boolean Equals(System.Object)
+FSharp.Compiler.Syntax.DebugPointAtTarget: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.DebugPointAtTarget: Boolean IsNo
+FSharp.Compiler.Syntax.DebugPointAtTarget: Boolean IsYes
+FSharp.Compiler.Syntax.DebugPointAtTarget: Boolean get_IsNo()
+FSharp.Compiler.Syntax.DebugPointAtTarget: Boolean get_IsYes()
+FSharp.Compiler.Syntax.DebugPointAtTarget: FSharp.Compiler.Syntax.DebugPointAtTarget No
+FSharp.Compiler.Syntax.DebugPointAtTarget: FSharp.Compiler.Syntax.DebugPointAtTarget Yes
+FSharp.Compiler.Syntax.DebugPointAtTarget: FSharp.Compiler.Syntax.DebugPointAtTarget get_No()
+FSharp.Compiler.Syntax.DebugPointAtTarget: FSharp.Compiler.Syntax.DebugPointAtTarget get_Yes()
+FSharp.Compiler.Syntax.DebugPointAtTarget: FSharp.Compiler.Syntax.DebugPointAtTarget+Tags
+FSharp.Compiler.Syntax.DebugPointAtTarget: Int32 CompareTo(FSharp.Compiler.Syntax.DebugPointAtTarget)
+FSharp.Compiler.Syntax.DebugPointAtTarget: Int32 CompareTo(System.Object)
+FSharp.Compiler.Syntax.DebugPointAtTarget: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.Syntax.DebugPointAtTarget: Int32 GetHashCode()
+FSharp.Compiler.Syntax.DebugPointAtTarget: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.DebugPointAtTarget: Int32 Tag
+FSharp.Compiler.Syntax.DebugPointAtTarget: Int32 get_Tag()
+FSharp.Compiler.Syntax.DebugPointAtTarget: System.String ToString()
+FSharp.Compiler.Syntax.DebugPointAtTry+Tags: Int32 No
+FSharp.Compiler.Syntax.DebugPointAtTry+Tags: Int32 Yes
+FSharp.Compiler.Syntax.DebugPointAtTry+Yes: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.DebugPointAtTry+Yes: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.DebugPointAtTry: Boolean Equals(FSharp.Compiler.Syntax.DebugPointAtTry)
+FSharp.Compiler.Syntax.DebugPointAtTry: Boolean Equals(System.Object)
+FSharp.Compiler.Syntax.DebugPointAtTry: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.DebugPointAtTry: Boolean IsNo
+FSharp.Compiler.Syntax.DebugPointAtTry: Boolean IsYes
+FSharp.Compiler.Syntax.DebugPointAtTry: Boolean get_IsNo()
+FSharp.Compiler.Syntax.DebugPointAtTry: Boolean get_IsYes()
+FSharp.Compiler.Syntax.DebugPointAtTry: FSharp.Compiler.Syntax.DebugPointAtTry NewYes(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.DebugPointAtTry: FSharp.Compiler.Syntax.DebugPointAtTry No
+FSharp.Compiler.Syntax.DebugPointAtTry: FSharp.Compiler.Syntax.DebugPointAtTry get_No()
+FSharp.Compiler.Syntax.DebugPointAtTry: FSharp.Compiler.Syntax.DebugPointAtTry+Tags
+FSharp.Compiler.Syntax.DebugPointAtTry: FSharp.Compiler.Syntax.DebugPointAtTry+Yes
+FSharp.Compiler.Syntax.DebugPointAtTry: Int32 GetHashCode()
+FSharp.Compiler.Syntax.DebugPointAtTry: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.DebugPointAtTry: Int32 Tag
+FSharp.Compiler.Syntax.DebugPointAtTry: Int32 get_Tag()
+FSharp.Compiler.Syntax.DebugPointAtTry: System.String ToString()
+FSharp.Compiler.Syntax.DebugPointAtWhile+Tags: Int32 No
+FSharp.Compiler.Syntax.DebugPointAtWhile+Tags: Int32 Yes
+FSharp.Compiler.Syntax.DebugPointAtWhile+Yes: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.DebugPointAtWhile+Yes: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.DebugPointAtWhile: Boolean Equals(FSharp.Compiler.Syntax.DebugPointAtWhile)
+FSharp.Compiler.Syntax.DebugPointAtWhile: Boolean Equals(System.Object)
+FSharp.Compiler.Syntax.DebugPointAtWhile: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.DebugPointAtWhile: Boolean IsNo
+FSharp.Compiler.Syntax.DebugPointAtWhile: Boolean IsYes
+FSharp.Compiler.Syntax.DebugPointAtWhile: Boolean get_IsNo()
+FSharp.Compiler.Syntax.DebugPointAtWhile: Boolean get_IsYes()
+FSharp.Compiler.Syntax.DebugPointAtWhile: FSharp.Compiler.Syntax.DebugPointAtWhile NewYes(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.DebugPointAtWhile: FSharp.Compiler.Syntax.DebugPointAtWhile No
+FSharp.Compiler.Syntax.DebugPointAtWhile: FSharp.Compiler.Syntax.DebugPointAtWhile get_No()
+FSharp.Compiler.Syntax.DebugPointAtWhile: FSharp.Compiler.Syntax.DebugPointAtWhile+Tags
+FSharp.Compiler.Syntax.DebugPointAtWhile: FSharp.Compiler.Syntax.DebugPointAtWhile+Yes
+FSharp.Compiler.Syntax.DebugPointAtWhile: Int32 GetHashCode()
+FSharp.Compiler.Syntax.DebugPointAtWhile: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.DebugPointAtWhile: Int32 Tag
+FSharp.Compiler.Syntax.DebugPointAtWhile: Int32 get_Tag()
+FSharp.Compiler.Syntax.DebugPointAtWhile: System.String ToString()
+FSharp.Compiler.Syntax.DebugPointAtWith+Tags: Int32 No
+FSharp.Compiler.Syntax.DebugPointAtWith+Tags: Int32 Yes
+FSharp.Compiler.Syntax.DebugPointAtWith+Yes: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.DebugPointAtWith+Yes: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.DebugPointAtWith: Boolean Equals(FSharp.Compiler.Syntax.DebugPointAtWith)
+FSharp.Compiler.Syntax.DebugPointAtWith: Boolean Equals(System.Object)
+FSharp.Compiler.Syntax.DebugPointAtWith: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.DebugPointAtWith: Boolean IsNo
+FSharp.Compiler.Syntax.DebugPointAtWith: Boolean IsYes
+FSharp.Compiler.Syntax.DebugPointAtWith: Boolean get_IsNo()
+FSharp.Compiler.Syntax.DebugPointAtWith: Boolean get_IsYes()
+FSharp.Compiler.Syntax.DebugPointAtWith: FSharp.Compiler.Syntax.DebugPointAtWith NewYes(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.DebugPointAtWith: FSharp.Compiler.Syntax.DebugPointAtWith No
+FSharp.Compiler.Syntax.DebugPointAtWith: FSharp.Compiler.Syntax.DebugPointAtWith get_No()
+FSharp.Compiler.Syntax.DebugPointAtWith: FSharp.Compiler.Syntax.DebugPointAtWith+Tags
+FSharp.Compiler.Syntax.DebugPointAtWith: FSharp.Compiler.Syntax.DebugPointAtWith+Yes
+FSharp.Compiler.Syntax.DebugPointAtWith: Int32 GetHashCode()
+FSharp.Compiler.Syntax.DebugPointAtWith: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.DebugPointAtWith: Int32 Tag
+FSharp.Compiler.Syntax.DebugPointAtWith: Int32 get_Tag()
+FSharp.Compiler.Syntax.DebugPointAtWith: System.String ToString()
+FSharp.Compiler.Syntax.ExprAtomicFlag: FSharp.Compiler.Syntax.ExprAtomicFlag Atomic
+FSharp.Compiler.Syntax.ExprAtomicFlag: FSharp.Compiler.Syntax.ExprAtomicFlag NonAtomic
+FSharp.Compiler.Syntax.ExprAtomicFlag: Int32 value__
+FSharp.Compiler.Syntax.Ident: FSharp.Compiler.Text.Range get_idRange()
+FSharp.Compiler.Syntax.Ident: FSharp.Compiler.Text.Range idRange
+FSharp.Compiler.Syntax.Ident: System.String ToString()
+FSharp.Compiler.Syntax.Ident: System.String get_idText()
+FSharp.Compiler.Syntax.Ident: System.String idText
+FSharp.Compiler.Syntax.Ident: Void .ctor(System.String, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.ParsedHashDirective: FSharp.Compiler.Syntax.ParsedHashDirective NewParsedHashDirective(System.String, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedHashDirectiveArgument], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.ParsedHashDirective: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.ParsedHashDirective: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.ParsedHashDirective: Int32 Tag
+FSharp.Compiler.Syntax.ParsedHashDirective: Int32 get_Tag()
+FSharp.Compiler.Syntax.ParsedHashDirective: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedHashDirectiveArgument] args
+FSharp.Compiler.Syntax.ParsedHashDirective: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedHashDirectiveArgument] get_args()
+FSharp.Compiler.Syntax.ParsedHashDirective: System.String ToString()
+FSharp.Compiler.Syntax.ParsedHashDirective: System.String get_ident()
+FSharp.Compiler.Syntax.ParsedHashDirective: System.String ident
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument+SourceIdentifier: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument+SourceIdentifier: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument+SourceIdentifier: System.String constant
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument+SourceIdentifier: System.String get_constant()
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument+SourceIdentifier: System.String get_value()
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument+SourceIdentifier: System.String value
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument+String: FSharp.Compiler.Syntax.SynStringKind get_stringKind()
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument+String: FSharp.Compiler.Syntax.SynStringKind stringKind
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument+String: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument+String: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument+String: System.String get_value()
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument+String: System.String value
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument+Tags: Int32 SourceIdentifier
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument+Tags: Int32 String
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument: Boolean IsSourceIdentifier
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument: Boolean IsString
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument: Boolean get_IsSourceIdentifier()
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument: Boolean get_IsString()
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument: FSharp.Compiler.Syntax.ParsedHashDirectiveArgument NewSourceIdentifier(System.String, System.String, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument: FSharp.Compiler.Syntax.ParsedHashDirectiveArgument NewString(System.String, FSharp.Compiler.Syntax.SynStringKind, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument: FSharp.Compiler.Syntax.ParsedHashDirectiveArgument+SourceIdentifier
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument: FSharp.Compiler.Syntax.ParsedHashDirectiveArgument+String
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument: FSharp.Compiler.Syntax.ParsedHashDirectiveArgument+Tags
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument: Int32 Tag
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument: Int32 get_Tag()
+FSharp.Compiler.Syntax.ParsedHashDirectiveArgument: System.String ToString()
+FSharp.Compiler.Syntax.ParsedImplFile: FSharp.Compiler.Syntax.ParsedImplFile NewParsedImplFile(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedHashDirective], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedImplFileFragment])
+FSharp.Compiler.Syntax.ParsedImplFile: Int32 Tag
+FSharp.Compiler.Syntax.ParsedImplFile: Int32 get_Tag()
+FSharp.Compiler.Syntax.ParsedImplFile: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedHashDirective] get_hashDirectives()
+FSharp.Compiler.Syntax.ParsedImplFile: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedHashDirective] hashDirectives
+FSharp.Compiler.Syntax.ParsedImplFile: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedImplFileFragment] fragments
+FSharp.Compiler.Syntax.ParsedImplFile: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedImplFileFragment] get_fragments()
+FSharp.Compiler.Syntax.ParsedImplFile: System.String ToString()
+FSharp.Compiler.Syntax.ParsedImplFileFragment+AnonModule: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.ParsedImplFileFragment+AnonModule: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.ParsedImplFileFragment+AnonModule: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleDecl] decls
+FSharp.Compiler.Syntax.ParsedImplFileFragment+AnonModule: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleDecl] get_decls()
+FSharp.Compiler.Syntax.ParsedImplFileFragment+NamedModule: FSharp.Compiler.Syntax.SynModuleOrNamespace get_namedModule()
+FSharp.Compiler.Syntax.ParsedImplFileFragment+NamedModule: FSharp.Compiler.Syntax.SynModuleOrNamespace namedModule
+FSharp.Compiler.Syntax.ParsedImplFileFragment+NamespaceFragment: Boolean get_isRecursive()
+FSharp.Compiler.Syntax.ParsedImplFileFragment+NamespaceFragment: Boolean isRecursive
+FSharp.Compiler.Syntax.ParsedImplFileFragment+NamespaceFragment: FSharp.Compiler.Syntax.SynModuleOrNamespaceKind get_kind()
+FSharp.Compiler.Syntax.ParsedImplFileFragment+NamespaceFragment: FSharp.Compiler.Syntax.SynModuleOrNamespaceKind kind
+FSharp.Compiler.Syntax.ParsedImplFileFragment+NamespaceFragment: FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceTrivia get_trivia()
+FSharp.Compiler.Syntax.ParsedImplFileFragment+NamespaceFragment: FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceTrivia trivia
+FSharp.Compiler.Syntax.ParsedImplFileFragment+NamespaceFragment: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.ParsedImplFileFragment+NamespaceFragment: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.ParsedImplFileFragment+NamespaceFragment: FSharp.Compiler.Xml.PreXmlDoc get_xmlDoc()
+FSharp.Compiler.Syntax.ParsedImplFileFragment+NamespaceFragment: FSharp.Compiler.Xml.PreXmlDoc xmlDoc
+FSharp.Compiler.Syntax.ParsedImplFileFragment+NamespaceFragment: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] get_longId()
+FSharp.Compiler.Syntax.ParsedImplFileFragment+NamespaceFragment: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] longId
+FSharp.Compiler.Syntax.ParsedImplFileFragment+NamespaceFragment: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] attributes
+FSharp.Compiler.Syntax.ParsedImplFileFragment+NamespaceFragment: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] get_attributes()
+FSharp.Compiler.Syntax.ParsedImplFileFragment+NamespaceFragment: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleDecl] decls
+FSharp.Compiler.Syntax.ParsedImplFileFragment+NamespaceFragment: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleDecl] get_decls()
+FSharp.Compiler.Syntax.ParsedImplFileFragment+Tags: Int32 AnonModule
+FSharp.Compiler.Syntax.ParsedImplFileFragment+Tags: Int32 NamedModule
+FSharp.Compiler.Syntax.ParsedImplFileFragment+Tags: Int32 NamespaceFragment
+FSharp.Compiler.Syntax.ParsedImplFileFragment: Boolean IsAnonModule
+FSharp.Compiler.Syntax.ParsedImplFileFragment: Boolean IsNamedModule
+FSharp.Compiler.Syntax.ParsedImplFileFragment: Boolean IsNamespaceFragment
+FSharp.Compiler.Syntax.ParsedImplFileFragment: Boolean get_IsAnonModule()
+FSharp.Compiler.Syntax.ParsedImplFileFragment: Boolean get_IsNamedModule()
+FSharp.Compiler.Syntax.ParsedImplFileFragment: Boolean get_IsNamespaceFragment()
+FSharp.Compiler.Syntax.ParsedImplFileFragment: FSharp.Compiler.Syntax.ParsedImplFileFragment NewAnonModule(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleDecl], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.ParsedImplFileFragment: FSharp.Compiler.Syntax.ParsedImplFileFragment NewNamedModule(FSharp.Compiler.Syntax.SynModuleOrNamespace)
+FSharp.Compiler.Syntax.ParsedImplFileFragment: FSharp.Compiler.Syntax.ParsedImplFileFragment NewNamespaceFragment(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident], Boolean, FSharp.Compiler.Syntax.SynModuleOrNamespaceKind, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleDecl], FSharp.Compiler.Xml.PreXmlDoc, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceTrivia)
+FSharp.Compiler.Syntax.ParsedImplFileFragment: FSharp.Compiler.Syntax.ParsedImplFileFragment+AnonModule
+FSharp.Compiler.Syntax.ParsedImplFileFragment: FSharp.Compiler.Syntax.ParsedImplFileFragment+NamedModule
+FSharp.Compiler.Syntax.ParsedImplFileFragment: FSharp.Compiler.Syntax.ParsedImplFileFragment+NamespaceFragment
+FSharp.Compiler.Syntax.ParsedImplFileFragment: FSharp.Compiler.Syntax.ParsedImplFileFragment+Tags
+FSharp.Compiler.Syntax.ParsedImplFileFragment: Int32 Tag
+FSharp.Compiler.Syntax.ParsedImplFileFragment: Int32 get_Tag()
+FSharp.Compiler.Syntax.ParsedImplFileFragment: System.String ToString()
+FSharp.Compiler.Syntax.ParsedImplFileInput: Boolean IsExe
+FSharp.Compiler.Syntax.ParsedImplFileInput: Boolean IsLastCompiland
+FSharp.Compiler.Syntax.ParsedImplFileInput: Boolean IsScript
+FSharp.Compiler.Syntax.ParsedImplFileInput: Boolean get_IsExe()
+FSharp.Compiler.Syntax.ParsedImplFileInput: Boolean get_IsLastCompiland()
+FSharp.Compiler.Syntax.ParsedImplFileInput: Boolean get_IsScript()
+FSharp.Compiler.Syntax.ParsedImplFileInput: Boolean get_isScript()
+FSharp.Compiler.Syntax.ParsedImplFileInput: Boolean isScript
+FSharp.Compiler.Syntax.ParsedImplFileInput: FSharp.Compiler.Syntax.ParsedImplFileInput NewParsedImplFileInput(System.String, Boolean, FSharp.Compiler.Syntax.QualifiedNameOfFile, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ScopedPragma], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedHashDirective], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleOrNamespace], System.Tuple`2[System.Boolean,System.Boolean], FSharp.Compiler.SyntaxTrivia.ParsedImplFileInputTrivia, Microsoft.FSharp.Collections.FSharpSet`1[System.String])
+FSharp.Compiler.Syntax.ParsedImplFileInput: FSharp.Compiler.Syntax.QualifiedNameOfFile QualifiedName
+FSharp.Compiler.Syntax.ParsedImplFileInput: FSharp.Compiler.Syntax.QualifiedNameOfFile get_QualifiedName()
+FSharp.Compiler.Syntax.ParsedImplFileInput: FSharp.Compiler.Syntax.QualifiedNameOfFile get_qualifiedNameOfFile()
+FSharp.Compiler.Syntax.ParsedImplFileInput: FSharp.Compiler.Syntax.QualifiedNameOfFile qualifiedNameOfFile
+FSharp.Compiler.Syntax.ParsedImplFileInput: FSharp.Compiler.SyntaxTrivia.ParsedImplFileInputTrivia Trivia
+FSharp.Compiler.Syntax.ParsedImplFileInput: FSharp.Compiler.SyntaxTrivia.ParsedImplFileInputTrivia get_Trivia()
+FSharp.Compiler.Syntax.ParsedImplFileInput: FSharp.Compiler.SyntaxTrivia.ParsedImplFileInputTrivia get_trivia()
+FSharp.Compiler.Syntax.ParsedImplFileInput: FSharp.Compiler.SyntaxTrivia.ParsedImplFileInputTrivia trivia
+FSharp.Compiler.Syntax.ParsedImplFileInput: Int32 Tag
+FSharp.Compiler.Syntax.ParsedImplFileInput: Int32 get_Tag()
+FSharp.Compiler.Syntax.ParsedImplFileInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedHashDirective] HashDirectives
+FSharp.Compiler.Syntax.ParsedImplFileInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedHashDirective] get_HashDirectives()
+FSharp.Compiler.Syntax.ParsedImplFileInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedHashDirective] get_hashDirectives()
+FSharp.Compiler.Syntax.ParsedImplFileInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedHashDirective] hashDirectives
+FSharp.Compiler.Syntax.ParsedImplFileInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ScopedPragma] ScopedPragmas
+FSharp.Compiler.Syntax.ParsedImplFileInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ScopedPragma] get_ScopedPragmas()
+FSharp.Compiler.Syntax.ParsedImplFileInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ScopedPragma] get_scopedPragmas()
+FSharp.Compiler.Syntax.ParsedImplFileInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ScopedPragma] scopedPragmas
+FSharp.Compiler.Syntax.ParsedImplFileInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleOrNamespace] Contents
+FSharp.Compiler.Syntax.ParsedImplFileInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleOrNamespace] contents
+FSharp.Compiler.Syntax.ParsedImplFileInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleOrNamespace] get_Contents()
+FSharp.Compiler.Syntax.ParsedImplFileInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleOrNamespace] get_contents()
+FSharp.Compiler.Syntax.ParsedImplFileInput: Microsoft.FSharp.Collections.FSharpSet`1[System.String] get_identifiers()
+FSharp.Compiler.Syntax.ParsedImplFileInput: Microsoft.FSharp.Collections.FSharpSet`1[System.String] identifiers
+FSharp.Compiler.Syntax.ParsedImplFileInput: System.String FileName
+FSharp.Compiler.Syntax.ParsedImplFileInput: System.String ToString()
+FSharp.Compiler.Syntax.ParsedImplFileInput: System.String fileName
+FSharp.Compiler.Syntax.ParsedImplFileInput: System.String get_FileName()
+FSharp.Compiler.Syntax.ParsedImplFileInput: System.String get_fileName()
+FSharp.Compiler.Syntax.ParsedImplFileInput: System.Tuple`2[System.Boolean,System.Boolean] flags
+FSharp.Compiler.Syntax.ParsedImplFileInput: System.Tuple`2[System.Boolean,System.Boolean] get_flags()
+FSharp.Compiler.Syntax.ParsedInput+ImplFile: FSharp.Compiler.Syntax.ParsedImplFileInput Item
+FSharp.Compiler.Syntax.ParsedInput+ImplFile: FSharp.Compiler.Syntax.ParsedImplFileInput get_Item()
+FSharp.Compiler.Syntax.ParsedInput+SigFile: FSharp.Compiler.Syntax.ParsedSigFileInput Item
+FSharp.Compiler.Syntax.ParsedInput+SigFile: FSharp.Compiler.Syntax.ParsedSigFileInput get_Item()
+FSharp.Compiler.Syntax.ParsedInput+Tags: Int32 ImplFile
+FSharp.Compiler.Syntax.ParsedInput+Tags: Int32 SigFile
+FSharp.Compiler.Syntax.ParsedInput: Boolean IsImplFile
+FSharp.Compiler.Syntax.ParsedInput: Boolean IsSigFile
+FSharp.Compiler.Syntax.ParsedInput: Boolean get_IsImplFile()
+FSharp.Compiler.Syntax.ParsedInput: Boolean get_IsSigFile()
+FSharp.Compiler.Syntax.ParsedInput: FSharp.Compiler.Syntax.ParsedInput NewImplFile(FSharp.Compiler.Syntax.ParsedImplFileInput)
+FSharp.Compiler.Syntax.ParsedInput: FSharp.Compiler.Syntax.ParsedInput NewSigFile(FSharp.Compiler.Syntax.ParsedSigFileInput)
+FSharp.Compiler.Syntax.ParsedInput: FSharp.Compiler.Syntax.ParsedInput+ImplFile
+FSharp.Compiler.Syntax.ParsedInput: FSharp.Compiler.Syntax.ParsedInput+SigFile
+FSharp.Compiler.Syntax.ParsedInput: FSharp.Compiler.Syntax.ParsedInput+Tags
+FSharp.Compiler.Syntax.ParsedInput: FSharp.Compiler.Syntax.QualifiedNameOfFile QualifiedName
+FSharp.Compiler.Syntax.ParsedInput: FSharp.Compiler.Syntax.QualifiedNameOfFile get_QualifiedName()
+FSharp.Compiler.Syntax.ParsedInput: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.ParsedInput: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.ParsedInput: Int32 Tag
+FSharp.Compiler.Syntax.ParsedInput: Int32 get_Tag()
+FSharp.Compiler.Syntax.ParsedInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ScopedPragma] ScopedPragmas
+FSharp.Compiler.Syntax.ParsedInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ScopedPragma] get_ScopedPragmas()
+FSharp.Compiler.Syntax.ParsedInput: Microsoft.FSharp.Collections.FSharpSet`1[System.String] Identifiers
+FSharp.Compiler.Syntax.ParsedInput: Microsoft.FSharp.Collections.FSharpSet`1[System.String] get_Identifiers()
+FSharp.Compiler.Syntax.ParsedInput: System.String FileName
+FSharp.Compiler.Syntax.ParsedInput: System.String ToString()
+FSharp.Compiler.Syntax.ParsedInput: System.String get_FileName()
+FSharp.Compiler.Syntax.ParsedScriptInteraction: FSharp.Compiler.Syntax.ParsedScriptInteraction NewDefinitions(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleDecl], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.ParsedScriptInteraction: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.ParsedScriptInteraction: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.ParsedScriptInteraction: Int32 Tag
+FSharp.Compiler.Syntax.ParsedScriptInteraction: Int32 get_Tag()
+FSharp.Compiler.Syntax.ParsedScriptInteraction: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleDecl] defns
+FSharp.Compiler.Syntax.ParsedScriptInteraction: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleDecl] get_defns()
+FSharp.Compiler.Syntax.ParsedScriptInteraction: System.String ToString()
+FSharp.Compiler.Syntax.ParsedSigFile: FSharp.Compiler.Syntax.ParsedSigFile NewParsedSigFile(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedHashDirective], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedSigFileFragment])
+FSharp.Compiler.Syntax.ParsedSigFile: Int32 Tag
+FSharp.Compiler.Syntax.ParsedSigFile: Int32 get_Tag()
+FSharp.Compiler.Syntax.ParsedSigFile: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedHashDirective] get_hashDirectives()
+FSharp.Compiler.Syntax.ParsedSigFile: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedHashDirective] hashDirectives
+FSharp.Compiler.Syntax.ParsedSigFile: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedSigFileFragment] fragments
+FSharp.Compiler.Syntax.ParsedSigFile: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedSigFileFragment] get_fragments()
+FSharp.Compiler.Syntax.ParsedSigFile: System.String ToString()
+FSharp.Compiler.Syntax.ParsedSigFileFragment+AnonModule: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.ParsedSigFileFragment+AnonModule: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.ParsedSigFileFragment+AnonModule: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleSigDecl] decls
+FSharp.Compiler.Syntax.ParsedSigFileFragment+AnonModule: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleSigDecl] get_decls()
+FSharp.Compiler.Syntax.ParsedSigFileFragment+NamedModule: FSharp.Compiler.Syntax.SynModuleOrNamespaceSig get_namedModule()
+FSharp.Compiler.Syntax.ParsedSigFileFragment+NamedModule: FSharp.Compiler.Syntax.SynModuleOrNamespaceSig namedModule
+FSharp.Compiler.Syntax.ParsedSigFileFragment+NamespaceFragment: Boolean get_isRecursive()
+FSharp.Compiler.Syntax.ParsedSigFileFragment+NamespaceFragment: Boolean isRecursive
+FSharp.Compiler.Syntax.ParsedSigFileFragment+NamespaceFragment: FSharp.Compiler.Syntax.SynModuleOrNamespaceKind get_kind()
+FSharp.Compiler.Syntax.ParsedSigFileFragment+NamespaceFragment: FSharp.Compiler.Syntax.SynModuleOrNamespaceKind kind
+FSharp.Compiler.Syntax.ParsedSigFileFragment+NamespaceFragment: FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceSigTrivia get_trivia()
+FSharp.Compiler.Syntax.ParsedSigFileFragment+NamespaceFragment: FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceSigTrivia trivia
+FSharp.Compiler.Syntax.ParsedSigFileFragment+NamespaceFragment: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.ParsedSigFileFragment+NamespaceFragment: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.ParsedSigFileFragment+NamespaceFragment: FSharp.Compiler.Xml.PreXmlDoc get_xmlDoc()
+FSharp.Compiler.Syntax.ParsedSigFileFragment+NamespaceFragment: FSharp.Compiler.Xml.PreXmlDoc xmlDoc
+FSharp.Compiler.Syntax.ParsedSigFileFragment+NamespaceFragment: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] get_longId()
+FSharp.Compiler.Syntax.ParsedSigFileFragment+NamespaceFragment: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] longId
+FSharp.Compiler.Syntax.ParsedSigFileFragment+NamespaceFragment: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] attributes
+FSharp.Compiler.Syntax.ParsedSigFileFragment+NamespaceFragment: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] get_attributes()
+FSharp.Compiler.Syntax.ParsedSigFileFragment+NamespaceFragment: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleSigDecl] decls
+FSharp.Compiler.Syntax.ParsedSigFileFragment+NamespaceFragment: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleSigDecl] get_decls()
+FSharp.Compiler.Syntax.ParsedSigFileFragment+Tags: Int32 AnonModule
+FSharp.Compiler.Syntax.ParsedSigFileFragment+Tags: Int32 NamedModule
+FSharp.Compiler.Syntax.ParsedSigFileFragment+Tags: Int32 NamespaceFragment
+FSharp.Compiler.Syntax.ParsedSigFileFragment: Boolean IsAnonModule
+FSharp.Compiler.Syntax.ParsedSigFileFragment: Boolean IsNamedModule
+FSharp.Compiler.Syntax.ParsedSigFileFragment: Boolean IsNamespaceFragment
+FSharp.Compiler.Syntax.ParsedSigFileFragment: Boolean get_IsAnonModule()
+FSharp.Compiler.Syntax.ParsedSigFileFragment: Boolean get_IsNamedModule()
+FSharp.Compiler.Syntax.ParsedSigFileFragment: Boolean get_IsNamespaceFragment()
+FSharp.Compiler.Syntax.ParsedSigFileFragment: FSharp.Compiler.Syntax.ParsedSigFileFragment NewAnonModule(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleSigDecl], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.ParsedSigFileFragment: FSharp.Compiler.Syntax.ParsedSigFileFragment NewNamedModule(FSharp.Compiler.Syntax.SynModuleOrNamespaceSig)
+FSharp.Compiler.Syntax.ParsedSigFileFragment: FSharp.Compiler.Syntax.ParsedSigFileFragment NewNamespaceFragment(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident], Boolean, FSharp.Compiler.Syntax.SynModuleOrNamespaceKind, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleSigDecl], FSharp.Compiler.Xml.PreXmlDoc, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceSigTrivia)
+FSharp.Compiler.Syntax.ParsedSigFileFragment: FSharp.Compiler.Syntax.ParsedSigFileFragment+AnonModule
+FSharp.Compiler.Syntax.ParsedSigFileFragment: FSharp.Compiler.Syntax.ParsedSigFileFragment+NamedModule
+FSharp.Compiler.Syntax.ParsedSigFileFragment: FSharp.Compiler.Syntax.ParsedSigFileFragment+NamespaceFragment
+FSharp.Compiler.Syntax.ParsedSigFileFragment: FSharp.Compiler.Syntax.ParsedSigFileFragment+Tags
+FSharp.Compiler.Syntax.ParsedSigFileFragment: Int32 Tag
+FSharp.Compiler.Syntax.ParsedSigFileFragment: Int32 get_Tag()
+FSharp.Compiler.Syntax.ParsedSigFileFragment: System.String ToString()
+FSharp.Compiler.Syntax.ParsedSigFileInput: FSharp.Compiler.Syntax.ParsedSigFileInput NewParsedSigFileInput(System.String, FSharp.Compiler.Syntax.QualifiedNameOfFile, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ScopedPragma], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedHashDirective], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleOrNamespaceSig], FSharp.Compiler.SyntaxTrivia.ParsedSigFileInputTrivia, Microsoft.FSharp.Collections.FSharpSet`1[System.String])
+FSharp.Compiler.Syntax.ParsedSigFileInput: FSharp.Compiler.Syntax.QualifiedNameOfFile QualifiedName
+FSharp.Compiler.Syntax.ParsedSigFileInput: FSharp.Compiler.Syntax.QualifiedNameOfFile get_QualifiedName()
+FSharp.Compiler.Syntax.ParsedSigFileInput: FSharp.Compiler.Syntax.QualifiedNameOfFile get_qualifiedNameOfFile()
+FSharp.Compiler.Syntax.ParsedSigFileInput: FSharp.Compiler.Syntax.QualifiedNameOfFile qualifiedNameOfFile
+FSharp.Compiler.Syntax.ParsedSigFileInput: FSharp.Compiler.SyntaxTrivia.ParsedSigFileInputTrivia Trivia
+FSharp.Compiler.Syntax.ParsedSigFileInput: FSharp.Compiler.SyntaxTrivia.ParsedSigFileInputTrivia get_Trivia()
+FSharp.Compiler.Syntax.ParsedSigFileInput: FSharp.Compiler.SyntaxTrivia.ParsedSigFileInputTrivia get_trivia()
+FSharp.Compiler.Syntax.ParsedSigFileInput: FSharp.Compiler.SyntaxTrivia.ParsedSigFileInputTrivia trivia
+FSharp.Compiler.Syntax.ParsedSigFileInput: Int32 Tag
+FSharp.Compiler.Syntax.ParsedSigFileInput: Int32 get_Tag()
+FSharp.Compiler.Syntax.ParsedSigFileInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedHashDirective] HashDirectives
+FSharp.Compiler.Syntax.ParsedSigFileInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedHashDirective] get_HashDirectives()
+FSharp.Compiler.Syntax.ParsedSigFileInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedHashDirective] get_hashDirectives()
+FSharp.Compiler.Syntax.ParsedSigFileInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ParsedHashDirective] hashDirectives
+FSharp.Compiler.Syntax.ParsedSigFileInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ScopedPragma] ScopedPragmas
+FSharp.Compiler.Syntax.ParsedSigFileInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ScopedPragma] get_ScopedPragmas()
+FSharp.Compiler.Syntax.ParsedSigFileInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ScopedPragma] get_scopedPragmas()
+FSharp.Compiler.Syntax.ParsedSigFileInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.ScopedPragma] scopedPragmas
+FSharp.Compiler.Syntax.ParsedSigFileInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleOrNamespaceSig] Contents
+FSharp.Compiler.Syntax.ParsedSigFileInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleOrNamespaceSig] contents
+FSharp.Compiler.Syntax.ParsedSigFileInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleOrNamespaceSig] get_Contents()
+FSharp.Compiler.Syntax.ParsedSigFileInput: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleOrNamespaceSig] get_contents()
+FSharp.Compiler.Syntax.ParsedSigFileInput: Microsoft.FSharp.Collections.FSharpSet`1[System.String] get_identifiers()
+FSharp.Compiler.Syntax.ParsedSigFileInput: Microsoft.FSharp.Collections.FSharpSet`1[System.String] identifiers
+FSharp.Compiler.Syntax.ParsedSigFileInput: System.String FileName
+FSharp.Compiler.Syntax.ParsedSigFileInput: System.String ToString()
+FSharp.Compiler.Syntax.ParsedSigFileInput: System.String fileName
+FSharp.Compiler.Syntax.ParsedSigFileInput: System.String get_FileName()
+FSharp.Compiler.Syntax.ParsedSigFileInput: System.String get_fileName()
+FSharp.Compiler.Syntax.ParserDetail+Tags: Int32 ErrorRecovery
+FSharp.Compiler.Syntax.ParserDetail+Tags: Int32 Ok
+FSharp.Compiler.Syntax.ParserDetail: Boolean Equals(FSharp.Compiler.Syntax.ParserDetail)
+FSharp.Compiler.Syntax.ParserDetail: Boolean Equals(System.Object)
+FSharp.Compiler.Syntax.ParserDetail: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.ParserDetail: Boolean IsErrorRecovery
+FSharp.Compiler.Syntax.ParserDetail: Boolean IsOk
+FSharp.Compiler.Syntax.ParserDetail: Boolean get_IsErrorRecovery()
+FSharp.Compiler.Syntax.ParserDetail: Boolean get_IsOk()
+FSharp.Compiler.Syntax.ParserDetail: FSharp.Compiler.Syntax.ParserDetail ErrorRecovery
+FSharp.Compiler.Syntax.ParserDetail: FSharp.Compiler.Syntax.ParserDetail Ok
+FSharp.Compiler.Syntax.ParserDetail: FSharp.Compiler.Syntax.ParserDetail get_ErrorRecovery()
+FSharp.Compiler.Syntax.ParserDetail: FSharp.Compiler.Syntax.ParserDetail get_Ok()
+FSharp.Compiler.Syntax.ParserDetail: FSharp.Compiler.Syntax.ParserDetail+Tags
+FSharp.Compiler.Syntax.ParserDetail: Int32 CompareTo(FSharp.Compiler.Syntax.ParserDetail)
+FSharp.Compiler.Syntax.ParserDetail: Int32 CompareTo(System.Object)
+FSharp.Compiler.Syntax.ParserDetail: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.Syntax.ParserDetail: Int32 GetHashCode()
+FSharp.Compiler.Syntax.ParserDetail: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.ParserDetail: Int32 Tag
+FSharp.Compiler.Syntax.ParserDetail: Int32 get_Tag()
+FSharp.Compiler.Syntax.ParserDetail: System.String ToString()
+FSharp.Compiler.Syntax.PrettyNaming: Boolean IsActivePatternName(System.String)
+FSharp.Compiler.Syntax.PrettyNaming: Boolean IsCompilerGeneratedName(System.String)
+FSharp.Compiler.Syntax.PrettyNaming: Boolean IsIdentifierFirstCharacter(Char)
+FSharp.Compiler.Syntax.PrettyNaming: Boolean IsIdentifierName(System.String)
+FSharp.Compiler.Syntax.PrettyNaming: Boolean IsIdentifierPartCharacter(Char)
+FSharp.Compiler.Syntax.PrettyNaming: Boolean IsLogicalInfixOpName(System.String)
+FSharp.Compiler.Syntax.PrettyNaming: Boolean IsLogicalOpName(System.String)
+FSharp.Compiler.Syntax.PrettyNaming: Boolean IsLogicalPrefixOperator(System.String)
+FSharp.Compiler.Syntax.PrettyNaming: Boolean IsLogicalTernaryOperator(System.String)
+FSharp.Compiler.Syntax.PrettyNaming: Boolean IsLongIdentifierPartCharacter(Char)
+FSharp.Compiler.Syntax.PrettyNaming: Boolean IsOperatorDisplayName(System.String)
+FSharp.Compiler.Syntax.PrettyNaming: Boolean IsPunctuation(System.String)
+FSharp.Compiler.Syntax.PrettyNaming: Microsoft.FSharp.Collections.FSharpList`1[System.String] GetLongNameFromString(System.String)
+FSharp.Compiler.Syntax.PrettyNaming: Microsoft.FSharp.Core.FSharpOption`1[System.String] TryChopPropertyName(System.String)
+FSharp.Compiler.Syntax.PrettyNaming: System.String CompileOpName(System.String)
+FSharp.Compiler.Syntax.PrettyNaming: System.String ConvertValLogicalNameToDisplayNameCore(System.String)
+FSharp.Compiler.Syntax.PrettyNaming: System.String FormatAndOtherOverloadsString(Int32)
+FSharp.Compiler.Syntax.PrettyNaming: System.String FsiDynamicModulePrefix
+FSharp.Compiler.Syntax.PrettyNaming: System.String NormalizeIdentifierBackticks(System.String)
+FSharp.Compiler.Syntax.PrettyNaming: System.String get_FsiDynamicModulePrefix()
+FSharp.Compiler.Syntax.QualifiedNameOfFile: FSharp.Compiler.Syntax.Ident Id
+FSharp.Compiler.Syntax.QualifiedNameOfFile: FSharp.Compiler.Syntax.Ident Item
+FSharp.Compiler.Syntax.QualifiedNameOfFile: FSharp.Compiler.Syntax.Ident get_Id()
+FSharp.Compiler.Syntax.QualifiedNameOfFile: FSharp.Compiler.Syntax.Ident get_Item()
+FSharp.Compiler.Syntax.QualifiedNameOfFile: FSharp.Compiler.Syntax.QualifiedNameOfFile NewQualifiedNameOfFile(FSharp.Compiler.Syntax.Ident)
+FSharp.Compiler.Syntax.QualifiedNameOfFile: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.QualifiedNameOfFile: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.QualifiedNameOfFile: Int32 Tag
+FSharp.Compiler.Syntax.QualifiedNameOfFile: Int32 get_Tag()
+FSharp.Compiler.Syntax.QualifiedNameOfFile: System.String Text
+FSharp.Compiler.Syntax.QualifiedNameOfFile: System.String ToString()
+FSharp.Compiler.Syntax.QualifiedNameOfFile: System.String get_Text()
+FSharp.Compiler.Syntax.ScopedPragma: Boolean Equals(FSharp.Compiler.Syntax.ScopedPragma)
+FSharp.Compiler.Syntax.ScopedPragma: Boolean Equals(System.Object)
+FSharp.Compiler.Syntax.ScopedPragma: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.ScopedPragma: FSharp.Compiler.Syntax.ScopedPragma NewWarningOff(FSharp.Compiler.Text.Range, Int32)
+FSharp.Compiler.Syntax.ScopedPragma: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.ScopedPragma: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.ScopedPragma: Int32 GetHashCode()
+FSharp.Compiler.Syntax.ScopedPragma: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.ScopedPragma: Int32 Tag
+FSharp.Compiler.Syntax.ScopedPragma: Int32 get_Tag()
+FSharp.Compiler.Syntax.ScopedPragma: Int32 get_warningNumber()
+FSharp.Compiler.Syntax.ScopedPragma: Int32 warningNumber
+FSharp.Compiler.Syntax.ScopedPragma: System.String ToString()
+FSharp.Compiler.Syntax.SeqExprOnly: Boolean Equals(FSharp.Compiler.Syntax.SeqExprOnly)
+FSharp.Compiler.Syntax.SeqExprOnly: Boolean Equals(System.Object)
+FSharp.Compiler.Syntax.SeqExprOnly: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.SeqExprOnly: Boolean Item
+FSharp.Compiler.Syntax.SeqExprOnly: Boolean get_Item()
+FSharp.Compiler.Syntax.SeqExprOnly: FSharp.Compiler.Syntax.SeqExprOnly NewSeqExprOnly(Boolean)
+FSharp.Compiler.Syntax.SeqExprOnly: Int32 CompareTo(FSharp.Compiler.Syntax.SeqExprOnly)
+FSharp.Compiler.Syntax.SeqExprOnly: Int32 CompareTo(System.Object)
+FSharp.Compiler.Syntax.SeqExprOnly: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.Syntax.SeqExprOnly: Int32 GetHashCode()
+FSharp.Compiler.Syntax.SeqExprOnly: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.SeqExprOnly: Int32 Tag
+FSharp.Compiler.Syntax.SeqExprOnly: Int32 get_Tag()
+FSharp.Compiler.Syntax.SeqExprOnly: System.String ToString()
+FSharp.Compiler.Syntax.SynAccess+Internal: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynAccess+Internal: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynAccess+Private: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynAccess+Private: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynAccess+Public: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynAccess+Public: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynAccess+Tags: Int32 Internal
+FSharp.Compiler.Syntax.SynAccess+Tags: Int32 Private
+FSharp.Compiler.Syntax.SynAccess+Tags: Int32 Public
+FSharp.Compiler.Syntax.SynAccess: Boolean Equals(FSharp.Compiler.Syntax.SynAccess)
+FSharp.Compiler.Syntax.SynAccess: Boolean Equals(System.Object)
+FSharp.Compiler.Syntax.SynAccess: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.SynAccess: Boolean IsInternal
+FSharp.Compiler.Syntax.SynAccess: Boolean IsPrivate
+FSharp.Compiler.Syntax.SynAccess: Boolean IsPublic
+FSharp.Compiler.Syntax.SynAccess: Boolean get_IsInternal()
+FSharp.Compiler.Syntax.SynAccess: Boolean get_IsPrivate()
+FSharp.Compiler.Syntax.SynAccess: Boolean get_IsPublic()
+FSharp.Compiler.Syntax.SynAccess: FSharp.Compiler.Syntax.SynAccess NewInternal(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynAccess: FSharp.Compiler.Syntax.SynAccess NewPrivate(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynAccess: FSharp.Compiler.Syntax.SynAccess NewPublic(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynAccess: FSharp.Compiler.Syntax.SynAccess+Internal
+FSharp.Compiler.Syntax.SynAccess: FSharp.Compiler.Syntax.SynAccess+Private
+FSharp.Compiler.Syntax.SynAccess: FSharp.Compiler.Syntax.SynAccess+Public
+FSharp.Compiler.Syntax.SynAccess: FSharp.Compiler.Syntax.SynAccess+Tags
+FSharp.Compiler.Syntax.SynAccess: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynAccess: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynAccess: Int32 GetHashCode()
+FSharp.Compiler.Syntax.SynAccess: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.SynAccess: Int32 Tag
+FSharp.Compiler.Syntax.SynAccess: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynAccess: System.String ToString()
+FSharp.Compiler.Syntax.SynArgInfo: Boolean get_optional()
+FSharp.Compiler.Syntax.SynArgInfo: Boolean optional
+FSharp.Compiler.Syntax.SynArgInfo: FSharp.Compiler.Syntax.SynArgInfo NewSynArgInfo(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], Boolean, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident])
+FSharp.Compiler.Syntax.SynArgInfo: Int32 Tag
+FSharp.Compiler.Syntax.SynArgInfo: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynArgInfo: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] Attributes
+FSharp.Compiler.Syntax.SynArgInfo: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] attributes
+FSharp.Compiler.Syntax.SynArgInfo: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] get_Attributes()
+FSharp.Compiler.Syntax.SynArgInfo: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] get_attributes()
+FSharp.Compiler.Syntax.SynArgInfo: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] Ident
+FSharp.Compiler.Syntax.SynArgInfo: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] get_Ident()
+FSharp.Compiler.Syntax.SynArgInfo: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] get_ident()
+FSharp.Compiler.Syntax.SynArgInfo: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] ident
+FSharp.Compiler.Syntax.SynArgInfo: System.String ToString()
+FSharp.Compiler.Syntax.SynArgPats+NamePatPairs: FSharp.Compiler.SyntaxTrivia.SynArgPatsNamePatPairsTrivia get_trivia()
+FSharp.Compiler.Syntax.SynArgPats+NamePatPairs: FSharp.Compiler.SyntaxTrivia.SynArgPatsNamePatPairsTrivia trivia
+FSharp.Compiler.Syntax.SynArgPats+NamePatPairs: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynArgPats+NamePatPairs: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynArgPats+NamePatPairs: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[FSharp.Compiler.Syntax.Ident,FSharp.Compiler.Text.Range,FSharp.Compiler.Syntax.SynPat]] get_pats()
+FSharp.Compiler.Syntax.SynArgPats+NamePatPairs: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[FSharp.Compiler.Syntax.Ident,FSharp.Compiler.Text.Range,FSharp.Compiler.Syntax.SynPat]] pats
+FSharp.Compiler.Syntax.SynArgPats+Pats: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynPat] get_pats()
+FSharp.Compiler.Syntax.SynArgPats+Pats: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynPat] pats
+FSharp.Compiler.Syntax.SynArgPats+Tags: Int32 NamePatPairs
+FSharp.Compiler.Syntax.SynArgPats+Tags: Int32 Pats
+FSharp.Compiler.Syntax.SynArgPats: Boolean IsNamePatPairs
+FSharp.Compiler.Syntax.SynArgPats: Boolean IsPats
+FSharp.Compiler.Syntax.SynArgPats: Boolean get_IsNamePatPairs()
+FSharp.Compiler.Syntax.SynArgPats: Boolean get_IsPats()
+FSharp.Compiler.Syntax.SynArgPats: FSharp.Compiler.Syntax.SynArgPats NewNamePatPairs(Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[FSharp.Compiler.Syntax.Ident,FSharp.Compiler.Text.Range,FSharp.Compiler.Syntax.SynPat]], FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynArgPatsNamePatPairsTrivia)
+FSharp.Compiler.Syntax.SynArgPats: FSharp.Compiler.Syntax.SynArgPats NewPats(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynPat])
+FSharp.Compiler.Syntax.SynArgPats: FSharp.Compiler.Syntax.SynArgPats+NamePatPairs
+FSharp.Compiler.Syntax.SynArgPats: FSharp.Compiler.Syntax.SynArgPats+Pats
+FSharp.Compiler.Syntax.SynArgPats: FSharp.Compiler.Syntax.SynArgPats+Tags
+FSharp.Compiler.Syntax.SynArgPats: Int32 Tag
+FSharp.Compiler.Syntax.SynArgPats: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynArgPats: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynPat] Patterns
+FSharp.Compiler.Syntax.SynArgPats: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynPat] get_Patterns()
+FSharp.Compiler.Syntax.SynArgPats: System.String ToString()
+FSharp.Compiler.Syntax.SynAttribute: Boolean AppliesToGetterAndSetter
+FSharp.Compiler.Syntax.SynAttribute: Boolean get_AppliesToGetterAndSetter()
+FSharp.Compiler.Syntax.SynAttribute: FSharp.Compiler.Syntax.SynExpr ArgExpr
+FSharp.Compiler.Syntax.SynAttribute: FSharp.Compiler.Syntax.SynExpr get_ArgExpr()
+FSharp.Compiler.Syntax.SynAttribute: FSharp.Compiler.Syntax.SynLongIdent TypeName
+FSharp.Compiler.Syntax.SynAttribute: FSharp.Compiler.Syntax.SynLongIdent get_TypeName()
+FSharp.Compiler.Syntax.SynAttribute: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynAttribute: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynAttribute: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] Target
+FSharp.Compiler.Syntax.SynAttribute: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] get_Target()
+FSharp.Compiler.Syntax.SynAttribute: System.String ToString()
+FSharp.Compiler.Syntax.SynAttribute: Void .ctor(FSharp.Compiler.Syntax.SynLongIdent, FSharp.Compiler.Syntax.SynExpr, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident], Boolean, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynAttributeList: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynAttributeList: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynAttributeList: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttribute] Attributes
+FSharp.Compiler.Syntax.SynAttributeList: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttribute] get_Attributes()
+FSharp.Compiler.Syntax.SynAttributeList: System.String ToString()
+FSharp.Compiler.Syntax.SynAttributeList: Void .ctor(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttribute], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynBinding: Boolean get_isInline()
+FSharp.Compiler.Syntax.SynBinding: Boolean get_isMutable()
+FSharp.Compiler.Syntax.SynBinding: Boolean isInline
+FSharp.Compiler.Syntax.SynBinding: Boolean isMutable
+FSharp.Compiler.Syntax.SynBinding: FSharp.Compiler.Syntax.DebugPointAtBinding debugPoint
+FSharp.Compiler.Syntax.SynBinding: FSharp.Compiler.Syntax.DebugPointAtBinding get_debugPoint()
+FSharp.Compiler.Syntax.SynBinding: FSharp.Compiler.Syntax.SynBinding NewSynBinding(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess], FSharp.Compiler.Syntax.SynBindingKind, Boolean, Boolean, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], FSharp.Compiler.Xml.PreXmlDoc, FSharp.Compiler.Syntax.SynValData, FSharp.Compiler.Syntax.SynPat, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynBindingReturnInfo], FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range, FSharp.Compiler.Syntax.DebugPointAtBinding, FSharp.Compiler.SyntaxTrivia.SynBindingTrivia)
+FSharp.Compiler.Syntax.SynBinding: FSharp.Compiler.Syntax.SynBindingKind get_kind()
+FSharp.Compiler.Syntax.SynBinding: FSharp.Compiler.Syntax.SynBindingKind kind
+FSharp.Compiler.Syntax.SynBinding: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynBinding: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynBinding: FSharp.Compiler.Syntax.SynPat get_headPat()
+FSharp.Compiler.Syntax.SynBinding: FSharp.Compiler.Syntax.SynPat headPat
+FSharp.Compiler.Syntax.SynBinding: FSharp.Compiler.Syntax.SynValData get_valData()
+FSharp.Compiler.Syntax.SynBinding: FSharp.Compiler.Syntax.SynValData valData
+FSharp.Compiler.Syntax.SynBinding: FSharp.Compiler.SyntaxTrivia.SynBindingTrivia get_trivia()
+FSharp.Compiler.Syntax.SynBinding: FSharp.Compiler.SyntaxTrivia.SynBindingTrivia trivia
+FSharp.Compiler.Syntax.SynBinding: FSharp.Compiler.Text.Range RangeOfBindingWithRhs
+FSharp.Compiler.Syntax.SynBinding: FSharp.Compiler.Text.Range RangeOfBindingWithoutRhs
+FSharp.Compiler.Syntax.SynBinding: FSharp.Compiler.Text.Range RangeOfHeadPattern
+FSharp.Compiler.Syntax.SynBinding: FSharp.Compiler.Text.Range get_RangeOfBindingWithRhs()
+FSharp.Compiler.Syntax.SynBinding: FSharp.Compiler.Text.Range get_RangeOfBindingWithoutRhs()
+FSharp.Compiler.Syntax.SynBinding: FSharp.Compiler.Text.Range get_RangeOfHeadPattern()
+FSharp.Compiler.Syntax.SynBinding: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynBinding: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynBinding: FSharp.Compiler.Xml.PreXmlDoc get_xmlDoc()
+FSharp.Compiler.Syntax.SynBinding: FSharp.Compiler.Xml.PreXmlDoc xmlDoc
+FSharp.Compiler.Syntax.SynBinding: Int32 Tag
+FSharp.Compiler.Syntax.SynBinding: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynBinding: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] attributes
+FSharp.Compiler.Syntax.SynBinding: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] get_attributes()
+FSharp.Compiler.Syntax.SynBinding: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] accessibility
+FSharp.Compiler.Syntax.SynBinding: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] get_accessibility()
+FSharp.Compiler.Syntax.SynBinding: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynBindingReturnInfo] get_returnInfo()
+FSharp.Compiler.Syntax.SynBinding: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynBindingReturnInfo] returnInfo
+FSharp.Compiler.Syntax.SynBinding: System.String ToString()
+FSharp.Compiler.Syntax.SynBindingKind+Tags: Int32 Do
+FSharp.Compiler.Syntax.SynBindingKind+Tags: Int32 Normal
+FSharp.Compiler.Syntax.SynBindingKind+Tags: Int32 StandaloneExpression
+FSharp.Compiler.Syntax.SynBindingKind: Boolean Equals(FSharp.Compiler.Syntax.SynBindingKind)
+FSharp.Compiler.Syntax.SynBindingKind: Boolean Equals(System.Object)
+FSharp.Compiler.Syntax.SynBindingKind: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.SynBindingKind: Boolean IsDo
+FSharp.Compiler.Syntax.SynBindingKind: Boolean IsNormal
+FSharp.Compiler.Syntax.SynBindingKind: Boolean IsStandaloneExpression
+FSharp.Compiler.Syntax.SynBindingKind: Boolean get_IsDo()
+FSharp.Compiler.Syntax.SynBindingKind: Boolean get_IsNormal()
+FSharp.Compiler.Syntax.SynBindingKind: Boolean get_IsStandaloneExpression()
+FSharp.Compiler.Syntax.SynBindingKind: FSharp.Compiler.Syntax.SynBindingKind Do
+FSharp.Compiler.Syntax.SynBindingKind: FSharp.Compiler.Syntax.SynBindingKind Normal
+FSharp.Compiler.Syntax.SynBindingKind: FSharp.Compiler.Syntax.SynBindingKind StandaloneExpression
+FSharp.Compiler.Syntax.SynBindingKind: FSharp.Compiler.Syntax.SynBindingKind get_Do()
+FSharp.Compiler.Syntax.SynBindingKind: FSharp.Compiler.Syntax.SynBindingKind get_Normal()
+FSharp.Compiler.Syntax.SynBindingKind: FSharp.Compiler.Syntax.SynBindingKind get_StandaloneExpression()
+FSharp.Compiler.Syntax.SynBindingKind: FSharp.Compiler.Syntax.SynBindingKind+Tags
+FSharp.Compiler.Syntax.SynBindingKind: Int32 CompareTo(FSharp.Compiler.Syntax.SynBindingKind)
+FSharp.Compiler.Syntax.SynBindingKind: Int32 CompareTo(System.Object)
+FSharp.Compiler.Syntax.SynBindingKind: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.Syntax.SynBindingKind: Int32 GetHashCode()
+FSharp.Compiler.Syntax.SynBindingKind: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.SynBindingKind: Int32 Tag
+FSharp.Compiler.Syntax.SynBindingKind: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynBindingKind: System.String ToString()
+FSharp.Compiler.Syntax.SynBindingReturnInfo: FSharp.Compiler.Syntax.SynBindingReturnInfo NewSynBindingReturnInfo(FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], FSharp.Compiler.SyntaxTrivia.SynBindingReturnInfoTrivia)
+FSharp.Compiler.Syntax.SynBindingReturnInfo: FSharp.Compiler.Syntax.SynType get_typeName()
+FSharp.Compiler.Syntax.SynBindingReturnInfo: FSharp.Compiler.Syntax.SynType typeName
+FSharp.Compiler.Syntax.SynBindingReturnInfo: FSharp.Compiler.SyntaxTrivia.SynBindingReturnInfoTrivia get_trivia()
+FSharp.Compiler.Syntax.SynBindingReturnInfo: FSharp.Compiler.SyntaxTrivia.SynBindingReturnInfoTrivia trivia
+FSharp.Compiler.Syntax.SynBindingReturnInfo: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynBindingReturnInfo: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynBindingReturnInfo: Int32 Tag
+FSharp.Compiler.Syntax.SynBindingReturnInfo: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynBindingReturnInfo: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] attributes
+FSharp.Compiler.Syntax.SynBindingReturnInfo: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] get_attributes()
+FSharp.Compiler.Syntax.SynBindingReturnInfo: System.String ToString()
+FSharp.Compiler.Syntax.SynByteStringKind+Tags: Int32 Regular
+FSharp.Compiler.Syntax.SynByteStringKind+Tags: Int32 Verbatim
+FSharp.Compiler.Syntax.SynByteStringKind: Boolean Equals(FSharp.Compiler.Syntax.SynByteStringKind)
+FSharp.Compiler.Syntax.SynByteStringKind: Boolean Equals(System.Object)
+FSharp.Compiler.Syntax.SynByteStringKind: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.SynByteStringKind: Boolean IsRegular
+FSharp.Compiler.Syntax.SynByteStringKind: Boolean IsVerbatim
+FSharp.Compiler.Syntax.SynByteStringKind: Boolean get_IsRegular()
+FSharp.Compiler.Syntax.SynByteStringKind: Boolean get_IsVerbatim()
+FSharp.Compiler.Syntax.SynByteStringKind: FSharp.Compiler.Syntax.SynByteStringKind Regular
+FSharp.Compiler.Syntax.SynByteStringKind: FSharp.Compiler.Syntax.SynByteStringKind Verbatim
+FSharp.Compiler.Syntax.SynByteStringKind: FSharp.Compiler.Syntax.SynByteStringKind get_Regular()
+FSharp.Compiler.Syntax.SynByteStringKind: FSharp.Compiler.Syntax.SynByteStringKind get_Verbatim()
+FSharp.Compiler.Syntax.SynByteStringKind: FSharp.Compiler.Syntax.SynByteStringKind+Tags
+FSharp.Compiler.Syntax.SynByteStringKind: Int32 CompareTo(FSharp.Compiler.Syntax.SynByteStringKind)
+FSharp.Compiler.Syntax.SynByteStringKind: Int32 CompareTo(System.Object)
+FSharp.Compiler.Syntax.SynByteStringKind: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.Syntax.SynByteStringKind: Int32 GetHashCode()
+FSharp.Compiler.Syntax.SynByteStringKind: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.SynByteStringKind: Int32 Tag
+FSharp.Compiler.Syntax.SynByteStringKind: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynByteStringKind: System.String ToString()
+FSharp.Compiler.Syntax.SynComponentInfo: Boolean get_preferPostfix()
+FSharp.Compiler.Syntax.SynComponentInfo: Boolean preferPostfix
+FSharp.Compiler.Syntax.SynComponentInfo: FSharp.Compiler.Syntax.SynComponentInfo NewSynComponentInfo(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynTyparDecls], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTypeConstraint], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident], FSharp.Compiler.Xml.PreXmlDoc, Boolean, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynComponentInfo: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynComponentInfo: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynComponentInfo: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynComponentInfo: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynComponentInfo: FSharp.Compiler.Xml.PreXmlDoc get_xmlDoc()
+FSharp.Compiler.Syntax.SynComponentInfo: FSharp.Compiler.Xml.PreXmlDoc xmlDoc
+FSharp.Compiler.Syntax.SynComponentInfo: Int32 Tag
+FSharp.Compiler.Syntax.SynComponentInfo: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynComponentInfo: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] get_longId()
+FSharp.Compiler.Syntax.SynComponentInfo: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] longId
+FSharp.Compiler.Syntax.SynComponentInfo: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] attributes
+FSharp.Compiler.Syntax.SynComponentInfo: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] get_attributes()
+FSharp.Compiler.Syntax.SynComponentInfo: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTypeConstraint] constraints
+FSharp.Compiler.Syntax.SynComponentInfo: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTypeConstraint] get_constraints()
+FSharp.Compiler.Syntax.SynComponentInfo: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] accessibility
+FSharp.Compiler.Syntax.SynComponentInfo: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] get_accessibility()
+FSharp.Compiler.Syntax.SynComponentInfo: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynTyparDecls] get_typeParams()
+FSharp.Compiler.Syntax.SynComponentInfo: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynTyparDecls] typeParams
+FSharp.Compiler.Syntax.SynComponentInfo: System.String ToString()
+FSharp.Compiler.Syntax.SynConst+Bool: Boolean Item
+FSharp.Compiler.Syntax.SynConst+Bool: Boolean get_Item()
+FSharp.Compiler.Syntax.SynConst+Byte: Byte Item
+FSharp.Compiler.Syntax.SynConst+Byte: Byte get_Item()
+FSharp.Compiler.Syntax.SynConst+Bytes: Byte[] bytes
+FSharp.Compiler.Syntax.SynConst+Bytes: Byte[] get_bytes()
+FSharp.Compiler.Syntax.SynConst+Bytes: FSharp.Compiler.Syntax.SynByteStringKind get_synByteStringKind()
+FSharp.Compiler.Syntax.SynConst+Bytes: FSharp.Compiler.Syntax.SynByteStringKind synByteStringKind
+FSharp.Compiler.Syntax.SynConst+Bytes: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynConst+Bytes: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynConst+Char: Char Item
+FSharp.Compiler.Syntax.SynConst+Char: Char get_Item()
+FSharp.Compiler.Syntax.SynConst+Decimal: System.Decimal Item
+FSharp.Compiler.Syntax.SynConst+Decimal: System.Decimal get_Item()
+FSharp.Compiler.Syntax.SynConst+Double: Double Item
+FSharp.Compiler.Syntax.SynConst+Double: Double get_Item()
+FSharp.Compiler.Syntax.SynConst+Int16: Int16 Item
+FSharp.Compiler.Syntax.SynConst+Int16: Int16 get_Item()
+FSharp.Compiler.Syntax.SynConst+Int32: Int32 Item
+FSharp.Compiler.Syntax.SynConst+Int32: Int32 get_Item()
+FSharp.Compiler.Syntax.SynConst+Int64: Int64 Item
+FSharp.Compiler.Syntax.SynConst+Int64: Int64 get_Item()
+FSharp.Compiler.Syntax.SynConst+IntPtr: Int64 Item
+FSharp.Compiler.Syntax.SynConst+IntPtr: Int64 get_Item()
+FSharp.Compiler.Syntax.SynConst+Measure: FSharp.Compiler.Syntax.SynConst constant
+FSharp.Compiler.Syntax.SynConst+Measure: FSharp.Compiler.Syntax.SynConst get_constant()
+FSharp.Compiler.Syntax.SynConst+Measure: FSharp.Compiler.Syntax.SynMeasure Item3
+FSharp.Compiler.Syntax.SynConst+Measure: FSharp.Compiler.Syntax.SynMeasure get_Item3()
+FSharp.Compiler.Syntax.SynConst+Measure: FSharp.Compiler.Text.Range constantRange
+FSharp.Compiler.Syntax.SynConst+Measure: FSharp.Compiler.Text.Range get_constantRange()
+FSharp.Compiler.Syntax.SynConst+SByte: SByte Item
+FSharp.Compiler.Syntax.SynConst+SByte: SByte get_Item()
+FSharp.Compiler.Syntax.SynConst+Single: Single Item
+FSharp.Compiler.Syntax.SynConst+Single: Single get_Item()
+FSharp.Compiler.Syntax.SynConst+SourceIdentifier: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynConst+SourceIdentifier: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynConst+SourceIdentifier: System.String constant
+FSharp.Compiler.Syntax.SynConst+SourceIdentifier: System.String get_constant()
+FSharp.Compiler.Syntax.SynConst+SourceIdentifier: System.String get_value()
+FSharp.Compiler.Syntax.SynConst+SourceIdentifier: System.String value
+FSharp.Compiler.Syntax.SynConst+String: FSharp.Compiler.Syntax.SynStringKind get_synStringKind()
+FSharp.Compiler.Syntax.SynConst+String: FSharp.Compiler.Syntax.SynStringKind synStringKind
+FSharp.Compiler.Syntax.SynConst+String: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynConst+String: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynConst+String: System.String get_text()
+FSharp.Compiler.Syntax.SynConst+String: System.String text
+FSharp.Compiler.Syntax.SynConst+Tags: Int32 Bool
+FSharp.Compiler.Syntax.SynConst+Tags: Int32 Byte
+FSharp.Compiler.Syntax.SynConst+Tags: Int32 Bytes
+FSharp.Compiler.Syntax.SynConst+Tags: Int32 Char
+FSharp.Compiler.Syntax.SynConst+Tags: Int32 Decimal
+FSharp.Compiler.Syntax.SynConst+Tags: Int32 Double
+FSharp.Compiler.Syntax.SynConst+Tags: Int32 Int16
+FSharp.Compiler.Syntax.SynConst+Tags: Int32 Int32
+FSharp.Compiler.Syntax.SynConst+Tags: Int32 Int64
+FSharp.Compiler.Syntax.SynConst+Tags: Int32 IntPtr
+FSharp.Compiler.Syntax.SynConst+Tags: Int32 Measure
+FSharp.Compiler.Syntax.SynConst+Tags: Int32 SByte
+FSharp.Compiler.Syntax.SynConst+Tags: Int32 Single
+FSharp.Compiler.Syntax.SynConst+Tags: Int32 SourceIdentifier
+FSharp.Compiler.Syntax.SynConst+Tags: Int32 String
+FSharp.Compiler.Syntax.SynConst+Tags: Int32 UInt16
+FSharp.Compiler.Syntax.SynConst+Tags: Int32 UInt16s
+FSharp.Compiler.Syntax.SynConst+Tags: Int32 UInt32
+FSharp.Compiler.Syntax.SynConst+Tags: Int32 UInt64
+FSharp.Compiler.Syntax.SynConst+Tags: Int32 UIntPtr
+FSharp.Compiler.Syntax.SynConst+Tags: Int32 Unit
+FSharp.Compiler.Syntax.SynConst+Tags: Int32 UserNum
+FSharp.Compiler.Syntax.SynConst+UInt16: UInt16 Item
+FSharp.Compiler.Syntax.SynConst+UInt16: UInt16 get_Item()
+FSharp.Compiler.Syntax.SynConst+UInt16s: UInt16[] Item
+FSharp.Compiler.Syntax.SynConst+UInt16s: UInt16[] get_Item()
+FSharp.Compiler.Syntax.SynConst+UInt32: UInt32 Item
+FSharp.Compiler.Syntax.SynConst+UInt32: UInt32 get_Item()
+FSharp.Compiler.Syntax.SynConst+UInt64: UInt64 Item
+FSharp.Compiler.Syntax.SynConst+UInt64: UInt64 get_Item()
+FSharp.Compiler.Syntax.SynConst+UIntPtr: UInt64 Item
+FSharp.Compiler.Syntax.SynConst+UIntPtr: UInt64 get_Item()
+FSharp.Compiler.Syntax.SynConst+UserNum: System.String get_suffix()
+FSharp.Compiler.Syntax.SynConst+UserNum: System.String get_value()
+FSharp.Compiler.Syntax.SynConst+UserNum: System.String suffix
+FSharp.Compiler.Syntax.SynConst+UserNum: System.String value
+FSharp.Compiler.Syntax.SynConst: Boolean IsBool
+FSharp.Compiler.Syntax.SynConst: Boolean IsByte
+FSharp.Compiler.Syntax.SynConst: Boolean IsBytes
+FSharp.Compiler.Syntax.SynConst: Boolean IsChar
+FSharp.Compiler.Syntax.SynConst: Boolean IsDecimal
+FSharp.Compiler.Syntax.SynConst: Boolean IsDouble
+FSharp.Compiler.Syntax.SynConst: Boolean IsInt16
+FSharp.Compiler.Syntax.SynConst: Boolean IsInt32
+FSharp.Compiler.Syntax.SynConst: Boolean IsInt64
+FSharp.Compiler.Syntax.SynConst: Boolean IsIntPtr
+FSharp.Compiler.Syntax.SynConst: Boolean IsMeasure
+FSharp.Compiler.Syntax.SynConst: Boolean IsSByte
+FSharp.Compiler.Syntax.SynConst: Boolean IsSingle
+FSharp.Compiler.Syntax.SynConst: Boolean IsSourceIdentifier
+FSharp.Compiler.Syntax.SynConst: Boolean IsString
+FSharp.Compiler.Syntax.SynConst: Boolean IsUInt16
+FSharp.Compiler.Syntax.SynConst: Boolean IsUInt16s
+FSharp.Compiler.Syntax.SynConst: Boolean IsUInt32
+FSharp.Compiler.Syntax.SynConst: Boolean IsUInt64
+FSharp.Compiler.Syntax.SynConst: Boolean IsUIntPtr
+FSharp.Compiler.Syntax.SynConst: Boolean IsUnit
+FSharp.Compiler.Syntax.SynConst: Boolean IsUserNum
+FSharp.Compiler.Syntax.SynConst: Boolean get_IsBool()
+FSharp.Compiler.Syntax.SynConst: Boolean get_IsByte()
+FSharp.Compiler.Syntax.SynConst: Boolean get_IsBytes()
+FSharp.Compiler.Syntax.SynConst: Boolean get_IsChar()
+FSharp.Compiler.Syntax.SynConst: Boolean get_IsDecimal()
+FSharp.Compiler.Syntax.SynConst: Boolean get_IsDouble()
+FSharp.Compiler.Syntax.SynConst: Boolean get_IsInt16()
+FSharp.Compiler.Syntax.SynConst: Boolean get_IsInt32()
+FSharp.Compiler.Syntax.SynConst: Boolean get_IsInt64()
+FSharp.Compiler.Syntax.SynConst: Boolean get_IsIntPtr()
+FSharp.Compiler.Syntax.SynConst: Boolean get_IsMeasure()
+FSharp.Compiler.Syntax.SynConst: Boolean get_IsSByte()
+FSharp.Compiler.Syntax.SynConst: Boolean get_IsSingle()
+FSharp.Compiler.Syntax.SynConst: Boolean get_IsSourceIdentifier()
+FSharp.Compiler.Syntax.SynConst: Boolean get_IsString()
+FSharp.Compiler.Syntax.SynConst: Boolean get_IsUInt16()
+FSharp.Compiler.Syntax.SynConst: Boolean get_IsUInt16s()
+FSharp.Compiler.Syntax.SynConst: Boolean get_IsUInt32()
+FSharp.Compiler.Syntax.SynConst: Boolean get_IsUInt64()
+FSharp.Compiler.Syntax.SynConst: Boolean get_IsUIntPtr()
+FSharp.Compiler.Syntax.SynConst: Boolean get_IsUnit()
+FSharp.Compiler.Syntax.SynConst: Boolean get_IsUserNum()
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst NewBool(Boolean)
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst NewByte(Byte)
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst NewBytes(Byte[], FSharp.Compiler.Syntax.SynByteStringKind, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst NewChar(Char)
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst NewDecimal(System.Decimal)
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst NewDouble(Double)
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst NewInt16(Int16)
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst NewInt32(Int32)
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst NewInt64(Int64)
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst NewIntPtr(Int64)
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst NewMeasure(FSharp.Compiler.Syntax.SynConst, FSharp.Compiler.Text.Range, FSharp.Compiler.Syntax.SynMeasure)
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst NewSByte(SByte)
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst NewSingle(Single)
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst NewSourceIdentifier(System.String, System.String, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst NewString(System.String, FSharp.Compiler.Syntax.SynStringKind, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst NewUInt16(UInt16)
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst NewUInt16s(UInt16[])
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst NewUInt32(UInt32)
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst NewUInt64(UInt64)
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst NewUIntPtr(UInt64)
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst NewUserNum(System.String, System.String)
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst Unit
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst get_Unit()
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst+Bool
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst+Byte
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst+Bytes
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst+Char
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst+Decimal
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst+Double
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst+Int16
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst+Int32
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst+Int64
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst+IntPtr
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst+Measure
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst+SByte
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst+Single
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst+SourceIdentifier
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst+String
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst+Tags
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst+UInt16
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst+UInt16s
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst+UInt32
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst+UInt64
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst+UIntPtr
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Syntax.SynConst+UserNum
+FSharp.Compiler.Syntax.SynConst: FSharp.Compiler.Text.Range Range(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynConst: Int32 Tag
+FSharp.Compiler.Syntax.SynConst: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynConst: System.String ToString()
+FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Syntax.SynEnumCase NewSynEnumCase(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], FSharp.Compiler.Syntax.SynIdent, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Xml.PreXmlDoc, FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynEnumCaseTrivia)
+FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Syntax.SynExpr get_valueExpr()
+FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Syntax.SynExpr valueExpr
+FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Syntax.SynIdent get_ident()
+FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Syntax.SynIdent ident
+FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.SyntaxTrivia.SynEnumCaseTrivia get_trivia()
+FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.SyntaxTrivia.SynEnumCaseTrivia trivia
+FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Xml.PreXmlDoc get_xmlDoc()
+FSharp.Compiler.Syntax.SynEnumCase: FSharp.Compiler.Xml.PreXmlDoc xmlDoc
+FSharp.Compiler.Syntax.SynEnumCase: Int32 Tag
+FSharp.Compiler.Syntax.SynEnumCase: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynEnumCase: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] attributes
+FSharp.Compiler.Syntax.SynEnumCase: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] get_attributes()
+FSharp.Compiler.Syntax.SynEnumCase: System.String ToString()
+FSharp.Compiler.Syntax.SynExceptionDefn: FSharp.Compiler.Syntax.SynExceptionDefn NewSynExceptionDefn(FSharp.Compiler.Syntax.SynExceptionDefnRepr, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExceptionDefn: FSharp.Compiler.Syntax.SynExceptionDefnRepr exnRepr
+FSharp.Compiler.Syntax.SynExceptionDefn: FSharp.Compiler.Syntax.SynExceptionDefnRepr get_exnRepr()
+FSharp.Compiler.Syntax.SynExceptionDefn: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynExceptionDefn: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynExceptionDefn: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExceptionDefn: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExceptionDefn: Int32 Tag
+FSharp.Compiler.Syntax.SynExceptionDefn: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynExceptionDefn: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn] get_members()
+FSharp.Compiler.Syntax.SynExceptionDefn: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn] members
+FSharp.Compiler.Syntax.SynExceptionDefn: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_withKeyword()
+FSharp.Compiler.Syntax.SynExceptionDefn: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] withKeyword
+FSharp.Compiler.Syntax.SynExceptionDefn: System.String ToString()
+FSharp.Compiler.Syntax.SynExceptionDefnRepr: FSharp.Compiler.Syntax.SynExceptionDefnRepr NewSynExceptionDefnRepr(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], FSharp.Compiler.Syntax.SynUnionCase, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident]], FSharp.Compiler.Xml.PreXmlDoc, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExceptionDefnRepr: FSharp.Compiler.Syntax.SynUnionCase caseName
+FSharp.Compiler.Syntax.SynExceptionDefnRepr: FSharp.Compiler.Syntax.SynUnionCase get_caseName()
+FSharp.Compiler.Syntax.SynExceptionDefnRepr: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynExceptionDefnRepr: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynExceptionDefnRepr: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExceptionDefnRepr: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExceptionDefnRepr: FSharp.Compiler.Xml.PreXmlDoc get_xmlDoc()
+FSharp.Compiler.Syntax.SynExceptionDefnRepr: FSharp.Compiler.Xml.PreXmlDoc xmlDoc
+FSharp.Compiler.Syntax.SynExceptionDefnRepr: Int32 Tag
+FSharp.Compiler.Syntax.SynExceptionDefnRepr: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynExceptionDefnRepr: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] attributes
+FSharp.Compiler.Syntax.SynExceptionDefnRepr: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] get_attributes()
+FSharp.Compiler.Syntax.SynExceptionDefnRepr: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] accessibility
+FSharp.Compiler.Syntax.SynExceptionDefnRepr: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] get_accessibility()
+FSharp.Compiler.Syntax.SynExceptionDefnRepr: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident]] get_longId()
+FSharp.Compiler.Syntax.SynExceptionDefnRepr: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident]] longId
+FSharp.Compiler.Syntax.SynExceptionDefnRepr: System.String ToString()
+FSharp.Compiler.Syntax.SynExceptionSig: FSharp.Compiler.Syntax.SynExceptionDefnRepr exnRepr
+FSharp.Compiler.Syntax.SynExceptionSig: FSharp.Compiler.Syntax.SynExceptionDefnRepr get_exnRepr()
+FSharp.Compiler.Syntax.SynExceptionSig: FSharp.Compiler.Syntax.SynExceptionSig NewSynExceptionSig(FSharp.Compiler.Syntax.SynExceptionDefnRepr, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberSig], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExceptionSig: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExceptionSig: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExceptionSig: Int32 Tag
+FSharp.Compiler.Syntax.SynExceptionSig: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynExceptionSig: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberSig] get_members()
+FSharp.Compiler.Syntax.SynExceptionSig: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberSig] members
+FSharp.Compiler.Syntax.SynExceptionSig: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_withKeyword()
+FSharp.Compiler.Syntax.SynExceptionSig: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] withKeyword
+FSharp.Compiler.Syntax.SynExceptionSig: System.String ToString()
+FSharp.Compiler.Syntax.SynExpr+AddressOf: Boolean get_isByref()
+FSharp.Compiler.Syntax.SynExpr+AddressOf: Boolean isByref
+FSharp.Compiler.Syntax.SynExpr+AddressOf: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+AddressOf: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+AddressOf: FSharp.Compiler.Text.Range get_opRange()
+FSharp.Compiler.Syntax.SynExpr+AddressOf: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+AddressOf: FSharp.Compiler.Text.Range opRange
+FSharp.Compiler.Syntax.SynExpr+AddressOf: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+AnonRecd: Boolean get_isStruct()
+FSharp.Compiler.Syntax.SynExpr+AnonRecd: Boolean isStruct
+FSharp.Compiler.Syntax.SynExpr+AnonRecd: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+AnonRecd: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+AnonRecd: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[FSharp.Compiler.Syntax.Ident,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range],FSharp.Compiler.Syntax.SynExpr]] get_recordFields()
+FSharp.Compiler.Syntax.SynExpr+AnonRecd: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[FSharp.Compiler.Syntax.Ident,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range],FSharp.Compiler.Syntax.SynExpr]] recordFields
+FSharp.Compiler.Syntax.SynExpr+AnonRecd: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Syntax.SynExpr,System.Tuple`2[FSharp.Compiler.Text.Range,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Position]]]] copyInfo
+FSharp.Compiler.Syntax.SynExpr+AnonRecd: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Syntax.SynExpr,System.Tuple`2[FSharp.Compiler.Text.Range,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Position]]]] get_copyInfo()
+FSharp.Compiler.Syntax.SynExpr+App: Boolean get_isInfix()
+FSharp.Compiler.Syntax.SynExpr+App: Boolean isInfix
+FSharp.Compiler.Syntax.SynExpr+App: FSharp.Compiler.Syntax.ExprAtomicFlag flag
+FSharp.Compiler.Syntax.SynExpr+App: FSharp.Compiler.Syntax.ExprAtomicFlag get_flag()
+FSharp.Compiler.Syntax.SynExpr+App: FSharp.Compiler.Syntax.SynExpr argExpr
+FSharp.Compiler.Syntax.SynExpr+App: FSharp.Compiler.Syntax.SynExpr funcExpr
+FSharp.Compiler.Syntax.SynExpr+App: FSharp.Compiler.Syntax.SynExpr get_argExpr()
+FSharp.Compiler.Syntax.SynExpr+App: FSharp.Compiler.Syntax.SynExpr get_funcExpr()
+FSharp.Compiler.Syntax.SynExpr+App: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+App: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+ArbitraryAfterError: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+ArbitraryAfterError: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+ArbitraryAfterError: System.String debugStr
+FSharp.Compiler.Syntax.SynExpr+ArbitraryAfterError: System.String get_debugStr()
+FSharp.Compiler.Syntax.SynExpr+ArrayOrList: Boolean get_isArray()
+FSharp.Compiler.Syntax.SynExpr+ArrayOrList: Boolean isArray
+FSharp.Compiler.Syntax.SynExpr+ArrayOrList: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+ArrayOrList: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+ArrayOrList: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynExpr] exprs
+FSharp.Compiler.Syntax.SynExpr+ArrayOrList: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynExpr] get_exprs()
+FSharp.Compiler.Syntax.SynExpr+ArrayOrListComputed: Boolean get_isArray()
+FSharp.Compiler.Syntax.SynExpr+ArrayOrListComputed: Boolean isArray
+FSharp.Compiler.Syntax.SynExpr+ArrayOrListComputed: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+ArrayOrListComputed: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+ArrayOrListComputed: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+ArrayOrListComputed: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+Assert: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+Assert: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+Assert: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+Assert: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+ComputationExpr: Boolean get_hasSeqBuilder()
+FSharp.Compiler.Syntax.SynExpr+ComputationExpr: Boolean hasSeqBuilder
+FSharp.Compiler.Syntax.SynExpr+ComputationExpr: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+ComputationExpr: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+ComputationExpr: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+ComputationExpr: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+Const: FSharp.Compiler.Syntax.SynConst constant
+FSharp.Compiler.Syntax.SynExpr+Const: FSharp.Compiler.Syntax.SynConst get_constant()
+FSharp.Compiler.Syntax.SynExpr+Const: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+Const: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+DebugPoint: Boolean get_isControlFlow()
+FSharp.Compiler.Syntax.SynExpr+DebugPoint: Boolean isControlFlow
+FSharp.Compiler.Syntax.SynExpr+DebugPoint: FSharp.Compiler.Syntax.DebugPointAtLeafExpr debugPoint
+FSharp.Compiler.Syntax.SynExpr+DebugPoint: FSharp.Compiler.Syntax.DebugPointAtLeafExpr get_debugPoint()
+FSharp.Compiler.Syntax.SynExpr+DebugPoint: FSharp.Compiler.Syntax.SynExpr get_innerExpr()
+FSharp.Compiler.Syntax.SynExpr+DebugPoint: FSharp.Compiler.Syntax.SynExpr innerExpr
+FSharp.Compiler.Syntax.SynExpr+DiscardAfterMissingQualificationAfterDot: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+DiscardAfterMissingQualificationAfterDot: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+DiscardAfterMissingQualificationAfterDot: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+DiscardAfterMissingQualificationAfterDot: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+Do: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+Do: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+Do: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+Do: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+DoBang: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+DoBang: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+DoBang: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+DoBang: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+DotGet: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+DotGet: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+DotGet: FSharp.Compiler.Syntax.SynLongIdent get_longDotId()
+FSharp.Compiler.Syntax.SynExpr+DotGet: FSharp.Compiler.Syntax.SynLongIdent longDotId
+FSharp.Compiler.Syntax.SynExpr+DotGet: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+DotGet: FSharp.Compiler.Text.Range get_rangeOfDot()
+FSharp.Compiler.Syntax.SynExpr+DotGet: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+DotGet: FSharp.Compiler.Text.Range rangeOfDot
+FSharp.Compiler.Syntax.SynExpr+DotIndexedGet: FSharp.Compiler.Syntax.SynExpr get_indexArgs()
+FSharp.Compiler.Syntax.SynExpr+DotIndexedGet: FSharp.Compiler.Syntax.SynExpr get_objectExpr()
+FSharp.Compiler.Syntax.SynExpr+DotIndexedGet: FSharp.Compiler.Syntax.SynExpr indexArgs
+FSharp.Compiler.Syntax.SynExpr+DotIndexedGet: FSharp.Compiler.Syntax.SynExpr objectExpr
+FSharp.Compiler.Syntax.SynExpr+DotIndexedGet: FSharp.Compiler.Text.Range dotRange
+FSharp.Compiler.Syntax.SynExpr+DotIndexedGet: FSharp.Compiler.Text.Range get_dotRange()
+FSharp.Compiler.Syntax.SynExpr+DotIndexedGet: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+DotIndexedGet: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+DotIndexedSet: FSharp.Compiler.Syntax.SynExpr get_indexArgs()
+FSharp.Compiler.Syntax.SynExpr+DotIndexedSet: FSharp.Compiler.Syntax.SynExpr get_objectExpr()
+FSharp.Compiler.Syntax.SynExpr+DotIndexedSet: FSharp.Compiler.Syntax.SynExpr get_valueExpr()
+FSharp.Compiler.Syntax.SynExpr+DotIndexedSet: FSharp.Compiler.Syntax.SynExpr indexArgs
+FSharp.Compiler.Syntax.SynExpr+DotIndexedSet: FSharp.Compiler.Syntax.SynExpr objectExpr
+FSharp.Compiler.Syntax.SynExpr+DotIndexedSet: FSharp.Compiler.Syntax.SynExpr valueExpr
+FSharp.Compiler.Syntax.SynExpr+DotIndexedSet: FSharp.Compiler.Text.Range dotRange
+FSharp.Compiler.Syntax.SynExpr+DotIndexedSet: FSharp.Compiler.Text.Range get_dotRange()
+FSharp.Compiler.Syntax.SynExpr+DotIndexedSet: FSharp.Compiler.Text.Range get_leftOfSetRange()
+FSharp.Compiler.Syntax.SynExpr+DotIndexedSet: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+DotIndexedSet: FSharp.Compiler.Text.Range leftOfSetRange
+FSharp.Compiler.Syntax.SynExpr+DotIndexedSet: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+DotNamedIndexedPropertySet: FSharp.Compiler.Syntax.SynExpr argExpr
+FSharp.Compiler.Syntax.SynExpr+DotNamedIndexedPropertySet: FSharp.Compiler.Syntax.SynExpr get_argExpr()
+FSharp.Compiler.Syntax.SynExpr+DotNamedIndexedPropertySet: FSharp.Compiler.Syntax.SynExpr get_rhsExpr()
+FSharp.Compiler.Syntax.SynExpr+DotNamedIndexedPropertySet: FSharp.Compiler.Syntax.SynExpr get_targetExpr()
+FSharp.Compiler.Syntax.SynExpr+DotNamedIndexedPropertySet: FSharp.Compiler.Syntax.SynExpr rhsExpr
+FSharp.Compiler.Syntax.SynExpr+DotNamedIndexedPropertySet: FSharp.Compiler.Syntax.SynExpr targetExpr
+FSharp.Compiler.Syntax.SynExpr+DotNamedIndexedPropertySet: FSharp.Compiler.Syntax.SynLongIdent get_longDotId()
+FSharp.Compiler.Syntax.SynExpr+DotNamedIndexedPropertySet: FSharp.Compiler.Syntax.SynLongIdent longDotId
+FSharp.Compiler.Syntax.SynExpr+DotNamedIndexedPropertySet: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+DotNamedIndexedPropertySet: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+DotSet: FSharp.Compiler.Syntax.SynExpr get_rhsExpr()
+FSharp.Compiler.Syntax.SynExpr+DotSet: FSharp.Compiler.Syntax.SynExpr get_targetExpr()
+FSharp.Compiler.Syntax.SynExpr+DotSet: FSharp.Compiler.Syntax.SynExpr rhsExpr
+FSharp.Compiler.Syntax.SynExpr+DotSet: FSharp.Compiler.Syntax.SynExpr targetExpr
+FSharp.Compiler.Syntax.SynExpr+DotSet: FSharp.Compiler.Syntax.SynLongIdent get_longDotId()
+FSharp.Compiler.Syntax.SynExpr+DotSet: FSharp.Compiler.Syntax.SynLongIdent longDotId
+FSharp.Compiler.Syntax.SynExpr+DotSet: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+DotSet: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+Downcast: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+Downcast: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+Downcast: FSharp.Compiler.Syntax.SynType get_targetType()
+FSharp.Compiler.Syntax.SynExpr+Downcast: FSharp.Compiler.Syntax.SynType targetType
+FSharp.Compiler.Syntax.SynExpr+Downcast: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+Downcast: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+Dynamic: FSharp.Compiler.Syntax.SynExpr argExpr
+FSharp.Compiler.Syntax.SynExpr+Dynamic: FSharp.Compiler.Syntax.SynExpr funcExpr
+FSharp.Compiler.Syntax.SynExpr+Dynamic: FSharp.Compiler.Syntax.SynExpr get_argExpr()
+FSharp.Compiler.Syntax.SynExpr+Dynamic: FSharp.Compiler.Syntax.SynExpr get_funcExpr()
+FSharp.Compiler.Syntax.SynExpr+Dynamic: FSharp.Compiler.Text.Range get_qmark()
+FSharp.Compiler.Syntax.SynExpr+Dynamic: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+Dynamic: FSharp.Compiler.Text.Range qmark
+FSharp.Compiler.Syntax.SynExpr+Dynamic: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+Fixed: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+Fixed: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+Fixed: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+Fixed: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+For: Boolean direction
+FSharp.Compiler.Syntax.SynExpr+For: Boolean get_direction()
+FSharp.Compiler.Syntax.SynExpr+For: FSharp.Compiler.Syntax.DebugPointAtFor forDebugPoint
+FSharp.Compiler.Syntax.SynExpr+For: FSharp.Compiler.Syntax.DebugPointAtFor get_forDebugPoint()
+FSharp.Compiler.Syntax.SynExpr+For: FSharp.Compiler.Syntax.DebugPointAtInOrTo get_toDebugPoint()
+FSharp.Compiler.Syntax.SynExpr+For: FSharp.Compiler.Syntax.DebugPointAtInOrTo toDebugPoint
+FSharp.Compiler.Syntax.SynExpr+For: FSharp.Compiler.Syntax.Ident get_ident()
+FSharp.Compiler.Syntax.SynExpr+For: FSharp.Compiler.Syntax.Ident ident
+FSharp.Compiler.Syntax.SynExpr+For: FSharp.Compiler.Syntax.SynExpr doBody
+FSharp.Compiler.Syntax.SynExpr+For: FSharp.Compiler.Syntax.SynExpr get_doBody()
+FSharp.Compiler.Syntax.SynExpr+For: FSharp.Compiler.Syntax.SynExpr get_identBody()
+FSharp.Compiler.Syntax.SynExpr+For: FSharp.Compiler.Syntax.SynExpr get_toBody()
+FSharp.Compiler.Syntax.SynExpr+For: FSharp.Compiler.Syntax.SynExpr identBody
+FSharp.Compiler.Syntax.SynExpr+For: FSharp.Compiler.Syntax.SynExpr toBody
+FSharp.Compiler.Syntax.SynExpr+For: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+For: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+For: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] equalsRange
+FSharp.Compiler.Syntax.SynExpr+For: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_equalsRange()
+FSharp.Compiler.Syntax.SynExpr+ForEach: Boolean get_isFromSource()
+FSharp.Compiler.Syntax.SynExpr+ForEach: Boolean isFromSource
+FSharp.Compiler.Syntax.SynExpr+ForEach: FSharp.Compiler.Syntax.DebugPointAtFor forDebugPoint
+FSharp.Compiler.Syntax.SynExpr+ForEach: FSharp.Compiler.Syntax.DebugPointAtFor get_forDebugPoint()
+FSharp.Compiler.Syntax.SynExpr+ForEach: FSharp.Compiler.Syntax.DebugPointAtInOrTo get_inDebugPoint()
+FSharp.Compiler.Syntax.SynExpr+ForEach: FSharp.Compiler.Syntax.DebugPointAtInOrTo inDebugPoint
+FSharp.Compiler.Syntax.SynExpr+ForEach: FSharp.Compiler.Syntax.SeqExprOnly get_seqExprOnly()
+FSharp.Compiler.Syntax.SynExpr+ForEach: FSharp.Compiler.Syntax.SeqExprOnly seqExprOnly
+FSharp.Compiler.Syntax.SynExpr+ForEach: FSharp.Compiler.Syntax.SynExpr bodyExpr
+FSharp.Compiler.Syntax.SynExpr+ForEach: FSharp.Compiler.Syntax.SynExpr enumExpr
+FSharp.Compiler.Syntax.SynExpr+ForEach: FSharp.Compiler.Syntax.SynExpr get_bodyExpr()
+FSharp.Compiler.Syntax.SynExpr+ForEach: FSharp.Compiler.Syntax.SynExpr get_enumExpr()
+FSharp.Compiler.Syntax.SynExpr+ForEach: FSharp.Compiler.Syntax.SynPat get_pat()
+FSharp.Compiler.Syntax.SynExpr+ForEach: FSharp.Compiler.Syntax.SynPat pat
+FSharp.Compiler.Syntax.SynExpr+ForEach: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+ForEach: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+FromParseError: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+FromParseError: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+FromParseError: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+FromParseError: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+Ident: FSharp.Compiler.Syntax.Ident get_ident()
+FSharp.Compiler.Syntax.SynExpr+Ident: FSharp.Compiler.Syntax.Ident ident
+FSharp.Compiler.Syntax.SynExpr+IfThenElse: Boolean get_isFromErrorRecovery()
+FSharp.Compiler.Syntax.SynExpr+IfThenElse: Boolean isFromErrorRecovery
+FSharp.Compiler.Syntax.SynExpr+IfThenElse: FSharp.Compiler.Syntax.DebugPointAtBinding get_spIfToThen()
+FSharp.Compiler.Syntax.SynExpr+IfThenElse: FSharp.Compiler.Syntax.DebugPointAtBinding spIfToThen
+FSharp.Compiler.Syntax.SynExpr+IfThenElse: FSharp.Compiler.Syntax.SynExpr get_ifExpr()
+FSharp.Compiler.Syntax.SynExpr+IfThenElse: FSharp.Compiler.Syntax.SynExpr get_thenExpr()
+FSharp.Compiler.Syntax.SynExpr+IfThenElse: FSharp.Compiler.Syntax.SynExpr ifExpr
+FSharp.Compiler.Syntax.SynExpr+IfThenElse: FSharp.Compiler.Syntax.SynExpr thenExpr
+FSharp.Compiler.Syntax.SynExpr+IfThenElse: FSharp.Compiler.SyntaxTrivia.SynExprIfThenElseTrivia get_trivia()
+FSharp.Compiler.Syntax.SynExpr+IfThenElse: FSharp.Compiler.SyntaxTrivia.SynExprIfThenElseTrivia trivia
+FSharp.Compiler.Syntax.SynExpr+IfThenElse: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+IfThenElse: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+IfThenElse: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynExpr] elseExpr
+FSharp.Compiler.Syntax.SynExpr+IfThenElse: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynExpr] get_elseExpr()
+FSharp.Compiler.Syntax.SynExpr+ImplicitZero: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+ImplicitZero: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+IndexFromEnd: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+IndexFromEnd: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+IndexFromEnd: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+IndexFromEnd: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+IndexRange: FSharp.Compiler.Text.Range get_opm()
+FSharp.Compiler.Syntax.SynExpr+IndexRange: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+IndexRange: FSharp.Compiler.Text.Range get_range1()
+FSharp.Compiler.Syntax.SynExpr+IndexRange: FSharp.Compiler.Text.Range get_range2()
+FSharp.Compiler.Syntax.SynExpr+IndexRange: FSharp.Compiler.Text.Range opm
+FSharp.Compiler.Syntax.SynExpr+IndexRange: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+IndexRange: FSharp.Compiler.Text.Range range1
+FSharp.Compiler.Syntax.SynExpr+IndexRange: FSharp.Compiler.Text.Range range2
+FSharp.Compiler.Syntax.SynExpr+IndexRange: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynExpr] expr1
+FSharp.Compiler.Syntax.SynExpr+IndexRange: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynExpr] expr2
+FSharp.Compiler.Syntax.SynExpr+IndexRange: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynExpr] get_expr1()
+FSharp.Compiler.Syntax.SynExpr+IndexRange: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynExpr] get_expr2()
+FSharp.Compiler.Syntax.SynExpr+InferredDowncast: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+InferredDowncast: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+InferredDowncast: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+InferredDowncast: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+InferredUpcast: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+InferredUpcast: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+InferredUpcast: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+InferredUpcast: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+InterpolatedString: FSharp.Compiler.Syntax.SynStringKind get_synStringKind()
+FSharp.Compiler.Syntax.SynExpr+InterpolatedString: FSharp.Compiler.Syntax.SynStringKind synStringKind
+FSharp.Compiler.Syntax.SynExpr+InterpolatedString: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+InterpolatedString: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+InterpolatedString: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynInterpolatedStringPart] contents
+FSharp.Compiler.Syntax.SynExpr+InterpolatedString: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynInterpolatedStringPart] get_contents()
+FSharp.Compiler.Syntax.SynExpr+JoinIn: FSharp.Compiler.Syntax.SynExpr get_lhsExpr()
+FSharp.Compiler.Syntax.SynExpr+JoinIn: FSharp.Compiler.Syntax.SynExpr get_rhsExpr()
+FSharp.Compiler.Syntax.SynExpr+JoinIn: FSharp.Compiler.Syntax.SynExpr lhsExpr
+FSharp.Compiler.Syntax.SynExpr+JoinIn: FSharp.Compiler.Syntax.SynExpr rhsExpr
+FSharp.Compiler.Syntax.SynExpr+JoinIn: FSharp.Compiler.Text.Range get_lhsRange()
+FSharp.Compiler.Syntax.SynExpr+JoinIn: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+JoinIn: FSharp.Compiler.Text.Range lhsRange
+FSharp.Compiler.Syntax.SynExpr+JoinIn: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+Lambda: Boolean fromMethod
+FSharp.Compiler.Syntax.SynExpr+Lambda: Boolean get_fromMethod()
+FSharp.Compiler.Syntax.SynExpr+Lambda: Boolean get_inLambdaSeq()
+FSharp.Compiler.Syntax.SynExpr+Lambda: Boolean inLambdaSeq
+FSharp.Compiler.Syntax.SynExpr+Lambda: FSharp.Compiler.Syntax.SynExpr body
+FSharp.Compiler.Syntax.SynExpr+Lambda: FSharp.Compiler.Syntax.SynExpr get_body()
+FSharp.Compiler.Syntax.SynExpr+Lambda: FSharp.Compiler.Syntax.SynSimplePats args
+FSharp.Compiler.Syntax.SynExpr+Lambda: FSharp.Compiler.Syntax.SynSimplePats get_args()
+FSharp.Compiler.Syntax.SynExpr+Lambda: FSharp.Compiler.SyntaxTrivia.SynExprLambdaTrivia get_trivia()
+FSharp.Compiler.Syntax.SynExpr+Lambda: FSharp.Compiler.SyntaxTrivia.SynExprLambdaTrivia trivia
+FSharp.Compiler.Syntax.SynExpr+Lambda: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+Lambda: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+Lambda: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynPat],FSharp.Compiler.Syntax.SynExpr]] get_parsedData()
+FSharp.Compiler.Syntax.SynExpr+Lambda: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynPat],FSharp.Compiler.Syntax.SynExpr]] parsedData
+FSharp.Compiler.Syntax.SynExpr+Lazy: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+Lazy: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+Lazy: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+Lazy: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+LetOrUse: Boolean get_isRecursive()
+FSharp.Compiler.Syntax.SynExpr+LetOrUse: Boolean get_isUse()
+FSharp.Compiler.Syntax.SynExpr+LetOrUse: Boolean isRecursive
+FSharp.Compiler.Syntax.SynExpr+LetOrUse: Boolean isUse
+FSharp.Compiler.Syntax.SynExpr+LetOrUse: FSharp.Compiler.Syntax.SynExpr body
+FSharp.Compiler.Syntax.SynExpr+LetOrUse: FSharp.Compiler.Syntax.SynExpr get_body()
+FSharp.Compiler.Syntax.SynExpr+LetOrUse: FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseTrivia get_trivia()
+FSharp.Compiler.Syntax.SynExpr+LetOrUse: FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseTrivia trivia
+FSharp.Compiler.Syntax.SynExpr+LetOrUse: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+LetOrUse: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+LetOrUse: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynBinding] bindings
+FSharp.Compiler.Syntax.SynExpr+LetOrUse: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynBinding] get_bindings()
+FSharp.Compiler.Syntax.SynExpr+LetOrUseBang: Boolean get_isFromSource()
+FSharp.Compiler.Syntax.SynExpr+LetOrUseBang: Boolean get_isUse()
+FSharp.Compiler.Syntax.SynExpr+LetOrUseBang: Boolean isFromSource
+FSharp.Compiler.Syntax.SynExpr+LetOrUseBang: Boolean isUse
+FSharp.Compiler.Syntax.SynExpr+LetOrUseBang: FSharp.Compiler.Syntax.DebugPointAtBinding bindDebugPoint
+FSharp.Compiler.Syntax.SynExpr+LetOrUseBang: FSharp.Compiler.Syntax.DebugPointAtBinding get_bindDebugPoint()
+FSharp.Compiler.Syntax.SynExpr+LetOrUseBang: FSharp.Compiler.Syntax.SynExpr body
+FSharp.Compiler.Syntax.SynExpr+LetOrUseBang: FSharp.Compiler.Syntax.SynExpr get_body()
+FSharp.Compiler.Syntax.SynExpr+LetOrUseBang: FSharp.Compiler.Syntax.SynExpr get_rhs()
+FSharp.Compiler.Syntax.SynExpr+LetOrUseBang: FSharp.Compiler.Syntax.SynExpr rhs
+FSharp.Compiler.Syntax.SynExpr+LetOrUseBang: FSharp.Compiler.Syntax.SynPat get_pat()
+FSharp.Compiler.Syntax.SynExpr+LetOrUseBang: FSharp.Compiler.Syntax.SynPat pat
+FSharp.Compiler.Syntax.SynExpr+LetOrUseBang: FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseBangTrivia get_trivia()
+FSharp.Compiler.Syntax.SynExpr+LetOrUseBang: FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseBangTrivia trivia
+FSharp.Compiler.Syntax.SynExpr+LetOrUseBang: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+LetOrUseBang: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+LetOrUseBang: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynExprAndBang] andBangs
+FSharp.Compiler.Syntax.SynExpr+LetOrUseBang: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynExprAndBang] get_andBangs()
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyILAssembly: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyILAssembly: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyILAssembly: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynExpr] args
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyILAssembly: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynExpr] get_args()
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyILAssembly: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynType] get_retTy()
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyILAssembly: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynType] get_typeArgs()
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyILAssembly: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynType] retTy
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyILAssembly: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynType] typeArgs
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyILAssembly: System.Object get_ilCode()
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyILAssembly: System.Object ilCode
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyStaticOptimization: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyStaticOptimization: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyStaticOptimization: FSharp.Compiler.Syntax.SynExpr get_optimizedExpr()
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyStaticOptimization: FSharp.Compiler.Syntax.SynExpr optimizedExpr
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyStaticOptimization: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyStaticOptimization: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyStaticOptimization: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynStaticOptimizationConstraint] constraints
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyStaticOptimization: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynStaticOptimizationConstraint] get_constraints()
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyUnionCaseFieldGet: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyUnionCaseFieldGet: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyUnionCaseFieldGet: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyUnionCaseFieldGet: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyUnionCaseFieldGet: Int32 fieldNum
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyUnionCaseFieldGet: Int32 get_fieldNum()
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyUnionCaseFieldGet: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] get_longId()
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyUnionCaseFieldGet: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] longId
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyUnionCaseFieldSet: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyUnionCaseFieldSet: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyUnionCaseFieldSet: FSharp.Compiler.Syntax.SynExpr get_rhsExpr()
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyUnionCaseFieldSet: FSharp.Compiler.Syntax.SynExpr rhsExpr
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyUnionCaseFieldSet: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyUnionCaseFieldSet: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyUnionCaseFieldSet: Int32 fieldNum
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyUnionCaseFieldSet: Int32 get_fieldNum()
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyUnionCaseFieldSet: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] get_longId()
+FSharp.Compiler.Syntax.SynExpr+LibraryOnlyUnionCaseFieldSet: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] longId
+FSharp.Compiler.Syntax.SynExpr+LongIdent: Boolean get_isOptional()
+FSharp.Compiler.Syntax.SynExpr+LongIdent: Boolean isOptional
+FSharp.Compiler.Syntax.SynExpr+LongIdent: FSharp.Compiler.Syntax.SynLongIdent get_longDotId()
+FSharp.Compiler.Syntax.SynExpr+LongIdent: FSharp.Compiler.Syntax.SynLongIdent longDotId
+FSharp.Compiler.Syntax.SynExpr+LongIdent: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+LongIdent: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+LongIdent: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpRef`1[FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo]] altNameRefCell
+FSharp.Compiler.Syntax.SynExpr+LongIdent: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpRef`1[FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo]] get_altNameRefCell()
+FSharp.Compiler.Syntax.SynExpr+LongIdentSet: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+LongIdentSet: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+LongIdentSet: FSharp.Compiler.Syntax.SynLongIdent get_longDotId()
+FSharp.Compiler.Syntax.SynExpr+LongIdentSet: FSharp.Compiler.Syntax.SynLongIdent longDotId
+FSharp.Compiler.Syntax.SynExpr+LongIdentSet: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+LongIdentSet: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+Match: FSharp.Compiler.Syntax.DebugPointAtBinding get_matchDebugPoint()
+FSharp.Compiler.Syntax.SynExpr+Match: FSharp.Compiler.Syntax.DebugPointAtBinding matchDebugPoint
+FSharp.Compiler.Syntax.SynExpr+Match: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+Match: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+Match: FSharp.Compiler.SyntaxTrivia.SynExprMatchTrivia get_trivia()
+FSharp.Compiler.Syntax.SynExpr+Match: FSharp.Compiler.SyntaxTrivia.SynExprMatchTrivia trivia
+FSharp.Compiler.Syntax.SynExpr+Match: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+Match: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+Match: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMatchClause] clauses
+FSharp.Compiler.Syntax.SynExpr+Match: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMatchClause] get_clauses()
+FSharp.Compiler.Syntax.SynExpr+MatchBang: FSharp.Compiler.Syntax.DebugPointAtBinding get_matchDebugPoint()
+FSharp.Compiler.Syntax.SynExpr+MatchBang: FSharp.Compiler.Syntax.DebugPointAtBinding matchDebugPoint
+FSharp.Compiler.Syntax.SynExpr+MatchBang: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+MatchBang: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+MatchBang: FSharp.Compiler.SyntaxTrivia.SynExprMatchBangTrivia get_trivia()
+FSharp.Compiler.Syntax.SynExpr+MatchBang: FSharp.Compiler.SyntaxTrivia.SynExprMatchBangTrivia trivia
+FSharp.Compiler.Syntax.SynExpr+MatchBang: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+MatchBang: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+MatchBang: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMatchClause] clauses
+FSharp.Compiler.Syntax.SynExpr+MatchBang: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMatchClause] get_clauses()
+FSharp.Compiler.Syntax.SynExpr+MatchLambda: Boolean get_isExnMatch()
+FSharp.Compiler.Syntax.SynExpr+MatchLambda: Boolean isExnMatch
+FSharp.Compiler.Syntax.SynExpr+MatchLambda: FSharp.Compiler.Syntax.DebugPointAtBinding get_matchDebugPoint()
+FSharp.Compiler.Syntax.SynExpr+MatchLambda: FSharp.Compiler.Syntax.DebugPointAtBinding matchDebugPoint
+FSharp.Compiler.Syntax.SynExpr+MatchLambda: FSharp.Compiler.Text.Range get_keywordRange()
+FSharp.Compiler.Syntax.SynExpr+MatchLambda: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+MatchLambda: FSharp.Compiler.Text.Range keywordRange
+FSharp.Compiler.Syntax.SynExpr+MatchLambda: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+MatchLambda: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMatchClause] get_matchClauses()
+FSharp.Compiler.Syntax.SynExpr+MatchLambda: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMatchClause] matchClauses
+FSharp.Compiler.Syntax.SynExpr+NamedIndexedPropertySet: FSharp.Compiler.Syntax.SynExpr expr1
+FSharp.Compiler.Syntax.SynExpr+NamedIndexedPropertySet: FSharp.Compiler.Syntax.SynExpr expr2
+FSharp.Compiler.Syntax.SynExpr+NamedIndexedPropertySet: FSharp.Compiler.Syntax.SynExpr get_expr1()
+FSharp.Compiler.Syntax.SynExpr+NamedIndexedPropertySet: FSharp.Compiler.Syntax.SynExpr get_expr2()
+FSharp.Compiler.Syntax.SynExpr+NamedIndexedPropertySet: FSharp.Compiler.Syntax.SynLongIdent get_longDotId()
+FSharp.Compiler.Syntax.SynExpr+NamedIndexedPropertySet: FSharp.Compiler.Syntax.SynLongIdent longDotId
+FSharp.Compiler.Syntax.SynExpr+NamedIndexedPropertySet: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+NamedIndexedPropertySet: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+New: Boolean get_isProtected()
+FSharp.Compiler.Syntax.SynExpr+New: Boolean isProtected
+FSharp.Compiler.Syntax.SynExpr+New: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+New: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+New: FSharp.Compiler.Syntax.SynType get_targetType()
+FSharp.Compiler.Syntax.SynExpr+New: FSharp.Compiler.Syntax.SynType targetType
+FSharp.Compiler.Syntax.SynExpr+New: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+New: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+Null: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+Null: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+ObjExpr: FSharp.Compiler.Syntax.SynType get_objType()
+FSharp.Compiler.Syntax.SynExpr+ObjExpr: FSharp.Compiler.Syntax.SynType objType
+FSharp.Compiler.Syntax.SynExpr+ObjExpr: FSharp.Compiler.Text.Range get_newExprRange()
+FSharp.Compiler.Syntax.SynExpr+ObjExpr: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+ObjExpr: FSharp.Compiler.Text.Range newExprRange
+FSharp.Compiler.Syntax.SynExpr+ObjExpr: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+ObjExpr: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynBinding] bindings
+FSharp.Compiler.Syntax.SynExpr+ObjExpr: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynBinding] get_bindings()
+FSharp.Compiler.Syntax.SynExpr+ObjExpr: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynInterfaceImpl] extraImpls
+FSharp.Compiler.Syntax.SynExpr+ObjExpr: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynInterfaceImpl] get_extraImpls()
+FSharp.Compiler.Syntax.SynExpr+ObjExpr: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn] get_members()
+FSharp.Compiler.Syntax.SynExpr+ObjExpr: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn] members
+FSharp.Compiler.Syntax.SynExpr+ObjExpr: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_withKeyword()
+FSharp.Compiler.Syntax.SynExpr+ObjExpr: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] withKeyword
+FSharp.Compiler.Syntax.SynExpr+ObjExpr: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Syntax.SynExpr,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident]]] argOptions
+FSharp.Compiler.Syntax.SynExpr+ObjExpr: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Syntax.SynExpr,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident]]] get_argOptions()
+FSharp.Compiler.Syntax.SynExpr+Paren: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+Paren: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+Paren: FSharp.Compiler.Text.Range get_leftParenRange()
+FSharp.Compiler.Syntax.SynExpr+Paren: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+Paren: FSharp.Compiler.Text.Range leftParenRange
+FSharp.Compiler.Syntax.SynExpr+Paren: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+Paren: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_rightParenRange()
+FSharp.Compiler.Syntax.SynExpr+Paren: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] rightParenRange
+FSharp.Compiler.Syntax.SynExpr+Quote: Boolean get_isFromQueryExpression()
+FSharp.Compiler.Syntax.SynExpr+Quote: Boolean get_isRaw()
+FSharp.Compiler.Syntax.SynExpr+Quote: Boolean isFromQueryExpression
+FSharp.Compiler.Syntax.SynExpr+Quote: Boolean isRaw
+FSharp.Compiler.Syntax.SynExpr+Quote: FSharp.Compiler.Syntax.SynExpr get_operator()
+FSharp.Compiler.Syntax.SynExpr+Quote: FSharp.Compiler.Syntax.SynExpr get_quotedExpr()
+FSharp.Compiler.Syntax.SynExpr+Quote: FSharp.Compiler.Syntax.SynExpr operator
+FSharp.Compiler.Syntax.SynExpr+Quote: FSharp.Compiler.Syntax.SynExpr quotedExpr
+FSharp.Compiler.Syntax.SynExpr+Quote: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+Quote: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+Record: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+Record: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+Record: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynExprRecordField] get_recordFields()
+FSharp.Compiler.Syntax.SynExpr+Record: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynExprRecordField] recordFields
+FSharp.Compiler.Syntax.SynExpr+Record: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Syntax.SynExpr,System.Tuple`2[FSharp.Compiler.Text.Range,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Position]]]] copyInfo
+FSharp.Compiler.Syntax.SynExpr+Record: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Syntax.SynExpr,System.Tuple`2[FSharp.Compiler.Text.Range,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Position]]]] get_copyInfo()
+FSharp.Compiler.Syntax.SynExpr+Record: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`5[FSharp.Compiler.Syntax.SynType,FSharp.Compiler.Syntax.SynExpr,FSharp.Compiler.Text.Range,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Text.Range,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Position]]],FSharp.Compiler.Text.Range]] baseInfo
+FSharp.Compiler.Syntax.SynExpr+Record: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`5[FSharp.Compiler.Syntax.SynType,FSharp.Compiler.Syntax.SynExpr,FSharp.Compiler.Text.Range,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Text.Range,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Position]]],FSharp.Compiler.Text.Range]] get_baseInfo()
+FSharp.Compiler.Syntax.SynExpr+Sequential: Boolean get_isTrueSeq()
+FSharp.Compiler.Syntax.SynExpr+Sequential: Boolean isTrueSeq
+FSharp.Compiler.Syntax.SynExpr+Sequential: FSharp.Compiler.Syntax.DebugPointAtSequential debugPoint
+FSharp.Compiler.Syntax.SynExpr+Sequential: FSharp.Compiler.Syntax.DebugPointAtSequential get_debugPoint()
+FSharp.Compiler.Syntax.SynExpr+Sequential: FSharp.Compiler.Syntax.SynExpr expr1
+FSharp.Compiler.Syntax.SynExpr+Sequential: FSharp.Compiler.Syntax.SynExpr expr2
+FSharp.Compiler.Syntax.SynExpr+Sequential: FSharp.Compiler.Syntax.SynExpr get_expr1()
+FSharp.Compiler.Syntax.SynExpr+Sequential: FSharp.Compiler.Syntax.SynExpr get_expr2()
+FSharp.Compiler.Syntax.SynExpr+Sequential: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+Sequential: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+SequentialOrImplicitYield: FSharp.Compiler.Syntax.DebugPointAtSequential debugPoint
+FSharp.Compiler.Syntax.SynExpr+SequentialOrImplicitYield: FSharp.Compiler.Syntax.DebugPointAtSequential get_debugPoint()
+FSharp.Compiler.Syntax.SynExpr+SequentialOrImplicitYield: FSharp.Compiler.Syntax.SynExpr expr1
+FSharp.Compiler.Syntax.SynExpr+SequentialOrImplicitYield: FSharp.Compiler.Syntax.SynExpr expr2
+FSharp.Compiler.Syntax.SynExpr+SequentialOrImplicitYield: FSharp.Compiler.Syntax.SynExpr get_expr1()
+FSharp.Compiler.Syntax.SynExpr+SequentialOrImplicitYield: FSharp.Compiler.Syntax.SynExpr get_expr2()
+FSharp.Compiler.Syntax.SynExpr+SequentialOrImplicitYield: FSharp.Compiler.Syntax.SynExpr get_ifNotStmt()
+FSharp.Compiler.Syntax.SynExpr+SequentialOrImplicitYield: FSharp.Compiler.Syntax.SynExpr ifNotStmt
+FSharp.Compiler.Syntax.SynExpr+SequentialOrImplicitYield: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+SequentialOrImplicitYield: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+Set: FSharp.Compiler.Syntax.SynExpr get_rhsExpr()
+FSharp.Compiler.Syntax.SynExpr+Set: FSharp.Compiler.Syntax.SynExpr get_targetExpr()
+FSharp.Compiler.Syntax.SynExpr+Set: FSharp.Compiler.Syntax.SynExpr rhsExpr
+FSharp.Compiler.Syntax.SynExpr+Set: FSharp.Compiler.Syntax.SynExpr targetExpr
+FSharp.Compiler.Syntax.SynExpr+Set: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+Set: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 AddressOf
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 AnonRecd
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 App
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 ArbitraryAfterError
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 ArrayOrList
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 ArrayOrListComputed
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 Assert
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 ComputationExpr
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 Const
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 DebugPoint
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 DiscardAfterMissingQualificationAfterDot
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 Do
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 DoBang
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 DotGet
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 DotIndexedGet
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 DotIndexedSet
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 DotNamedIndexedPropertySet
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 DotSet
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 Downcast
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 Dynamic
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 Fixed
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 For
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 ForEach
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 FromParseError
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 Ident
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 IfThenElse
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 ImplicitZero
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 IndexFromEnd
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 IndexRange
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 InferredDowncast
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 InferredUpcast
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 InterpolatedString
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 JoinIn
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 Lambda
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 Lazy
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 LetOrUse
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 LetOrUseBang
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 LibraryOnlyILAssembly
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 LibraryOnlyStaticOptimization
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 LibraryOnlyUnionCaseFieldGet
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 LibraryOnlyUnionCaseFieldSet
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 LongIdent
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 LongIdentSet
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 Match
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 MatchBang
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 MatchLambda
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 NamedIndexedPropertySet
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 New
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 Null
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 ObjExpr
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 Paren
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 Quote
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 Record
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 Sequential
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 SequentialOrImplicitYield
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 Set
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 TraitCall
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 TryFinally
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 TryWith
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 Tuple
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 Typar
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 TypeApp
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 TypeTest
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 Typed
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 Upcast
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 While
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 YieldOrReturn
+FSharp.Compiler.Syntax.SynExpr+Tags: Int32 YieldOrReturnFrom
+FSharp.Compiler.Syntax.SynExpr+TraitCall: FSharp.Compiler.Syntax.SynExpr argExpr
+FSharp.Compiler.Syntax.SynExpr+TraitCall: FSharp.Compiler.Syntax.SynExpr get_argExpr()
+FSharp.Compiler.Syntax.SynExpr+TraitCall: FSharp.Compiler.Syntax.SynMemberSig get_traitSig()
+FSharp.Compiler.Syntax.SynExpr+TraitCall: FSharp.Compiler.Syntax.SynMemberSig traitSig
+FSharp.Compiler.Syntax.SynExpr+TraitCall: FSharp.Compiler.Syntax.SynType get_supportTys()
+FSharp.Compiler.Syntax.SynExpr+TraitCall: FSharp.Compiler.Syntax.SynType supportTys
+FSharp.Compiler.Syntax.SynExpr+TraitCall: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+TraitCall: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+TryFinally: FSharp.Compiler.Syntax.DebugPointAtFinally finallyDebugPoint
+FSharp.Compiler.Syntax.SynExpr+TryFinally: FSharp.Compiler.Syntax.DebugPointAtFinally get_finallyDebugPoint()
+FSharp.Compiler.Syntax.SynExpr+TryFinally: FSharp.Compiler.Syntax.DebugPointAtTry get_tryDebugPoint()
+FSharp.Compiler.Syntax.SynExpr+TryFinally: FSharp.Compiler.Syntax.DebugPointAtTry tryDebugPoint
+FSharp.Compiler.Syntax.SynExpr+TryFinally: FSharp.Compiler.Syntax.SynExpr finallyExpr
+FSharp.Compiler.Syntax.SynExpr+TryFinally: FSharp.Compiler.Syntax.SynExpr get_finallyExpr()
+FSharp.Compiler.Syntax.SynExpr+TryFinally: FSharp.Compiler.Syntax.SynExpr get_tryExpr()
+FSharp.Compiler.Syntax.SynExpr+TryFinally: FSharp.Compiler.Syntax.SynExpr tryExpr
+FSharp.Compiler.Syntax.SynExpr+TryFinally: FSharp.Compiler.SyntaxTrivia.SynExprTryFinallyTrivia get_trivia()
+FSharp.Compiler.Syntax.SynExpr+TryFinally: FSharp.Compiler.SyntaxTrivia.SynExprTryFinallyTrivia trivia
+FSharp.Compiler.Syntax.SynExpr+TryFinally: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+TryFinally: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+TryWith: FSharp.Compiler.Syntax.DebugPointAtTry get_tryDebugPoint()
+FSharp.Compiler.Syntax.SynExpr+TryWith: FSharp.Compiler.Syntax.DebugPointAtTry tryDebugPoint
+FSharp.Compiler.Syntax.SynExpr+TryWith: FSharp.Compiler.Syntax.DebugPointAtWith get_withDebugPoint()
+FSharp.Compiler.Syntax.SynExpr+TryWith: FSharp.Compiler.Syntax.DebugPointAtWith withDebugPoint
+FSharp.Compiler.Syntax.SynExpr+TryWith: FSharp.Compiler.Syntax.SynExpr get_tryExpr()
+FSharp.Compiler.Syntax.SynExpr+TryWith: FSharp.Compiler.Syntax.SynExpr tryExpr
+FSharp.Compiler.Syntax.SynExpr+TryWith: FSharp.Compiler.SyntaxTrivia.SynExprTryWithTrivia get_trivia()
+FSharp.Compiler.Syntax.SynExpr+TryWith: FSharp.Compiler.SyntaxTrivia.SynExprTryWithTrivia trivia
+FSharp.Compiler.Syntax.SynExpr+TryWith: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+TryWith: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+TryWith: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMatchClause] get_withCases()
+FSharp.Compiler.Syntax.SynExpr+TryWith: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMatchClause] withCases
+FSharp.Compiler.Syntax.SynExpr+Tuple: Boolean get_isStruct()
+FSharp.Compiler.Syntax.SynExpr+Tuple: Boolean isStruct
+FSharp.Compiler.Syntax.SynExpr+Tuple: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+Tuple: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+Tuple: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynExpr] exprs
+FSharp.Compiler.Syntax.SynExpr+Tuple: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynExpr] get_exprs()
+FSharp.Compiler.Syntax.SynExpr+Tuple: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.Range] commaRanges
+FSharp.Compiler.Syntax.SynExpr+Tuple: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.Range] get_commaRanges()
+FSharp.Compiler.Syntax.SynExpr+Typar: FSharp.Compiler.Syntax.SynTypar get_typar()
+FSharp.Compiler.Syntax.SynExpr+Typar: FSharp.Compiler.Syntax.SynTypar typar
+FSharp.Compiler.Syntax.SynExpr+Typar: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+Typar: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+TypeApp: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+TypeApp: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+TypeApp: FSharp.Compiler.Text.Range get_lessRange()
+FSharp.Compiler.Syntax.SynExpr+TypeApp: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+TypeApp: FSharp.Compiler.Text.Range get_typeArgsRange()
+FSharp.Compiler.Syntax.SynExpr+TypeApp: FSharp.Compiler.Text.Range lessRange
+FSharp.Compiler.Syntax.SynExpr+TypeApp: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+TypeApp: FSharp.Compiler.Text.Range typeArgsRange
+FSharp.Compiler.Syntax.SynExpr+TypeApp: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynType] get_typeArgs()
+FSharp.Compiler.Syntax.SynExpr+TypeApp: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynType] typeArgs
+FSharp.Compiler.Syntax.SynExpr+TypeApp: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.Range] commaRanges
+FSharp.Compiler.Syntax.SynExpr+TypeApp: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.Range] get_commaRanges()
+FSharp.Compiler.Syntax.SynExpr+TypeApp: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_greaterRange()
+FSharp.Compiler.Syntax.SynExpr+TypeApp: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] greaterRange
+FSharp.Compiler.Syntax.SynExpr+TypeTest: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+TypeTest: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+TypeTest: FSharp.Compiler.Syntax.SynType get_targetType()
+FSharp.Compiler.Syntax.SynExpr+TypeTest: FSharp.Compiler.Syntax.SynType targetType
+FSharp.Compiler.Syntax.SynExpr+TypeTest: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+TypeTest: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+Typed: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+Typed: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+Typed: FSharp.Compiler.Syntax.SynType get_targetType()
+FSharp.Compiler.Syntax.SynExpr+Typed: FSharp.Compiler.Syntax.SynType targetType
+FSharp.Compiler.Syntax.SynExpr+Typed: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+Typed: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+Upcast: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+Upcast: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+Upcast: FSharp.Compiler.Syntax.SynType get_targetType()
+FSharp.Compiler.Syntax.SynExpr+Upcast: FSharp.Compiler.Syntax.SynType targetType
+FSharp.Compiler.Syntax.SynExpr+Upcast: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+Upcast: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+While: FSharp.Compiler.Syntax.DebugPointAtWhile get_whileDebugPoint()
+FSharp.Compiler.Syntax.SynExpr+While: FSharp.Compiler.Syntax.DebugPointAtWhile whileDebugPoint
+FSharp.Compiler.Syntax.SynExpr+While: FSharp.Compiler.Syntax.SynExpr doExpr
+FSharp.Compiler.Syntax.SynExpr+While: FSharp.Compiler.Syntax.SynExpr get_doExpr()
+FSharp.Compiler.Syntax.SynExpr+While: FSharp.Compiler.Syntax.SynExpr get_whileExpr()
+FSharp.Compiler.Syntax.SynExpr+While: FSharp.Compiler.Syntax.SynExpr whileExpr
+FSharp.Compiler.Syntax.SynExpr+While: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+While: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+YieldOrReturn: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+YieldOrReturn: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+YieldOrReturn: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+YieldOrReturn: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+YieldOrReturn: System.Tuple`2[System.Boolean,System.Boolean] flags
+FSharp.Compiler.Syntax.SynExpr+YieldOrReturn: System.Tuple`2[System.Boolean,System.Boolean] get_flags()
+FSharp.Compiler.Syntax.SynExpr+YieldOrReturnFrom: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynExpr+YieldOrReturnFrom: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynExpr+YieldOrReturnFrom: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExpr+YieldOrReturnFrom: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExpr+YieldOrReturnFrom: System.Tuple`2[System.Boolean,System.Boolean] flags
+FSharp.Compiler.Syntax.SynExpr+YieldOrReturnFrom: System.Tuple`2[System.Boolean,System.Boolean] get_flags()
+FSharp.Compiler.Syntax.SynExpr: Boolean IsAddressOf
+FSharp.Compiler.Syntax.SynExpr: Boolean IsAnonRecd
+FSharp.Compiler.Syntax.SynExpr: Boolean IsApp
+FSharp.Compiler.Syntax.SynExpr: Boolean IsArbExprAndThusAlreadyReportedError
+FSharp.Compiler.Syntax.SynExpr: Boolean IsArbitraryAfterError
+FSharp.Compiler.Syntax.SynExpr: Boolean IsArrayOrList
+FSharp.Compiler.Syntax.SynExpr: Boolean IsArrayOrListComputed
+FSharp.Compiler.Syntax.SynExpr: Boolean IsAssert
+FSharp.Compiler.Syntax.SynExpr: Boolean IsComputationExpr
+FSharp.Compiler.Syntax.SynExpr: Boolean IsConst
+FSharp.Compiler.Syntax.SynExpr: Boolean IsDebugPoint
+FSharp.Compiler.Syntax.SynExpr: Boolean IsDiscardAfterMissingQualificationAfterDot
+FSharp.Compiler.Syntax.SynExpr: Boolean IsDo
+FSharp.Compiler.Syntax.SynExpr: Boolean IsDoBang
+FSharp.Compiler.Syntax.SynExpr: Boolean IsDotGet
+FSharp.Compiler.Syntax.SynExpr: Boolean IsDotIndexedGet
+FSharp.Compiler.Syntax.SynExpr: Boolean IsDotIndexedSet
+FSharp.Compiler.Syntax.SynExpr: Boolean IsDotNamedIndexedPropertySet
+FSharp.Compiler.Syntax.SynExpr: Boolean IsDotSet
+FSharp.Compiler.Syntax.SynExpr: Boolean IsDowncast
+FSharp.Compiler.Syntax.SynExpr: Boolean IsDynamic
+FSharp.Compiler.Syntax.SynExpr: Boolean IsFixed
+FSharp.Compiler.Syntax.SynExpr: Boolean IsFor
+FSharp.Compiler.Syntax.SynExpr: Boolean IsForEach
+FSharp.Compiler.Syntax.SynExpr: Boolean IsFromParseError
+FSharp.Compiler.Syntax.SynExpr: Boolean IsIdent
+FSharp.Compiler.Syntax.SynExpr: Boolean IsIfThenElse
+FSharp.Compiler.Syntax.SynExpr: Boolean IsImplicitZero
+FSharp.Compiler.Syntax.SynExpr: Boolean IsIndexFromEnd
+FSharp.Compiler.Syntax.SynExpr: Boolean IsIndexRange
+FSharp.Compiler.Syntax.SynExpr: Boolean IsInferredDowncast
+FSharp.Compiler.Syntax.SynExpr: Boolean IsInferredUpcast
+FSharp.Compiler.Syntax.SynExpr: Boolean IsInterpolatedString
+FSharp.Compiler.Syntax.SynExpr: Boolean IsJoinIn
+FSharp.Compiler.Syntax.SynExpr: Boolean IsLambda
+FSharp.Compiler.Syntax.SynExpr: Boolean IsLazy
+FSharp.Compiler.Syntax.SynExpr: Boolean IsLetOrUse
+FSharp.Compiler.Syntax.SynExpr: Boolean IsLetOrUseBang
+FSharp.Compiler.Syntax.SynExpr: Boolean IsLibraryOnlyILAssembly
+FSharp.Compiler.Syntax.SynExpr: Boolean IsLibraryOnlyStaticOptimization
+FSharp.Compiler.Syntax.SynExpr: Boolean IsLibraryOnlyUnionCaseFieldGet
+FSharp.Compiler.Syntax.SynExpr: Boolean IsLibraryOnlyUnionCaseFieldSet
+FSharp.Compiler.Syntax.SynExpr: Boolean IsLongIdent
+FSharp.Compiler.Syntax.SynExpr: Boolean IsLongIdentSet
+FSharp.Compiler.Syntax.SynExpr: Boolean IsMatch
+FSharp.Compiler.Syntax.SynExpr: Boolean IsMatchBang
+FSharp.Compiler.Syntax.SynExpr: Boolean IsMatchLambda
+FSharp.Compiler.Syntax.SynExpr: Boolean IsNamedIndexedPropertySet
+FSharp.Compiler.Syntax.SynExpr: Boolean IsNew
+FSharp.Compiler.Syntax.SynExpr: Boolean IsNull
+FSharp.Compiler.Syntax.SynExpr: Boolean IsObjExpr
+FSharp.Compiler.Syntax.SynExpr: Boolean IsParen
+FSharp.Compiler.Syntax.SynExpr: Boolean IsQuote
+FSharp.Compiler.Syntax.SynExpr: Boolean IsRecord
+FSharp.Compiler.Syntax.SynExpr: Boolean IsSequential
+FSharp.Compiler.Syntax.SynExpr: Boolean IsSequentialOrImplicitYield
+FSharp.Compiler.Syntax.SynExpr: Boolean IsSet
+FSharp.Compiler.Syntax.SynExpr: Boolean IsTraitCall
+FSharp.Compiler.Syntax.SynExpr: Boolean IsTryFinally
+FSharp.Compiler.Syntax.SynExpr: Boolean IsTryWith
+FSharp.Compiler.Syntax.SynExpr: Boolean IsTuple
+FSharp.Compiler.Syntax.SynExpr: Boolean IsTypar
+FSharp.Compiler.Syntax.SynExpr: Boolean IsTypeApp
+FSharp.Compiler.Syntax.SynExpr: Boolean IsTypeTest
+FSharp.Compiler.Syntax.SynExpr: Boolean IsTyped
+FSharp.Compiler.Syntax.SynExpr: Boolean IsUpcast
+FSharp.Compiler.Syntax.SynExpr: Boolean IsWhile
+FSharp.Compiler.Syntax.SynExpr: Boolean IsYieldOrReturn
+FSharp.Compiler.Syntax.SynExpr: Boolean IsYieldOrReturnFrom
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsAddressOf()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsAnonRecd()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsApp()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsArbExprAndThusAlreadyReportedError()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsArbitraryAfterError()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsArrayOrList()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsArrayOrListComputed()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsAssert()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsComputationExpr()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsConst()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsDebugPoint()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsDiscardAfterMissingQualificationAfterDot()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsDo()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsDoBang()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsDotGet()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsDotIndexedGet()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsDotIndexedSet()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsDotNamedIndexedPropertySet()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsDotSet()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsDowncast()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsDynamic()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsFixed()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsFor()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsForEach()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsFromParseError()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsIdent()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsIfThenElse()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsImplicitZero()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsIndexFromEnd()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsIndexRange()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsInferredDowncast()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsInferredUpcast()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsInterpolatedString()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsJoinIn()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsLambda()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsLazy()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsLetOrUse()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsLetOrUseBang()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsLibraryOnlyILAssembly()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsLibraryOnlyStaticOptimization()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsLibraryOnlyUnionCaseFieldGet()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsLibraryOnlyUnionCaseFieldSet()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsLongIdent()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsLongIdentSet()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsMatch()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsMatchBang()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsMatchLambda()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsNamedIndexedPropertySet()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsNew()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsNull()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsObjExpr()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsParen()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsQuote()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsRecord()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsSequential()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsSequentialOrImplicitYield()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsSet()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsTraitCall()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsTryFinally()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsTryWith()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsTuple()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsTypar()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsTypeApp()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsTypeTest()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsTyped()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsUpcast()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsWhile()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsYieldOrReturn()
+FSharp.Compiler.Syntax.SynExpr: Boolean get_IsYieldOrReturnFrom()
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewAddressOf(Boolean, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewAnonRecd(Boolean, Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Syntax.SynExpr,System.Tuple`2[FSharp.Compiler.Text.Range,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Position]]]], Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[FSharp.Compiler.Syntax.Ident,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range],FSharp.Compiler.Syntax.SynExpr]], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewApp(FSharp.Compiler.Syntax.ExprAtomicFlag, Boolean, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewArbitraryAfterError(System.String, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewArrayOrList(Boolean, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynExpr], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewArrayOrListComputed(Boolean, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewAssert(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewComputationExpr(Boolean, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewConst(FSharp.Compiler.Syntax.SynConst, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewDebugPoint(FSharp.Compiler.Syntax.DebugPointAtLeafExpr, Boolean, FSharp.Compiler.Syntax.SynExpr)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewDiscardAfterMissingQualificationAfterDot(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewDo(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewDoBang(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewDotGet(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range, FSharp.Compiler.Syntax.SynLongIdent, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewDotIndexedGet(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewDotIndexedSet(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewDotNamedIndexedPropertySet(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Syntax.SynLongIdent, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewDotSet(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Syntax.SynLongIdent, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewDowncast(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewDynamic(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewFixed(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewFor(FSharp.Compiler.Syntax.DebugPointAtFor, FSharp.Compiler.Syntax.DebugPointAtInOrTo, FSharp.Compiler.Syntax.Ident, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], FSharp.Compiler.Syntax.SynExpr, Boolean, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewForEach(FSharp.Compiler.Syntax.DebugPointAtFor, FSharp.Compiler.Syntax.DebugPointAtInOrTo, FSharp.Compiler.Syntax.SeqExprOnly, Boolean, FSharp.Compiler.Syntax.SynPat, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewFromParseError(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewIdent(FSharp.Compiler.Syntax.Ident)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewIfThenElse(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Syntax.SynExpr, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynExpr], FSharp.Compiler.Syntax.DebugPointAtBinding, Boolean, FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynExprIfThenElseTrivia)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewImplicitZero(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewIndexFromEnd(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewIndexRange(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynExpr], FSharp.Compiler.Text.Range, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynExpr], FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewInferredDowncast(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewInferredUpcast(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewInterpolatedString(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynInterpolatedStringPart], FSharp.Compiler.Syntax.SynStringKind, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewJoinIn(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewLambda(Boolean, Boolean, FSharp.Compiler.Syntax.SynSimplePats, FSharp.Compiler.Syntax.SynExpr, Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynPat],FSharp.Compiler.Syntax.SynExpr]], FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynExprLambdaTrivia)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewLazy(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewLetOrUse(Boolean, Boolean, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynBinding], FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseTrivia)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewLetOrUseBang(FSharp.Compiler.Syntax.DebugPointAtBinding, Boolean, Boolean, FSharp.Compiler.Syntax.SynPat, FSharp.Compiler.Syntax.SynExpr, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynExprAndBang], FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseBangTrivia)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewLibraryOnlyILAssembly(System.Object, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynType], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynExpr], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynType], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewLibraryOnlyStaticOptimization(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynStaticOptimizationConstraint], FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewLibraryOnlyUnionCaseFieldGet(FSharp.Compiler.Syntax.SynExpr, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident], Int32, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewLibraryOnlyUnionCaseFieldSet(FSharp.Compiler.Syntax.SynExpr, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident], Int32, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewLongIdent(Boolean, FSharp.Compiler.Syntax.SynLongIdent, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpRef`1[FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo]], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewLongIdentSet(FSharp.Compiler.Syntax.SynLongIdent, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewMatch(FSharp.Compiler.Syntax.DebugPointAtBinding, FSharp.Compiler.Syntax.SynExpr, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMatchClause], FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynExprMatchTrivia)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewMatchBang(FSharp.Compiler.Syntax.DebugPointAtBinding, FSharp.Compiler.Syntax.SynExpr, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMatchClause], FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynExprMatchBangTrivia)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewMatchLambda(Boolean, FSharp.Compiler.Text.Range, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMatchClause], FSharp.Compiler.Syntax.DebugPointAtBinding, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewNamedIndexedPropertySet(FSharp.Compiler.Syntax.SynLongIdent, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewNew(Boolean, FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewNull(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewObjExpr(FSharp.Compiler.Syntax.SynType, Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Syntax.SynExpr,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident]]], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynBinding], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynInterfaceImpl], FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewParen(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewQuote(FSharp.Compiler.Syntax.SynExpr, Boolean, FSharp.Compiler.Syntax.SynExpr, Boolean, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewRecord(Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`5[FSharp.Compiler.Syntax.SynType,FSharp.Compiler.Syntax.SynExpr,FSharp.Compiler.Text.Range,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Text.Range,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Position]]],FSharp.Compiler.Text.Range]], Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Syntax.SynExpr,System.Tuple`2[FSharp.Compiler.Text.Range,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Position]]]], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynExprRecordField], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewSequential(FSharp.Compiler.Syntax.DebugPointAtSequential, Boolean, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewSequentialOrImplicitYield(FSharp.Compiler.Syntax.DebugPointAtSequential, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewSet(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewTraitCall(FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Syntax.SynMemberSig, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewTryFinally(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range, FSharp.Compiler.Syntax.DebugPointAtTry, FSharp.Compiler.Syntax.DebugPointAtFinally, FSharp.Compiler.SyntaxTrivia.SynExprTryFinallyTrivia)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewTryWith(FSharp.Compiler.Syntax.SynExpr, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMatchClause], FSharp.Compiler.Text.Range, FSharp.Compiler.Syntax.DebugPointAtTry, FSharp.Compiler.Syntax.DebugPointAtWith, FSharp.Compiler.SyntaxTrivia.SynExprTryWithTrivia)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewTuple(Boolean, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynExpr], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.Range], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewTypar(FSharp.Compiler.Syntax.SynTypar, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewTypeApp(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynType], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewTypeTest(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewTyped(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewUpcast(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewWhile(FSharp.Compiler.Syntax.DebugPointAtWhile, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewYieldOrReturn(System.Tuple`2[System.Boolean,System.Boolean], FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr NewYieldOrReturnFrom(System.Tuple`2[System.Boolean,System.Boolean], FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+AddressOf
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+AnonRecd
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+App
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+ArbitraryAfterError
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+ArrayOrList
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+ArrayOrListComputed
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+Assert
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+ComputationExpr
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+Const
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+DebugPoint
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+DiscardAfterMissingQualificationAfterDot
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+Do
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+DoBang
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+DotGet
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+DotIndexedGet
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+DotIndexedSet
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+DotNamedIndexedPropertySet
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+DotSet
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+Downcast
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+Dynamic
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+Fixed
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+For
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+ForEach
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+FromParseError
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+Ident
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+IfThenElse
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+ImplicitZero
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+IndexFromEnd
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+IndexRange
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+InferredDowncast
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+InferredUpcast
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+InterpolatedString
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+JoinIn
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+Lambda
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+Lazy
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+LetOrUse
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+LetOrUseBang
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+LibraryOnlyILAssembly
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+LibraryOnlyStaticOptimization
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+LibraryOnlyUnionCaseFieldGet
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+LibraryOnlyUnionCaseFieldSet
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+LongIdent
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+LongIdentSet
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+Match
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+MatchBang
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+MatchLambda
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+NamedIndexedPropertySet
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+New
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+Null
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+ObjExpr
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+Paren
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+Quote
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+Record
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+Sequential
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+SequentialOrImplicitYield
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+Set
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+Tags
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+TraitCall
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+TryFinally
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+TryWith
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+Tuple
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+Typar
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+TypeApp
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+TypeTest
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+Typed
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+Upcast
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+While
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+YieldOrReturn
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Syntax.SynExpr+YieldOrReturnFrom
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Text.Range RangeOfFirstPortion
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Text.Range RangeWithoutAnyExtraDot
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Text.Range get_RangeOfFirstPortion()
+FSharp.Compiler.Syntax.SynExpr: FSharp.Compiler.Text.Range get_RangeWithoutAnyExtraDot()
+FSharp.Compiler.Syntax.SynExpr: Int32 Tag
+FSharp.Compiler.Syntax.SynExpr: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynExpr: System.String ToString()
+FSharp.Compiler.Syntax.SynExprAndBang: Boolean get_isFromSource()
+FSharp.Compiler.Syntax.SynExprAndBang: Boolean get_isUse()
+FSharp.Compiler.Syntax.SynExprAndBang: Boolean isFromSource
+FSharp.Compiler.Syntax.SynExprAndBang: Boolean isUse
+FSharp.Compiler.Syntax.SynExprAndBang: FSharp.Compiler.Syntax.DebugPointAtBinding debugPoint
+FSharp.Compiler.Syntax.SynExprAndBang: FSharp.Compiler.Syntax.DebugPointAtBinding get_debugPoint()
+FSharp.Compiler.Syntax.SynExprAndBang: FSharp.Compiler.Syntax.SynExpr body
+FSharp.Compiler.Syntax.SynExprAndBang: FSharp.Compiler.Syntax.SynExpr get_body()
+FSharp.Compiler.Syntax.SynExprAndBang: FSharp.Compiler.Syntax.SynExprAndBang NewSynExprAndBang(FSharp.Compiler.Syntax.DebugPointAtBinding, Boolean, Boolean, FSharp.Compiler.Syntax.SynPat, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynExprAndBangTrivia)
+FSharp.Compiler.Syntax.SynExprAndBang: FSharp.Compiler.Syntax.SynPat get_pat()
+FSharp.Compiler.Syntax.SynExprAndBang: FSharp.Compiler.Syntax.SynPat pat
+FSharp.Compiler.Syntax.SynExprAndBang: FSharp.Compiler.SyntaxTrivia.SynExprAndBangTrivia get_trivia()
+FSharp.Compiler.Syntax.SynExprAndBang: FSharp.Compiler.SyntaxTrivia.SynExprAndBangTrivia trivia
+FSharp.Compiler.Syntax.SynExprAndBang: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynExprAndBang: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynExprAndBang: Int32 Tag
+FSharp.Compiler.Syntax.SynExprAndBang: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynExprAndBang: System.String ToString()
+FSharp.Compiler.Syntax.SynExprRecordField: FSharp.Compiler.Syntax.SynExprRecordField NewSynExprRecordField(System.Tuple`2[FSharp.Compiler.Syntax.SynLongIdent,System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynExpr], Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Text.Range,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Position]]])
+FSharp.Compiler.Syntax.SynExprRecordField: Int32 Tag
+FSharp.Compiler.Syntax.SynExprRecordField: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynExprRecordField: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynExpr] expr
+FSharp.Compiler.Syntax.SynExprRecordField: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynExpr] get_expr()
+FSharp.Compiler.Syntax.SynExprRecordField: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] equalsRange
+FSharp.Compiler.Syntax.SynExprRecordField: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_equalsRange()
+FSharp.Compiler.Syntax.SynExprRecordField: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Text.Range,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Position]]] blockSeparator
+FSharp.Compiler.Syntax.SynExprRecordField: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[FSharp.Compiler.Text.Range,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Position]]] get_blockSeparator()
+FSharp.Compiler.Syntax.SynExprRecordField: System.String ToString()
+FSharp.Compiler.Syntax.SynExprRecordField: System.Tuple`2[FSharp.Compiler.Syntax.SynLongIdent,System.Boolean] fieldName
+FSharp.Compiler.Syntax.SynExprRecordField: System.Tuple`2[FSharp.Compiler.Syntax.SynLongIdent,System.Boolean] get_fieldName()
+FSharp.Compiler.Syntax.SynField: Boolean get_isMutable()
+FSharp.Compiler.Syntax.SynField: Boolean get_isStatic()
+FSharp.Compiler.Syntax.SynField: Boolean isMutable
+FSharp.Compiler.Syntax.SynField: Boolean isStatic
+FSharp.Compiler.Syntax.SynField: FSharp.Compiler.Syntax.SynField NewSynField(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], Boolean, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident], FSharp.Compiler.Syntax.SynType, Boolean, FSharp.Compiler.Xml.PreXmlDoc, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess], FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynFieldTrivia)
+FSharp.Compiler.Syntax.SynField: FSharp.Compiler.Syntax.SynType fieldType
+FSharp.Compiler.Syntax.SynField: FSharp.Compiler.Syntax.SynType get_fieldType()
+FSharp.Compiler.Syntax.SynField: FSharp.Compiler.SyntaxTrivia.SynFieldTrivia get_trivia()
+FSharp.Compiler.Syntax.SynField: FSharp.Compiler.SyntaxTrivia.SynFieldTrivia trivia
+FSharp.Compiler.Syntax.SynField: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynField: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynField: FSharp.Compiler.Xml.PreXmlDoc get_xmlDoc()
+FSharp.Compiler.Syntax.SynField: FSharp.Compiler.Xml.PreXmlDoc xmlDoc
+FSharp.Compiler.Syntax.SynField: Int32 Tag
+FSharp.Compiler.Syntax.SynField: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynField: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] attributes
+FSharp.Compiler.Syntax.SynField: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] get_attributes()
+FSharp.Compiler.Syntax.SynField: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] get_idOpt()
+FSharp.Compiler.Syntax.SynField: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] idOpt
+FSharp.Compiler.Syntax.SynField: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] accessibility
+FSharp.Compiler.Syntax.SynField: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] get_accessibility()
+FSharp.Compiler.Syntax.SynField: System.String ToString()
+FSharp.Compiler.Syntax.SynIdent: FSharp.Compiler.Syntax.Ident get_ident()
+FSharp.Compiler.Syntax.SynIdent: FSharp.Compiler.Syntax.Ident ident
+FSharp.Compiler.Syntax.SynIdent: FSharp.Compiler.Syntax.SynIdent NewSynIdent(FSharp.Compiler.Syntax.Ident, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.IdentTrivia])
+FSharp.Compiler.Syntax.SynIdent: Int32 Tag
+FSharp.Compiler.Syntax.SynIdent: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynIdent: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.IdentTrivia] get_trivia()
+FSharp.Compiler.Syntax.SynIdent: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.IdentTrivia] trivia
+FSharp.Compiler.Syntax.SynIdent: System.String ToString()
+FSharp.Compiler.Syntax.SynInterfaceImpl: FSharp.Compiler.Syntax.SynInterfaceImpl NewSynInterfaceImpl(FSharp.Compiler.Syntax.SynType, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynBinding], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynInterfaceImpl: FSharp.Compiler.Syntax.SynType get_interfaceTy()
+FSharp.Compiler.Syntax.SynInterfaceImpl: FSharp.Compiler.Syntax.SynType interfaceTy
+FSharp.Compiler.Syntax.SynInterfaceImpl: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynInterfaceImpl: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynInterfaceImpl: Int32 Tag
+FSharp.Compiler.Syntax.SynInterfaceImpl: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynInterfaceImpl: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynBinding] bindings
+FSharp.Compiler.Syntax.SynInterfaceImpl: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynBinding] get_bindings()
+FSharp.Compiler.Syntax.SynInterfaceImpl: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn] get_members()
+FSharp.Compiler.Syntax.SynInterfaceImpl: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn] members
+FSharp.Compiler.Syntax.SynInterfaceImpl: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_withKeyword()
+FSharp.Compiler.Syntax.SynInterfaceImpl: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] withKeyword
+FSharp.Compiler.Syntax.SynInterfaceImpl: System.String ToString()
+FSharp.Compiler.Syntax.SynInterpolatedStringPart+FillExpr: FSharp.Compiler.Syntax.SynExpr fillExpr
+FSharp.Compiler.Syntax.SynInterpolatedStringPart+FillExpr: FSharp.Compiler.Syntax.SynExpr get_fillExpr()
+FSharp.Compiler.Syntax.SynInterpolatedStringPart+FillExpr: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] get_qualifiers()
+FSharp.Compiler.Syntax.SynInterpolatedStringPart+FillExpr: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] qualifiers
+FSharp.Compiler.Syntax.SynInterpolatedStringPart+String: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynInterpolatedStringPart+String: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynInterpolatedStringPart+String: System.String get_value()
+FSharp.Compiler.Syntax.SynInterpolatedStringPart+String: System.String value
+FSharp.Compiler.Syntax.SynInterpolatedStringPart+Tags: Int32 FillExpr
+FSharp.Compiler.Syntax.SynInterpolatedStringPart+Tags: Int32 String
+FSharp.Compiler.Syntax.SynInterpolatedStringPart: Boolean IsFillExpr
+FSharp.Compiler.Syntax.SynInterpolatedStringPart: Boolean IsString
+FSharp.Compiler.Syntax.SynInterpolatedStringPart: Boolean get_IsFillExpr()
+FSharp.Compiler.Syntax.SynInterpolatedStringPart: Boolean get_IsString()
+FSharp.Compiler.Syntax.SynInterpolatedStringPart: FSharp.Compiler.Syntax.SynInterpolatedStringPart NewFillExpr(FSharp.Compiler.Syntax.SynExpr, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident])
+FSharp.Compiler.Syntax.SynInterpolatedStringPart: FSharp.Compiler.Syntax.SynInterpolatedStringPart NewString(System.String, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynInterpolatedStringPart: FSharp.Compiler.Syntax.SynInterpolatedStringPart+FillExpr
+FSharp.Compiler.Syntax.SynInterpolatedStringPart: FSharp.Compiler.Syntax.SynInterpolatedStringPart+String
+FSharp.Compiler.Syntax.SynInterpolatedStringPart: FSharp.Compiler.Syntax.SynInterpolatedStringPart+Tags
+FSharp.Compiler.Syntax.SynInterpolatedStringPart: Int32 Tag
+FSharp.Compiler.Syntax.SynInterpolatedStringPart: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynInterpolatedStringPart: System.String ToString()
+FSharp.Compiler.Syntax.SynLongIdent: Boolean ThereIsAnExtraDotAtTheEnd
+FSharp.Compiler.Syntax.SynLongIdent: Boolean get_ThereIsAnExtraDotAtTheEnd()
+FSharp.Compiler.Syntax.SynLongIdent: FSharp.Compiler.Syntax.SynLongIdent NewSynLongIdent(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.IdentTrivia]])
+FSharp.Compiler.Syntax.SynLongIdent: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynLongIdent: FSharp.Compiler.Text.Range RangeWithoutAnyExtraDot
+FSharp.Compiler.Syntax.SynLongIdent: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynLongIdent: FSharp.Compiler.Text.Range get_RangeWithoutAnyExtraDot()
+FSharp.Compiler.Syntax.SynLongIdent: Int32 Tag
+FSharp.Compiler.Syntax.SynLongIdent: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynLongIdent: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] LongIdent
+FSharp.Compiler.Syntax.SynLongIdent: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] get_LongIdent()
+FSharp.Compiler.Syntax.SynLongIdent: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] get_id()
+FSharp.Compiler.Syntax.SynLongIdent: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] id
+FSharp.Compiler.Syntax.SynLongIdent: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynIdent] IdentsWithTrivia
+FSharp.Compiler.Syntax.SynLongIdent: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynIdent] get_IdentsWithTrivia()
+FSharp.Compiler.Syntax.SynLongIdent: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.IdentTrivia] Trivia
+FSharp.Compiler.Syntax.SynLongIdent: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.IdentTrivia] get_Trivia()
+FSharp.Compiler.Syntax.SynLongIdent: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.Range] Dots
+FSharp.Compiler.Syntax.SynLongIdent: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.Range] dotRanges
+FSharp.Compiler.Syntax.SynLongIdent: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.Range] get_Dots()
+FSharp.Compiler.Syntax.SynLongIdent: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.Range] get_dotRanges()
+FSharp.Compiler.Syntax.SynLongIdent: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.IdentTrivia]] get_trivia()
+FSharp.Compiler.Syntax.SynLongIdent: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.IdentTrivia]] trivia
+FSharp.Compiler.Syntax.SynLongIdent: System.String ToString()
+FSharp.Compiler.Syntax.SynLongIdentHelpers: FSharp.Compiler.Syntax.SynLongIdent LongIdentWithDots(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.Range])
+FSharp.Compiler.Syntax.SynLongIdentHelpers: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident],Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.Range]] |LongIdentWithDots|(FSharp.Compiler.Syntax.SynLongIdent)
+FSharp.Compiler.Syntax.SynMatchClause: FSharp.Compiler.Syntax.DebugPointAtTarget debugPoint
+FSharp.Compiler.Syntax.SynMatchClause: FSharp.Compiler.Syntax.DebugPointAtTarget get_debugPoint()
+FSharp.Compiler.Syntax.SynMatchClause: FSharp.Compiler.Syntax.SynExpr get_resultExpr()
+FSharp.Compiler.Syntax.SynMatchClause: FSharp.Compiler.Syntax.SynExpr resultExpr
+FSharp.Compiler.Syntax.SynMatchClause: FSharp.Compiler.Syntax.SynMatchClause NewSynMatchClause(FSharp.Compiler.Syntax.SynPat, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynExpr], FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range, FSharp.Compiler.Syntax.DebugPointAtTarget, FSharp.Compiler.SyntaxTrivia.SynMatchClauseTrivia)
+FSharp.Compiler.Syntax.SynMatchClause: FSharp.Compiler.Syntax.SynPat get_pat()
+FSharp.Compiler.Syntax.SynMatchClause: FSharp.Compiler.Syntax.SynPat pat
+FSharp.Compiler.Syntax.SynMatchClause: FSharp.Compiler.SyntaxTrivia.SynMatchClauseTrivia get_trivia()
+FSharp.Compiler.Syntax.SynMatchClause: FSharp.Compiler.SyntaxTrivia.SynMatchClauseTrivia trivia
+FSharp.Compiler.Syntax.SynMatchClause: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynMatchClause: FSharp.Compiler.Text.Range RangeOfGuardAndRhs
+FSharp.Compiler.Syntax.SynMatchClause: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynMatchClause: FSharp.Compiler.Text.Range get_RangeOfGuardAndRhs()
+FSharp.Compiler.Syntax.SynMatchClause: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMatchClause: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMatchClause: Int32 Tag
+FSharp.Compiler.Syntax.SynMatchClause: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynMatchClause: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynExpr] get_whenExpr()
+FSharp.Compiler.Syntax.SynMatchClause: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynExpr] whenExpr
+FSharp.Compiler.Syntax.SynMatchClause: System.String ToString()
+FSharp.Compiler.Syntax.SynMeasure+Anon: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMeasure+Anon: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMeasure+Divide: FSharp.Compiler.Syntax.SynMeasure get_measure1()
+FSharp.Compiler.Syntax.SynMeasure+Divide: FSharp.Compiler.Syntax.SynMeasure get_measure2()
+FSharp.Compiler.Syntax.SynMeasure+Divide: FSharp.Compiler.Syntax.SynMeasure measure1
+FSharp.Compiler.Syntax.SynMeasure+Divide: FSharp.Compiler.Syntax.SynMeasure measure2
+FSharp.Compiler.Syntax.SynMeasure+Divide: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMeasure+Divide: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMeasure+Named: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMeasure+Named: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMeasure+Named: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] get_longId()
+FSharp.Compiler.Syntax.SynMeasure+Named: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] longId
+FSharp.Compiler.Syntax.SynMeasure+Paren: FSharp.Compiler.Syntax.SynMeasure get_measure()
+FSharp.Compiler.Syntax.SynMeasure+Paren: FSharp.Compiler.Syntax.SynMeasure measure
+FSharp.Compiler.Syntax.SynMeasure+Paren: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMeasure+Paren: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMeasure+Power: FSharp.Compiler.Syntax.SynMeasure get_measure()
+FSharp.Compiler.Syntax.SynMeasure+Power: FSharp.Compiler.Syntax.SynMeasure measure
+FSharp.Compiler.Syntax.SynMeasure+Power: FSharp.Compiler.Syntax.SynRationalConst get_power()
+FSharp.Compiler.Syntax.SynMeasure+Power: FSharp.Compiler.Syntax.SynRationalConst power
+FSharp.Compiler.Syntax.SynMeasure+Power: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMeasure+Power: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMeasure+Product: FSharp.Compiler.Syntax.SynMeasure get_measure1()
+FSharp.Compiler.Syntax.SynMeasure+Product: FSharp.Compiler.Syntax.SynMeasure get_measure2()
+FSharp.Compiler.Syntax.SynMeasure+Product: FSharp.Compiler.Syntax.SynMeasure measure1
+FSharp.Compiler.Syntax.SynMeasure+Product: FSharp.Compiler.Syntax.SynMeasure measure2
+FSharp.Compiler.Syntax.SynMeasure+Product: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMeasure+Product: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMeasure+Seq: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMeasure+Seq: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMeasure+Seq: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMeasure] get_measures()
+FSharp.Compiler.Syntax.SynMeasure+Seq: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMeasure] measures
+FSharp.Compiler.Syntax.SynMeasure+Tags: Int32 Anon
+FSharp.Compiler.Syntax.SynMeasure+Tags: Int32 Divide
+FSharp.Compiler.Syntax.SynMeasure+Tags: Int32 Named
+FSharp.Compiler.Syntax.SynMeasure+Tags: Int32 One
+FSharp.Compiler.Syntax.SynMeasure+Tags: Int32 Paren
+FSharp.Compiler.Syntax.SynMeasure+Tags: Int32 Power
+FSharp.Compiler.Syntax.SynMeasure+Tags: Int32 Product
+FSharp.Compiler.Syntax.SynMeasure+Tags: Int32 Seq
+FSharp.Compiler.Syntax.SynMeasure+Tags: Int32 Var
+FSharp.Compiler.Syntax.SynMeasure+Var: FSharp.Compiler.Syntax.SynTypar get_typar()
+FSharp.Compiler.Syntax.SynMeasure+Var: FSharp.Compiler.Syntax.SynTypar typar
+FSharp.Compiler.Syntax.SynMeasure+Var: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMeasure+Var: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMeasure: Boolean IsAnon
+FSharp.Compiler.Syntax.SynMeasure: Boolean IsDivide
+FSharp.Compiler.Syntax.SynMeasure: Boolean IsNamed
+FSharp.Compiler.Syntax.SynMeasure: Boolean IsOne
+FSharp.Compiler.Syntax.SynMeasure: Boolean IsParen
+FSharp.Compiler.Syntax.SynMeasure: Boolean IsPower
+FSharp.Compiler.Syntax.SynMeasure: Boolean IsProduct
+FSharp.Compiler.Syntax.SynMeasure: Boolean IsSeq
+FSharp.Compiler.Syntax.SynMeasure: Boolean IsVar
+FSharp.Compiler.Syntax.SynMeasure: Boolean get_IsAnon()
+FSharp.Compiler.Syntax.SynMeasure: Boolean get_IsDivide()
+FSharp.Compiler.Syntax.SynMeasure: Boolean get_IsNamed()
+FSharp.Compiler.Syntax.SynMeasure: Boolean get_IsOne()
+FSharp.Compiler.Syntax.SynMeasure: Boolean get_IsParen()
+FSharp.Compiler.Syntax.SynMeasure: Boolean get_IsPower()
+FSharp.Compiler.Syntax.SynMeasure: Boolean get_IsProduct()
+FSharp.Compiler.Syntax.SynMeasure: Boolean get_IsSeq()
+FSharp.Compiler.Syntax.SynMeasure: Boolean get_IsVar()
+FSharp.Compiler.Syntax.SynMeasure: FSharp.Compiler.Syntax.SynMeasure NewAnon(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynMeasure: FSharp.Compiler.Syntax.SynMeasure NewDivide(FSharp.Compiler.Syntax.SynMeasure, FSharp.Compiler.Syntax.SynMeasure, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynMeasure: FSharp.Compiler.Syntax.SynMeasure NewNamed(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynMeasure: FSharp.Compiler.Syntax.SynMeasure NewParen(FSharp.Compiler.Syntax.SynMeasure, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynMeasure: FSharp.Compiler.Syntax.SynMeasure NewPower(FSharp.Compiler.Syntax.SynMeasure, FSharp.Compiler.Syntax.SynRationalConst, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynMeasure: FSharp.Compiler.Syntax.SynMeasure NewProduct(FSharp.Compiler.Syntax.SynMeasure, FSharp.Compiler.Syntax.SynMeasure, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynMeasure: FSharp.Compiler.Syntax.SynMeasure NewSeq(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMeasure], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynMeasure: FSharp.Compiler.Syntax.SynMeasure NewVar(FSharp.Compiler.Syntax.SynTypar, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynMeasure: FSharp.Compiler.Syntax.SynMeasure One
+FSharp.Compiler.Syntax.SynMeasure: FSharp.Compiler.Syntax.SynMeasure get_One()
+FSharp.Compiler.Syntax.SynMeasure: FSharp.Compiler.Syntax.SynMeasure+Anon
+FSharp.Compiler.Syntax.SynMeasure: FSharp.Compiler.Syntax.SynMeasure+Divide
+FSharp.Compiler.Syntax.SynMeasure: FSharp.Compiler.Syntax.SynMeasure+Named
+FSharp.Compiler.Syntax.SynMeasure: FSharp.Compiler.Syntax.SynMeasure+Paren
+FSharp.Compiler.Syntax.SynMeasure: FSharp.Compiler.Syntax.SynMeasure+Power
+FSharp.Compiler.Syntax.SynMeasure: FSharp.Compiler.Syntax.SynMeasure+Product
+FSharp.Compiler.Syntax.SynMeasure: FSharp.Compiler.Syntax.SynMeasure+Seq
+FSharp.Compiler.Syntax.SynMeasure: FSharp.Compiler.Syntax.SynMeasure+Tags
+FSharp.Compiler.Syntax.SynMeasure: FSharp.Compiler.Syntax.SynMeasure+Var
+FSharp.Compiler.Syntax.SynMeasure: Int32 Tag
+FSharp.Compiler.Syntax.SynMeasure: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynMeasure: System.String ToString()
+FSharp.Compiler.Syntax.SynMemberDefn+AbstractSlot: FSharp.Compiler.Syntax.SynMemberFlags flags
+FSharp.Compiler.Syntax.SynMemberDefn+AbstractSlot: FSharp.Compiler.Syntax.SynMemberFlags get_flags()
+FSharp.Compiler.Syntax.SynMemberDefn+AbstractSlot: FSharp.Compiler.Syntax.SynValSig get_slotSig()
+FSharp.Compiler.Syntax.SynMemberDefn+AbstractSlot: FSharp.Compiler.Syntax.SynValSig slotSig
+FSharp.Compiler.Syntax.SynMemberDefn+AbstractSlot: FSharp.Compiler.SyntaxTrivia.SynMemberDefnAbstractSlotTrivia get_trivia()
+FSharp.Compiler.Syntax.SynMemberDefn+AbstractSlot: FSharp.Compiler.SyntaxTrivia.SynMemberDefnAbstractSlotTrivia trivia
+FSharp.Compiler.Syntax.SynMemberDefn+AbstractSlot: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMemberDefn+AbstractSlot: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMemberDefn+AutoProperty: Boolean get_isStatic()
+FSharp.Compiler.Syntax.SynMemberDefn+AutoProperty: Boolean isStatic
+FSharp.Compiler.Syntax.SynMemberDefn+AutoProperty: FSharp.Compiler.Syntax.Ident get_ident()
+FSharp.Compiler.Syntax.SynMemberDefn+AutoProperty: FSharp.Compiler.Syntax.Ident ident
+FSharp.Compiler.Syntax.SynMemberDefn+AutoProperty: FSharp.Compiler.Syntax.SynExpr get_synExpr()
+FSharp.Compiler.Syntax.SynMemberDefn+AutoProperty: FSharp.Compiler.Syntax.SynExpr synExpr
+FSharp.Compiler.Syntax.SynMemberDefn+AutoProperty: FSharp.Compiler.Syntax.SynMemberFlags get_memberFlags()
+FSharp.Compiler.Syntax.SynMemberDefn+AutoProperty: FSharp.Compiler.Syntax.SynMemberFlags get_memberFlagsForSet()
+FSharp.Compiler.Syntax.SynMemberDefn+AutoProperty: FSharp.Compiler.Syntax.SynMemberFlags memberFlags
+FSharp.Compiler.Syntax.SynMemberDefn+AutoProperty: FSharp.Compiler.Syntax.SynMemberFlags memberFlagsForSet
+FSharp.Compiler.Syntax.SynMemberDefn+AutoProperty: FSharp.Compiler.Syntax.SynMemberKind get_propKind()
+FSharp.Compiler.Syntax.SynMemberDefn+AutoProperty: FSharp.Compiler.Syntax.SynMemberKind propKind
+FSharp.Compiler.Syntax.SynMemberDefn+AutoProperty: FSharp.Compiler.SyntaxTrivia.SynMemberDefnAutoPropertyTrivia get_trivia()
+FSharp.Compiler.Syntax.SynMemberDefn+AutoProperty: FSharp.Compiler.SyntaxTrivia.SynMemberDefnAutoPropertyTrivia trivia
+FSharp.Compiler.Syntax.SynMemberDefn+AutoProperty: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMemberDefn+AutoProperty: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMemberDefn+AutoProperty: FSharp.Compiler.Xml.PreXmlDoc get_xmlDoc()
+FSharp.Compiler.Syntax.SynMemberDefn+AutoProperty: FSharp.Compiler.Xml.PreXmlDoc xmlDoc
+FSharp.Compiler.Syntax.SynMemberDefn+AutoProperty: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] attributes
+FSharp.Compiler.Syntax.SynMemberDefn+AutoProperty: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] get_attributes()
+FSharp.Compiler.Syntax.SynMemberDefn+AutoProperty: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] accessibility
+FSharp.Compiler.Syntax.SynMemberDefn+AutoProperty: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] get_accessibility()
+FSharp.Compiler.Syntax.SynMemberDefn+AutoProperty: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynType] get_typeOpt()
+FSharp.Compiler.Syntax.SynMemberDefn+AutoProperty: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynType] typeOpt
+FSharp.Compiler.Syntax.SynMemberDefn+GetSetMember: FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia get_trivia()
+FSharp.Compiler.Syntax.SynMemberDefn+GetSetMember: FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia trivia
+FSharp.Compiler.Syntax.SynMemberDefn+GetSetMember: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMemberDefn+GetSetMember: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMemberDefn+GetSetMember: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynBinding] get_memberDefnForGet()
+FSharp.Compiler.Syntax.SynMemberDefn+GetSetMember: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynBinding] get_memberDefnForSet()
+FSharp.Compiler.Syntax.SynMemberDefn+GetSetMember: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynBinding] memberDefnForGet
+FSharp.Compiler.Syntax.SynMemberDefn+GetSetMember: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynBinding] memberDefnForSet
+FSharp.Compiler.Syntax.SynMemberDefn+ImplicitCtor: FSharp.Compiler.Syntax.SynSimplePats ctorArgs
+FSharp.Compiler.Syntax.SynMemberDefn+ImplicitCtor: FSharp.Compiler.Syntax.SynSimplePats get_ctorArgs()
+FSharp.Compiler.Syntax.SynMemberDefn+ImplicitCtor: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMemberDefn+ImplicitCtor: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMemberDefn+ImplicitCtor: FSharp.Compiler.Xml.PreXmlDoc get_xmlDoc()
+FSharp.Compiler.Syntax.SynMemberDefn+ImplicitCtor: FSharp.Compiler.Xml.PreXmlDoc xmlDoc
+FSharp.Compiler.Syntax.SynMemberDefn+ImplicitCtor: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] attributes
+FSharp.Compiler.Syntax.SynMemberDefn+ImplicitCtor: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] get_attributes()
+FSharp.Compiler.Syntax.SynMemberDefn+ImplicitCtor: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] get_selfIdentifier()
+FSharp.Compiler.Syntax.SynMemberDefn+ImplicitCtor: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] selfIdentifier
+FSharp.Compiler.Syntax.SynMemberDefn+ImplicitCtor: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] accessibility
+FSharp.Compiler.Syntax.SynMemberDefn+ImplicitCtor: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] get_accessibility()
+FSharp.Compiler.Syntax.SynMemberDefn+ImplicitInherit: FSharp.Compiler.Syntax.SynExpr get_inheritArgs()
+FSharp.Compiler.Syntax.SynMemberDefn+ImplicitInherit: FSharp.Compiler.Syntax.SynExpr inheritArgs
+FSharp.Compiler.Syntax.SynMemberDefn+ImplicitInherit: FSharp.Compiler.Syntax.SynType get_inheritType()
+FSharp.Compiler.Syntax.SynMemberDefn+ImplicitInherit: FSharp.Compiler.Syntax.SynType inheritType
+FSharp.Compiler.Syntax.SynMemberDefn+ImplicitInherit: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMemberDefn+ImplicitInherit: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMemberDefn+ImplicitInherit: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] get_inheritAlias()
+FSharp.Compiler.Syntax.SynMemberDefn+ImplicitInherit: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] inheritAlias
+FSharp.Compiler.Syntax.SynMemberDefn+Inherit: FSharp.Compiler.Syntax.SynType baseType
+FSharp.Compiler.Syntax.SynMemberDefn+Inherit: FSharp.Compiler.Syntax.SynType get_baseType()
+FSharp.Compiler.Syntax.SynMemberDefn+Inherit: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMemberDefn+Inherit: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMemberDefn+Inherit: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] asIdent
+FSharp.Compiler.Syntax.SynMemberDefn+Inherit: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] get_asIdent()
+FSharp.Compiler.Syntax.SynMemberDefn+Interface: FSharp.Compiler.Syntax.SynType get_interfaceType()
+FSharp.Compiler.Syntax.SynMemberDefn+Interface: FSharp.Compiler.Syntax.SynType interfaceType
+FSharp.Compiler.Syntax.SynMemberDefn+Interface: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMemberDefn+Interface: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMemberDefn+Interface: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_withKeyword()
+FSharp.Compiler.Syntax.SynMemberDefn+Interface: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] withKeyword
+FSharp.Compiler.Syntax.SynMemberDefn+Interface: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn]] get_members()
+FSharp.Compiler.Syntax.SynMemberDefn+Interface: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn]] members
+FSharp.Compiler.Syntax.SynMemberDefn+LetBindings: Boolean get_isRecursive()
+FSharp.Compiler.Syntax.SynMemberDefn+LetBindings: Boolean get_isStatic()
+FSharp.Compiler.Syntax.SynMemberDefn+LetBindings: Boolean isRecursive
+FSharp.Compiler.Syntax.SynMemberDefn+LetBindings: Boolean isStatic
+FSharp.Compiler.Syntax.SynMemberDefn+LetBindings: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMemberDefn+LetBindings: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMemberDefn+LetBindings: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynBinding] bindings
+FSharp.Compiler.Syntax.SynMemberDefn+LetBindings: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynBinding] get_bindings()
+FSharp.Compiler.Syntax.SynMemberDefn+Member: FSharp.Compiler.Syntax.SynBinding get_memberDefn()
+FSharp.Compiler.Syntax.SynMemberDefn+Member: FSharp.Compiler.Syntax.SynBinding memberDefn
+FSharp.Compiler.Syntax.SynMemberDefn+Member: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMemberDefn+Member: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMemberDefn+NestedType: FSharp.Compiler.Syntax.SynTypeDefn get_typeDefn()
+FSharp.Compiler.Syntax.SynMemberDefn+NestedType: FSharp.Compiler.Syntax.SynTypeDefn typeDefn
+FSharp.Compiler.Syntax.SynMemberDefn+NestedType: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMemberDefn+NestedType: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMemberDefn+NestedType: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] accessibility
+FSharp.Compiler.Syntax.SynMemberDefn+NestedType: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] get_accessibility()
+FSharp.Compiler.Syntax.SynMemberDefn+Open: FSharp.Compiler.Syntax.SynOpenDeclTarget get_target()
+FSharp.Compiler.Syntax.SynMemberDefn+Open: FSharp.Compiler.Syntax.SynOpenDeclTarget target
+FSharp.Compiler.Syntax.SynMemberDefn+Open: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMemberDefn+Open: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMemberDefn+Tags: Int32 AbstractSlot
+FSharp.Compiler.Syntax.SynMemberDefn+Tags: Int32 AutoProperty
+FSharp.Compiler.Syntax.SynMemberDefn+Tags: Int32 GetSetMember
+FSharp.Compiler.Syntax.SynMemberDefn+Tags: Int32 ImplicitCtor
+FSharp.Compiler.Syntax.SynMemberDefn+Tags: Int32 ImplicitInherit
+FSharp.Compiler.Syntax.SynMemberDefn+Tags: Int32 Inherit
+FSharp.Compiler.Syntax.SynMemberDefn+Tags: Int32 Interface
+FSharp.Compiler.Syntax.SynMemberDefn+Tags: Int32 LetBindings
+FSharp.Compiler.Syntax.SynMemberDefn+Tags: Int32 Member
+FSharp.Compiler.Syntax.SynMemberDefn+Tags: Int32 NestedType
+FSharp.Compiler.Syntax.SynMemberDefn+Tags: Int32 Open
+FSharp.Compiler.Syntax.SynMemberDefn+Tags: Int32 ValField
+FSharp.Compiler.Syntax.SynMemberDefn+ValField: FSharp.Compiler.Syntax.SynField fieldInfo
+FSharp.Compiler.Syntax.SynMemberDefn+ValField: FSharp.Compiler.Syntax.SynField get_fieldInfo()
+FSharp.Compiler.Syntax.SynMemberDefn+ValField: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMemberDefn+ValField: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMemberDefn: Boolean IsAbstractSlot
+FSharp.Compiler.Syntax.SynMemberDefn: Boolean IsAutoProperty
+FSharp.Compiler.Syntax.SynMemberDefn: Boolean IsGetSetMember
+FSharp.Compiler.Syntax.SynMemberDefn: Boolean IsImplicitCtor
+FSharp.Compiler.Syntax.SynMemberDefn: Boolean IsImplicitInherit
+FSharp.Compiler.Syntax.SynMemberDefn: Boolean IsInherit
+FSharp.Compiler.Syntax.SynMemberDefn: Boolean IsInterface
+FSharp.Compiler.Syntax.SynMemberDefn: Boolean IsLetBindings
+FSharp.Compiler.Syntax.SynMemberDefn: Boolean IsMember
+FSharp.Compiler.Syntax.SynMemberDefn: Boolean IsNestedType
+FSharp.Compiler.Syntax.SynMemberDefn: Boolean IsOpen
+FSharp.Compiler.Syntax.SynMemberDefn: Boolean IsValField
+FSharp.Compiler.Syntax.SynMemberDefn: Boolean get_IsAbstractSlot()
+FSharp.Compiler.Syntax.SynMemberDefn: Boolean get_IsAutoProperty()
+FSharp.Compiler.Syntax.SynMemberDefn: Boolean get_IsGetSetMember()
+FSharp.Compiler.Syntax.SynMemberDefn: Boolean get_IsImplicitCtor()
+FSharp.Compiler.Syntax.SynMemberDefn: Boolean get_IsImplicitInherit()
+FSharp.Compiler.Syntax.SynMemberDefn: Boolean get_IsInherit()
+FSharp.Compiler.Syntax.SynMemberDefn: Boolean get_IsInterface()
+FSharp.Compiler.Syntax.SynMemberDefn: Boolean get_IsLetBindings()
+FSharp.Compiler.Syntax.SynMemberDefn: Boolean get_IsMember()
+FSharp.Compiler.Syntax.SynMemberDefn: Boolean get_IsNestedType()
+FSharp.Compiler.Syntax.SynMemberDefn: Boolean get_IsOpen()
+FSharp.Compiler.Syntax.SynMemberDefn: Boolean get_IsValField()
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn NewAbstractSlot(FSharp.Compiler.Syntax.SynValSig, FSharp.Compiler.Syntax.SynMemberFlags, FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynMemberDefnAbstractSlotTrivia)
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn NewAutoProperty(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], Boolean, FSharp.Compiler.Syntax.Ident, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynType], FSharp.Compiler.Syntax.SynMemberKind, FSharp.Compiler.Syntax.SynMemberFlags, FSharp.Compiler.Syntax.SynMemberFlags, FSharp.Compiler.Xml.PreXmlDoc, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess], FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynMemberDefnAutoPropertyTrivia)
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn NewGetSetMember(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynBinding], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynBinding], FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia)
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn NewImplicitCtor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], FSharp.Compiler.Syntax.SynSimplePats, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident], FSharp.Compiler.Xml.PreXmlDoc, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn NewImplicitInherit(FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Syntax.SynExpr, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn NewInherit(FSharp.Compiler.Syntax.SynType, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn NewInterface(FSharp.Compiler.Syntax.SynType, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn]], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn NewLetBindings(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynBinding], Boolean, Boolean, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn NewMember(FSharp.Compiler.Syntax.SynBinding, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn NewNestedType(FSharp.Compiler.Syntax.SynTypeDefn, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn NewOpen(FSharp.Compiler.Syntax.SynOpenDeclTarget, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn NewValField(FSharp.Compiler.Syntax.SynField, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn+AbstractSlot
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn+AutoProperty
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn+GetSetMember
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn+ImplicitCtor
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn+ImplicitInherit
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn+Inherit
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn+Interface
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn+LetBindings
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn+Member
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn+NestedType
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn+Open
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn+Tags
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn+ValField
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynMemberDefn: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynMemberDefn: Int32 Tag
+FSharp.Compiler.Syntax.SynMemberDefn: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynMemberDefn: System.String ToString()
+FSharp.Compiler.Syntax.SynMemberFlags: Boolean Equals(System.Object)
+FSharp.Compiler.Syntax.SynMemberFlags: Boolean GetterOrSetterIsCompilerGenerated
+FSharp.Compiler.Syntax.SynMemberFlags: Boolean IsDispatchSlot
+FSharp.Compiler.Syntax.SynMemberFlags: Boolean IsFinal
+FSharp.Compiler.Syntax.SynMemberFlags: Boolean IsInstance
+FSharp.Compiler.Syntax.SynMemberFlags: Boolean IsOverrideOrExplicitImpl
+FSharp.Compiler.Syntax.SynMemberFlags: Boolean get_GetterOrSetterIsCompilerGenerated()
+FSharp.Compiler.Syntax.SynMemberFlags: Boolean get_IsDispatchSlot()
+FSharp.Compiler.Syntax.SynMemberFlags: Boolean get_IsFinal()
+FSharp.Compiler.Syntax.SynMemberFlags: Boolean get_IsInstance()
+FSharp.Compiler.Syntax.SynMemberFlags: Boolean get_IsOverrideOrExplicitImpl()
+FSharp.Compiler.Syntax.SynMemberFlags: FSharp.Compiler.Syntax.SynMemberKind MemberKind
+FSharp.Compiler.Syntax.SynMemberFlags: FSharp.Compiler.Syntax.SynMemberKind get_MemberKind()
+FSharp.Compiler.Syntax.SynMemberFlags: Int32 GetHashCode()
+FSharp.Compiler.Syntax.SynMemberFlags: System.String ToString()
+FSharp.Compiler.Syntax.SynMemberFlags: Void .ctor(Boolean, Boolean, Boolean, Boolean, Boolean, FSharp.Compiler.Syntax.SynMemberKind)
+FSharp.Compiler.Syntax.SynMemberKind+Tags: Int32 ClassConstructor
+FSharp.Compiler.Syntax.SynMemberKind+Tags: Int32 Constructor
+FSharp.Compiler.Syntax.SynMemberKind+Tags: Int32 Member
+FSharp.Compiler.Syntax.SynMemberKind+Tags: Int32 PropertyGet
+FSharp.Compiler.Syntax.SynMemberKind+Tags: Int32 PropertyGetSet
+FSharp.Compiler.Syntax.SynMemberKind+Tags: Int32 PropertySet
+FSharp.Compiler.Syntax.SynMemberKind: Boolean Equals(FSharp.Compiler.Syntax.SynMemberKind)
+FSharp.Compiler.Syntax.SynMemberKind: Boolean Equals(System.Object)
+FSharp.Compiler.Syntax.SynMemberKind: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.SynMemberKind: Boolean IsClassConstructor
+FSharp.Compiler.Syntax.SynMemberKind: Boolean IsConstructor
+FSharp.Compiler.Syntax.SynMemberKind: Boolean IsMember
+FSharp.Compiler.Syntax.SynMemberKind: Boolean IsPropertyGet
+FSharp.Compiler.Syntax.SynMemberKind: Boolean IsPropertyGetSet
+FSharp.Compiler.Syntax.SynMemberKind: Boolean IsPropertySet
+FSharp.Compiler.Syntax.SynMemberKind: Boolean get_IsClassConstructor()
+FSharp.Compiler.Syntax.SynMemberKind: Boolean get_IsConstructor()
+FSharp.Compiler.Syntax.SynMemberKind: Boolean get_IsMember()
+FSharp.Compiler.Syntax.SynMemberKind: Boolean get_IsPropertyGet()
+FSharp.Compiler.Syntax.SynMemberKind: Boolean get_IsPropertyGetSet()
+FSharp.Compiler.Syntax.SynMemberKind: Boolean get_IsPropertySet()
+FSharp.Compiler.Syntax.SynMemberKind: FSharp.Compiler.Syntax.SynMemberKind ClassConstructor
+FSharp.Compiler.Syntax.SynMemberKind: FSharp.Compiler.Syntax.SynMemberKind Constructor
+FSharp.Compiler.Syntax.SynMemberKind: FSharp.Compiler.Syntax.SynMemberKind Member
+FSharp.Compiler.Syntax.SynMemberKind: FSharp.Compiler.Syntax.SynMemberKind PropertyGet
+FSharp.Compiler.Syntax.SynMemberKind: FSharp.Compiler.Syntax.SynMemberKind PropertyGetSet
+FSharp.Compiler.Syntax.SynMemberKind: FSharp.Compiler.Syntax.SynMemberKind PropertySet
+FSharp.Compiler.Syntax.SynMemberKind: FSharp.Compiler.Syntax.SynMemberKind get_ClassConstructor()
+FSharp.Compiler.Syntax.SynMemberKind: FSharp.Compiler.Syntax.SynMemberKind get_Constructor()
+FSharp.Compiler.Syntax.SynMemberKind: FSharp.Compiler.Syntax.SynMemberKind get_Member()
+FSharp.Compiler.Syntax.SynMemberKind: FSharp.Compiler.Syntax.SynMemberKind get_PropertyGet()
+FSharp.Compiler.Syntax.SynMemberKind: FSharp.Compiler.Syntax.SynMemberKind get_PropertyGetSet()
+FSharp.Compiler.Syntax.SynMemberKind: FSharp.Compiler.Syntax.SynMemberKind get_PropertySet()
+FSharp.Compiler.Syntax.SynMemberKind: FSharp.Compiler.Syntax.SynMemberKind+Tags
+FSharp.Compiler.Syntax.SynMemberKind: Int32 GetHashCode()
+FSharp.Compiler.Syntax.SynMemberKind: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.SynMemberKind: Int32 Tag
+FSharp.Compiler.Syntax.SynMemberKind: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynMemberKind: System.String ToString()
+FSharp.Compiler.Syntax.SynMemberSig+Inherit: FSharp.Compiler.Syntax.SynType get_inheritedType()
+FSharp.Compiler.Syntax.SynMemberSig+Inherit: FSharp.Compiler.Syntax.SynType inheritedType
+FSharp.Compiler.Syntax.SynMemberSig+Inherit: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMemberSig+Inherit: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMemberSig+Interface: FSharp.Compiler.Syntax.SynType get_interfaceType()
+FSharp.Compiler.Syntax.SynMemberSig+Interface: FSharp.Compiler.Syntax.SynType interfaceType
+FSharp.Compiler.Syntax.SynMemberSig+Interface: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMemberSig+Interface: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMemberSig+Member: FSharp.Compiler.Syntax.SynMemberFlags flags
+FSharp.Compiler.Syntax.SynMemberSig+Member: FSharp.Compiler.Syntax.SynMemberFlags get_flags()
+FSharp.Compiler.Syntax.SynMemberSig+Member: FSharp.Compiler.Syntax.SynValSig get_memberSig()
+FSharp.Compiler.Syntax.SynMemberSig+Member: FSharp.Compiler.Syntax.SynValSig memberSig
+FSharp.Compiler.Syntax.SynMemberSig+Member: FSharp.Compiler.SyntaxTrivia.SynMemberSigMemberTrivia get_trivia()
+FSharp.Compiler.Syntax.SynMemberSig+Member: FSharp.Compiler.SyntaxTrivia.SynMemberSigMemberTrivia trivia
+FSharp.Compiler.Syntax.SynMemberSig+Member: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMemberSig+Member: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMemberSig+NestedType: FSharp.Compiler.Syntax.SynTypeDefnSig get_nestedType()
+FSharp.Compiler.Syntax.SynMemberSig+NestedType: FSharp.Compiler.Syntax.SynTypeDefnSig nestedType
+FSharp.Compiler.Syntax.SynMemberSig+NestedType: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMemberSig+NestedType: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMemberSig+Tags: Int32 Inherit
+FSharp.Compiler.Syntax.SynMemberSig+Tags: Int32 Interface
+FSharp.Compiler.Syntax.SynMemberSig+Tags: Int32 Member
+FSharp.Compiler.Syntax.SynMemberSig+Tags: Int32 NestedType
+FSharp.Compiler.Syntax.SynMemberSig+Tags: Int32 ValField
+FSharp.Compiler.Syntax.SynMemberSig+ValField: FSharp.Compiler.Syntax.SynField field
+FSharp.Compiler.Syntax.SynMemberSig+ValField: FSharp.Compiler.Syntax.SynField get_field()
+FSharp.Compiler.Syntax.SynMemberSig+ValField: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynMemberSig+ValField: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynMemberSig: Boolean IsInherit
+FSharp.Compiler.Syntax.SynMemberSig: Boolean IsInterface
+FSharp.Compiler.Syntax.SynMemberSig: Boolean IsMember
+FSharp.Compiler.Syntax.SynMemberSig: Boolean IsNestedType
+FSharp.Compiler.Syntax.SynMemberSig: Boolean IsValField
+FSharp.Compiler.Syntax.SynMemberSig: Boolean get_IsInherit()
+FSharp.Compiler.Syntax.SynMemberSig: Boolean get_IsInterface()
+FSharp.Compiler.Syntax.SynMemberSig: Boolean get_IsMember()
+FSharp.Compiler.Syntax.SynMemberSig: Boolean get_IsNestedType()
+FSharp.Compiler.Syntax.SynMemberSig: Boolean get_IsValField()
+FSharp.Compiler.Syntax.SynMemberSig: FSharp.Compiler.Syntax.SynMemberSig NewInherit(FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynMemberSig: FSharp.Compiler.Syntax.SynMemberSig NewInterface(FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynMemberSig: FSharp.Compiler.Syntax.SynMemberSig NewMember(FSharp.Compiler.Syntax.SynValSig, FSharp.Compiler.Syntax.SynMemberFlags, FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynMemberSigMemberTrivia)
+FSharp.Compiler.Syntax.SynMemberSig: FSharp.Compiler.Syntax.SynMemberSig NewNestedType(FSharp.Compiler.Syntax.SynTypeDefnSig, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynMemberSig: FSharp.Compiler.Syntax.SynMemberSig NewValField(FSharp.Compiler.Syntax.SynField, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynMemberSig: FSharp.Compiler.Syntax.SynMemberSig+Inherit
+FSharp.Compiler.Syntax.SynMemberSig: FSharp.Compiler.Syntax.SynMemberSig+Interface
+FSharp.Compiler.Syntax.SynMemberSig: FSharp.Compiler.Syntax.SynMemberSig+Member
+FSharp.Compiler.Syntax.SynMemberSig: FSharp.Compiler.Syntax.SynMemberSig+NestedType
+FSharp.Compiler.Syntax.SynMemberSig: FSharp.Compiler.Syntax.SynMemberSig+Tags
+FSharp.Compiler.Syntax.SynMemberSig: FSharp.Compiler.Syntax.SynMemberSig+ValField
+FSharp.Compiler.Syntax.SynMemberSig: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynMemberSig: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynMemberSig: Int32 Tag
+FSharp.Compiler.Syntax.SynMemberSig: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynMemberSig: System.String ToString()
+FSharp.Compiler.Syntax.SynModuleDecl+Attributes: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynModuleDecl+Attributes: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynModuleDecl+Attributes: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] attributes
+FSharp.Compiler.Syntax.SynModuleDecl+Attributes: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] get_attributes()
+FSharp.Compiler.Syntax.SynModuleDecl+Exception: FSharp.Compiler.Syntax.SynExceptionDefn exnDefn
+FSharp.Compiler.Syntax.SynModuleDecl+Exception: FSharp.Compiler.Syntax.SynExceptionDefn get_exnDefn()
+FSharp.Compiler.Syntax.SynModuleDecl+Exception: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynModuleDecl+Exception: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynModuleDecl+Expr: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynModuleDecl+Expr: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynModuleDecl+Expr: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynModuleDecl+Expr: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynModuleDecl+HashDirective: FSharp.Compiler.Syntax.ParsedHashDirective get_hashDirective()
+FSharp.Compiler.Syntax.SynModuleDecl+HashDirective: FSharp.Compiler.Syntax.ParsedHashDirective hashDirective
+FSharp.Compiler.Syntax.SynModuleDecl+HashDirective: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynModuleDecl+HashDirective: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynModuleDecl+Let: Boolean get_isRecursive()
+FSharp.Compiler.Syntax.SynModuleDecl+Let: Boolean isRecursive
+FSharp.Compiler.Syntax.SynModuleDecl+Let: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynModuleDecl+Let: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynModuleDecl+Let: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynBinding] bindings
+FSharp.Compiler.Syntax.SynModuleDecl+Let: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynBinding] get_bindings()
+FSharp.Compiler.Syntax.SynModuleDecl+ModuleAbbrev: FSharp.Compiler.Syntax.Ident get_ident()
+FSharp.Compiler.Syntax.SynModuleDecl+ModuleAbbrev: FSharp.Compiler.Syntax.Ident ident
+FSharp.Compiler.Syntax.SynModuleDecl+ModuleAbbrev: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynModuleDecl+ModuleAbbrev: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynModuleDecl+ModuleAbbrev: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] get_longId()
+FSharp.Compiler.Syntax.SynModuleDecl+ModuleAbbrev: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] longId
+FSharp.Compiler.Syntax.SynModuleDecl+NamespaceFragment: FSharp.Compiler.Syntax.SynModuleOrNamespace fragment
+FSharp.Compiler.Syntax.SynModuleDecl+NamespaceFragment: FSharp.Compiler.Syntax.SynModuleOrNamespace get_fragment()
+FSharp.Compiler.Syntax.SynModuleDecl+NestedModule: Boolean get_isContinuing()
+FSharp.Compiler.Syntax.SynModuleDecl+NestedModule: Boolean get_isRecursive()
+FSharp.Compiler.Syntax.SynModuleDecl+NestedModule: Boolean isContinuing
+FSharp.Compiler.Syntax.SynModuleDecl+NestedModule: Boolean isRecursive
+FSharp.Compiler.Syntax.SynModuleDecl+NestedModule: FSharp.Compiler.Syntax.SynComponentInfo get_moduleInfo()
+FSharp.Compiler.Syntax.SynModuleDecl+NestedModule: FSharp.Compiler.Syntax.SynComponentInfo moduleInfo
+FSharp.Compiler.Syntax.SynModuleDecl+NestedModule: FSharp.Compiler.SyntaxTrivia.SynModuleDeclNestedModuleTrivia get_trivia()
+FSharp.Compiler.Syntax.SynModuleDecl+NestedModule: FSharp.Compiler.SyntaxTrivia.SynModuleDeclNestedModuleTrivia trivia
+FSharp.Compiler.Syntax.SynModuleDecl+NestedModule: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynModuleDecl+NestedModule: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynModuleDecl+NestedModule: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleDecl] decls
+FSharp.Compiler.Syntax.SynModuleDecl+NestedModule: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleDecl] get_decls()
+FSharp.Compiler.Syntax.SynModuleDecl+Open: FSharp.Compiler.Syntax.SynOpenDeclTarget get_target()
+FSharp.Compiler.Syntax.SynModuleDecl+Open: FSharp.Compiler.Syntax.SynOpenDeclTarget target
+FSharp.Compiler.Syntax.SynModuleDecl+Open: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynModuleDecl+Open: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynModuleDecl+Tags: Int32 Attributes
+FSharp.Compiler.Syntax.SynModuleDecl+Tags: Int32 Exception
+FSharp.Compiler.Syntax.SynModuleDecl+Tags: Int32 Expr
+FSharp.Compiler.Syntax.SynModuleDecl+Tags: Int32 HashDirective
+FSharp.Compiler.Syntax.SynModuleDecl+Tags: Int32 Let
+FSharp.Compiler.Syntax.SynModuleDecl+Tags: Int32 ModuleAbbrev
+FSharp.Compiler.Syntax.SynModuleDecl+Tags: Int32 NamespaceFragment
+FSharp.Compiler.Syntax.SynModuleDecl+Tags: Int32 NestedModule
+FSharp.Compiler.Syntax.SynModuleDecl+Tags: Int32 Open
+FSharp.Compiler.Syntax.SynModuleDecl+Tags: Int32 Types
+FSharp.Compiler.Syntax.SynModuleDecl+Types: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynModuleDecl+Types: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynModuleDecl+Types: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTypeDefn] get_typeDefns()
+FSharp.Compiler.Syntax.SynModuleDecl+Types: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTypeDefn] typeDefns
+FSharp.Compiler.Syntax.SynModuleDecl: Boolean IsAttributes
+FSharp.Compiler.Syntax.SynModuleDecl: Boolean IsException
+FSharp.Compiler.Syntax.SynModuleDecl: Boolean IsExpr
+FSharp.Compiler.Syntax.SynModuleDecl: Boolean IsHashDirective
+FSharp.Compiler.Syntax.SynModuleDecl: Boolean IsLet
+FSharp.Compiler.Syntax.SynModuleDecl: Boolean IsModuleAbbrev
+FSharp.Compiler.Syntax.SynModuleDecl: Boolean IsNamespaceFragment
+FSharp.Compiler.Syntax.SynModuleDecl: Boolean IsNestedModule
+FSharp.Compiler.Syntax.SynModuleDecl: Boolean IsOpen
+FSharp.Compiler.Syntax.SynModuleDecl: Boolean IsTypes
+FSharp.Compiler.Syntax.SynModuleDecl: Boolean get_IsAttributes()
+FSharp.Compiler.Syntax.SynModuleDecl: Boolean get_IsException()
+FSharp.Compiler.Syntax.SynModuleDecl: Boolean get_IsExpr()
+FSharp.Compiler.Syntax.SynModuleDecl: Boolean get_IsHashDirective()
+FSharp.Compiler.Syntax.SynModuleDecl: Boolean get_IsLet()
+FSharp.Compiler.Syntax.SynModuleDecl: Boolean get_IsModuleAbbrev()
+FSharp.Compiler.Syntax.SynModuleDecl: Boolean get_IsNamespaceFragment()
+FSharp.Compiler.Syntax.SynModuleDecl: Boolean get_IsNestedModule()
+FSharp.Compiler.Syntax.SynModuleDecl: Boolean get_IsOpen()
+FSharp.Compiler.Syntax.SynModuleDecl: Boolean get_IsTypes()
+FSharp.Compiler.Syntax.SynModuleDecl: FSharp.Compiler.Syntax.SynModuleDecl NewAttributes(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynModuleDecl: FSharp.Compiler.Syntax.SynModuleDecl NewException(FSharp.Compiler.Syntax.SynExceptionDefn, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynModuleDecl: FSharp.Compiler.Syntax.SynModuleDecl NewExpr(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynModuleDecl: FSharp.Compiler.Syntax.SynModuleDecl NewHashDirective(FSharp.Compiler.Syntax.ParsedHashDirective, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynModuleDecl: FSharp.Compiler.Syntax.SynModuleDecl NewLet(Boolean, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynBinding], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynModuleDecl: FSharp.Compiler.Syntax.SynModuleDecl NewModuleAbbrev(FSharp.Compiler.Syntax.Ident, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynModuleDecl: FSharp.Compiler.Syntax.SynModuleDecl NewNamespaceFragment(FSharp.Compiler.Syntax.SynModuleOrNamespace)
+FSharp.Compiler.Syntax.SynModuleDecl: FSharp.Compiler.Syntax.SynModuleDecl NewNestedModule(FSharp.Compiler.Syntax.SynComponentInfo, Boolean, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleDecl], Boolean, FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynModuleDeclNestedModuleTrivia)
+FSharp.Compiler.Syntax.SynModuleDecl: FSharp.Compiler.Syntax.SynModuleDecl NewOpen(FSharp.Compiler.Syntax.SynOpenDeclTarget, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynModuleDecl: FSharp.Compiler.Syntax.SynModuleDecl NewTypes(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTypeDefn], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynModuleDecl: FSharp.Compiler.Syntax.SynModuleDecl+Attributes
+FSharp.Compiler.Syntax.SynModuleDecl: FSharp.Compiler.Syntax.SynModuleDecl+Exception
+FSharp.Compiler.Syntax.SynModuleDecl: FSharp.Compiler.Syntax.SynModuleDecl+Expr
+FSharp.Compiler.Syntax.SynModuleDecl: FSharp.Compiler.Syntax.SynModuleDecl+HashDirective
+FSharp.Compiler.Syntax.SynModuleDecl: FSharp.Compiler.Syntax.SynModuleDecl+Let
+FSharp.Compiler.Syntax.SynModuleDecl: FSharp.Compiler.Syntax.SynModuleDecl+ModuleAbbrev
+FSharp.Compiler.Syntax.SynModuleDecl: FSharp.Compiler.Syntax.SynModuleDecl+NamespaceFragment
+FSharp.Compiler.Syntax.SynModuleDecl: FSharp.Compiler.Syntax.SynModuleDecl+NestedModule
+FSharp.Compiler.Syntax.SynModuleDecl: FSharp.Compiler.Syntax.SynModuleDecl+Open
+FSharp.Compiler.Syntax.SynModuleDecl: FSharp.Compiler.Syntax.SynModuleDecl+Tags
+FSharp.Compiler.Syntax.SynModuleDecl: FSharp.Compiler.Syntax.SynModuleDecl+Types
+FSharp.Compiler.Syntax.SynModuleDecl: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynModuleDecl: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynModuleDecl: Int32 Tag
+FSharp.Compiler.Syntax.SynModuleDecl: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynModuleDecl: System.String ToString()
+FSharp.Compiler.Syntax.SynModuleOrNamespace: Boolean get_isRecursive()
+FSharp.Compiler.Syntax.SynModuleOrNamespace: Boolean isRecursive
+FSharp.Compiler.Syntax.SynModuleOrNamespace: FSharp.Compiler.Syntax.SynModuleOrNamespace NewSynModuleOrNamespace(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident], Boolean, FSharp.Compiler.Syntax.SynModuleOrNamespaceKind, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleDecl], FSharp.Compiler.Xml.PreXmlDoc, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess], FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceTrivia)
+FSharp.Compiler.Syntax.SynModuleOrNamespace: FSharp.Compiler.Syntax.SynModuleOrNamespaceKind get_kind()
+FSharp.Compiler.Syntax.SynModuleOrNamespace: FSharp.Compiler.Syntax.SynModuleOrNamespaceKind kind
+FSharp.Compiler.Syntax.SynModuleOrNamespace: FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceTrivia get_trivia()
+FSharp.Compiler.Syntax.SynModuleOrNamespace: FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceTrivia trivia
+FSharp.Compiler.Syntax.SynModuleOrNamespace: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynModuleOrNamespace: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynModuleOrNamespace: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynModuleOrNamespace: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynModuleOrNamespace: FSharp.Compiler.Xml.PreXmlDoc get_xmlDoc()
+FSharp.Compiler.Syntax.SynModuleOrNamespace: FSharp.Compiler.Xml.PreXmlDoc xmlDoc
+FSharp.Compiler.Syntax.SynModuleOrNamespace: Int32 Tag
+FSharp.Compiler.Syntax.SynModuleOrNamespace: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynModuleOrNamespace: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] get_longId()
+FSharp.Compiler.Syntax.SynModuleOrNamespace: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] longId
+FSharp.Compiler.Syntax.SynModuleOrNamespace: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] attribs
+FSharp.Compiler.Syntax.SynModuleOrNamespace: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] get_attribs()
+FSharp.Compiler.Syntax.SynModuleOrNamespace: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleDecl] decls
+FSharp.Compiler.Syntax.SynModuleOrNamespace: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleDecl] get_decls()
+FSharp.Compiler.Syntax.SynModuleOrNamespace: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] accessibility
+FSharp.Compiler.Syntax.SynModuleOrNamespace: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] get_accessibility()
+FSharp.Compiler.Syntax.SynModuleOrNamespace: System.String ToString()
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind+Tags: Int32 AnonModule
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind+Tags: Int32 DeclaredNamespace
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind+Tags: Int32 GlobalNamespace
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind+Tags: Int32 NamedModule
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: Boolean Equals(FSharp.Compiler.Syntax.SynModuleOrNamespaceKind)
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: Boolean Equals(System.Object)
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: Boolean IsAnonModule
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: Boolean IsDeclaredNamespace
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: Boolean IsGlobalNamespace
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: Boolean IsModule
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: Boolean IsNamedModule
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: Boolean get_IsAnonModule()
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: Boolean get_IsDeclaredNamespace()
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: Boolean get_IsGlobalNamespace()
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: Boolean get_IsModule()
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: Boolean get_IsNamedModule()
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: FSharp.Compiler.Syntax.SynModuleOrNamespaceKind AnonModule
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: FSharp.Compiler.Syntax.SynModuleOrNamespaceKind DeclaredNamespace
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: FSharp.Compiler.Syntax.SynModuleOrNamespaceKind GlobalNamespace
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: FSharp.Compiler.Syntax.SynModuleOrNamespaceKind NamedModule
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: FSharp.Compiler.Syntax.SynModuleOrNamespaceKind get_AnonModule()
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: FSharp.Compiler.Syntax.SynModuleOrNamespaceKind get_DeclaredNamespace()
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: FSharp.Compiler.Syntax.SynModuleOrNamespaceKind get_GlobalNamespace()
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: FSharp.Compiler.Syntax.SynModuleOrNamespaceKind get_NamedModule()
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: FSharp.Compiler.Syntax.SynModuleOrNamespaceKind+Tags
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: Int32 CompareTo(FSharp.Compiler.Syntax.SynModuleOrNamespaceKind)
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: Int32 CompareTo(System.Object)
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: Int32 GetHashCode()
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: Int32 Tag
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynModuleOrNamespaceKind: System.String ToString()
+FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: Boolean get_isRecursive()
+FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: Boolean isRecursive
+FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: FSharp.Compiler.Syntax.SynModuleOrNamespaceKind get_kind()
+FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: FSharp.Compiler.Syntax.SynModuleOrNamespaceKind kind
+FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: FSharp.Compiler.Syntax.SynModuleOrNamespaceSig NewSynModuleOrNamespaceSig(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident], Boolean, FSharp.Compiler.Syntax.SynModuleOrNamespaceKind, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleSigDecl], FSharp.Compiler.Xml.PreXmlDoc, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess], FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceSigTrivia)
+FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceSigTrivia get_trivia()
+FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceSigTrivia trivia
+FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: FSharp.Compiler.Xml.PreXmlDoc get_xmlDoc()
+FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: FSharp.Compiler.Xml.PreXmlDoc xmlDoc
+FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: Int32 Tag
+FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] get_longId()
+FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] longId
+FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] attribs
+FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] get_attribs()
+FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleSigDecl] decls
+FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleSigDecl] get_decls()
+FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] accessibility
+FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] get_accessibility()
+FSharp.Compiler.Syntax.SynModuleOrNamespaceSig: System.String ToString()
+FSharp.Compiler.Syntax.SynModuleSigDecl+Exception: FSharp.Compiler.Syntax.SynExceptionSig exnSig
+FSharp.Compiler.Syntax.SynModuleSigDecl+Exception: FSharp.Compiler.Syntax.SynExceptionSig get_exnSig()
+FSharp.Compiler.Syntax.SynModuleSigDecl+Exception: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynModuleSigDecl+Exception: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynModuleSigDecl+HashDirective: FSharp.Compiler.Syntax.ParsedHashDirective get_hashDirective()
+FSharp.Compiler.Syntax.SynModuleSigDecl+HashDirective: FSharp.Compiler.Syntax.ParsedHashDirective hashDirective
+FSharp.Compiler.Syntax.SynModuleSigDecl+HashDirective: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynModuleSigDecl+HashDirective: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynModuleSigDecl+ModuleAbbrev: FSharp.Compiler.Syntax.Ident get_ident()
+FSharp.Compiler.Syntax.SynModuleSigDecl+ModuleAbbrev: FSharp.Compiler.Syntax.Ident ident
+FSharp.Compiler.Syntax.SynModuleSigDecl+ModuleAbbrev: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynModuleSigDecl+ModuleAbbrev: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynModuleSigDecl+ModuleAbbrev: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] get_longId()
+FSharp.Compiler.Syntax.SynModuleSigDecl+ModuleAbbrev: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident] longId
+FSharp.Compiler.Syntax.SynModuleSigDecl+NamespaceFragment: FSharp.Compiler.Syntax.SynModuleOrNamespaceSig Item
+FSharp.Compiler.Syntax.SynModuleSigDecl+NamespaceFragment: FSharp.Compiler.Syntax.SynModuleOrNamespaceSig get_Item()
+FSharp.Compiler.Syntax.SynModuleSigDecl+NestedModule: Boolean get_isRecursive()
+FSharp.Compiler.Syntax.SynModuleSigDecl+NestedModule: Boolean isRecursive
+FSharp.Compiler.Syntax.SynModuleSigDecl+NestedModule: FSharp.Compiler.Syntax.SynComponentInfo get_moduleInfo()
+FSharp.Compiler.Syntax.SynModuleSigDecl+NestedModule: FSharp.Compiler.Syntax.SynComponentInfo moduleInfo
+FSharp.Compiler.Syntax.SynModuleSigDecl+NestedModule: FSharp.Compiler.SyntaxTrivia.SynModuleSigDeclNestedModuleTrivia get_trivia()
+FSharp.Compiler.Syntax.SynModuleSigDecl+NestedModule: FSharp.Compiler.SyntaxTrivia.SynModuleSigDeclNestedModuleTrivia trivia
+FSharp.Compiler.Syntax.SynModuleSigDecl+NestedModule: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynModuleSigDecl+NestedModule: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynModuleSigDecl+NestedModule: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleSigDecl] get_moduleDecls()
+FSharp.Compiler.Syntax.SynModuleSigDecl+NestedModule: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleSigDecl] moduleDecls
+FSharp.Compiler.Syntax.SynModuleSigDecl+Open: FSharp.Compiler.Syntax.SynOpenDeclTarget get_target()
+FSharp.Compiler.Syntax.SynModuleSigDecl+Open: FSharp.Compiler.Syntax.SynOpenDeclTarget target
+FSharp.Compiler.Syntax.SynModuleSigDecl+Open: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynModuleSigDecl+Open: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynModuleSigDecl+Tags: Int32 Exception
+FSharp.Compiler.Syntax.SynModuleSigDecl+Tags: Int32 HashDirective
+FSharp.Compiler.Syntax.SynModuleSigDecl+Tags: Int32 ModuleAbbrev
+FSharp.Compiler.Syntax.SynModuleSigDecl+Tags: Int32 NamespaceFragment
+FSharp.Compiler.Syntax.SynModuleSigDecl+Tags: Int32 NestedModule
+FSharp.Compiler.Syntax.SynModuleSigDecl+Tags: Int32 Open
+FSharp.Compiler.Syntax.SynModuleSigDecl+Tags: Int32 Types
+FSharp.Compiler.Syntax.SynModuleSigDecl+Tags: Int32 Val
+FSharp.Compiler.Syntax.SynModuleSigDecl+Types: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynModuleSigDecl+Types: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynModuleSigDecl+Types: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTypeDefnSig] get_types()
+FSharp.Compiler.Syntax.SynModuleSigDecl+Types: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTypeDefnSig] types
+FSharp.Compiler.Syntax.SynModuleSigDecl+Val: FSharp.Compiler.Syntax.SynValSig get_valSig()
+FSharp.Compiler.Syntax.SynModuleSigDecl+Val: FSharp.Compiler.Syntax.SynValSig valSig
+FSharp.Compiler.Syntax.SynModuleSigDecl+Val: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynModuleSigDecl+Val: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynModuleSigDecl: Boolean IsException
+FSharp.Compiler.Syntax.SynModuleSigDecl: Boolean IsHashDirective
+FSharp.Compiler.Syntax.SynModuleSigDecl: Boolean IsModuleAbbrev
+FSharp.Compiler.Syntax.SynModuleSigDecl: Boolean IsNamespaceFragment
+FSharp.Compiler.Syntax.SynModuleSigDecl: Boolean IsNestedModule
+FSharp.Compiler.Syntax.SynModuleSigDecl: Boolean IsOpen
+FSharp.Compiler.Syntax.SynModuleSigDecl: Boolean IsTypes
+FSharp.Compiler.Syntax.SynModuleSigDecl: Boolean IsVal
+FSharp.Compiler.Syntax.SynModuleSigDecl: Boolean get_IsException()
+FSharp.Compiler.Syntax.SynModuleSigDecl: Boolean get_IsHashDirective()
+FSharp.Compiler.Syntax.SynModuleSigDecl: Boolean get_IsModuleAbbrev()
+FSharp.Compiler.Syntax.SynModuleSigDecl: Boolean get_IsNamespaceFragment()
+FSharp.Compiler.Syntax.SynModuleSigDecl: Boolean get_IsNestedModule()
+FSharp.Compiler.Syntax.SynModuleSigDecl: Boolean get_IsOpen()
+FSharp.Compiler.Syntax.SynModuleSigDecl: Boolean get_IsTypes()
+FSharp.Compiler.Syntax.SynModuleSigDecl: Boolean get_IsVal()
+FSharp.Compiler.Syntax.SynModuleSigDecl: FSharp.Compiler.Syntax.SynModuleSigDecl NewException(FSharp.Compiler.Syntax.SynExceptionSig, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynModuleSigDecl: FSharp.Compiler.Syntax.SynModuleSigDecl NewHashDirective(FSharp.Compiler.Syntax.ParsedHashDirective, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynModuleSigDecl: FSharp.Compiler.Syntax.SynModuleSigDecl NewModuleAbbrev(FSharp.Compiler.Syntax.Ident, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynModuleSigDecl: FSharp.Compiler.Syntax.SynModuleSigDecl NewNamespaceFragment(FSharp.Compiler.Syntax.SynModuleOrNamespaceSig)
+FSharp.Compiler.Syntax.SynModuleSigDecl: FSharp.Compiler.Syntax.SynModuleSigDecl NewNestedModule(FSharp.Compiler.Syntax.SynComponentInfo, Boolean, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynModuleSigDecl], FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynModuleSigDeclNestedModuleTrivia)
+FSharp.Compiler.Syntax.SynModuleSigDecl: FSharp.Compiler.Syntax.SynModuleSigDecl NewOpen(FSharp.Compiler.Syntax.SynOpenDeclTarget, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynModuleSigDecl: FSharp.Compiler.Syntax.SynModuleSigDecl NewTypes(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTypeDefnSig], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynModuleSigDecl: FSharp.Compiler.Syntax.SynModuleSigDecl NewVal(FSharp.Compiler.Syntax.SynValSig, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynModuleSigDecl: FSharp.Compiler.Syntax.SynModuleSigDecl+Exception
+FSharp.Compiler.Syntax.SynModuleSigDecl: FSharp.Compiler.Syntax.SynModuleSigDecl+HashDirective
+FSharp.Compiler.Syntax.SynModuleSigDecl: FSharp.Compiler.Syntax.SynModuleSigDecl+ModuleAbbrev
+FSharp.Compiler.Syntax.SynModuleSigDecl: FSharp.Compiler.Syntax.SynModuleSigDecl+NamespaceFragment
+FSharp.Compiler.Syntax.SynModuleSigDecl: FSharp.Compiler.Syntax.SynModuleSigDecl+NestedModule
+FSharp.Compiler.Syntax.SynModuleSigDecl: FSharp.Compiler.Syntax.SynModuleSigDecl+Open
+FSharp.Compiler.Syntax.SynModuleSigDecl: FSharp.Compiler.Syntax.SynModuleSigDecl+Tags
+FSharp.Compiler.Syntax.SynModuleSigDecl: FSharp.Compiler.Syntax.SynModuleSigDecl+Types
+FSharp.Compiler.Syntax.SynModuleSigDecl: FSharp.Compiler.Syntax.SynModuleSigDecl+Val
+FSharp.Compiler.Syntax.SynModuleSigDecl: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynModuleSigDecl: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynModuleSigDecl: Int32 Tag
+FSharp.Compiler.Syntax.SynModuleSigDecl: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynModuleSigDecl: System.String ToString()
+FSharp.Compiler.Syntax.SynOpenDeclTarget+ModuleOrNamespace: FSharp.Compiler.Syntax.SynLongIdent get_longId()
+FSharp.Compiler.Syntax.SynOpenDeclTarget+ModuleOrNamespace: FSharp.Compiler.Syntax.SynLongIdent longId
+FSharp.Compiler.Syntax.SynOpenDeclTarget+ModuleOrNamespace: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynOpenDeclTarget+ModuleOrNamespace: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynOpenDeclTarget+Tags: Int32 ModuleOrNamespace
+FSharp.Compiler.Syntax.SynOpenDeclTarget+Tags: Int32 Type
+FSharp.Compiler.Syntax.SynOpenDeclTarget+Type: FSharp.Compiler.Syntax.SynType get_typeName()
+FSharp.Compiler.Syntax.SynOpenDeclTarget+Type: FSharp.Compiler.Syntax.SynType typeName
+FSharp.Compiler.Syntax.SynOpenDeclTarget+Type: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynOpenDeclTarget+Type: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynOpenDeclTarget: Boolean IsModuleOrNamespace
+FSharp.Compiler.Syntax.SynOpenDeclTarget: Boolean IsType
+FSharp.Compiler.Syntax.SynOpenDeclTarget: Boolean get_IsModuleOrNamespace()
+FSharp.Compiler.Syntax.SynOpenDeclTarget: Boolean get_IsType()
+FSharp.Compiler.Syntax.SynOpenDeclTarget: FSharp.Compiler.Syntax.SynOpenDeclTarget NewModuleOrNamespace(FSharp.Compiler.Syntax.SynLongIdent, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynOpenDeclTarget: FSharp.Compiler.Syntax.SynOpenDeclTarget NewType(FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynOpenDeclTarget: FSharp.Compiler.Syntax.SynOpenDeclTarget+ModuleOrNamespace
+FSharp.Compiler.Syntax.SynOpenDeclTarget: FSharp.Compiler.Syntax.SynOpenDeclTarget+Tags
+FSharp.Compiler.Syntax.SynOpenDeclTarget: FSharp.Compiler.Syntax.SynOpenDeclTarget+Type
+FSharp.Compiler.Syntax.SynOpenDeclTarget: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynOpenDeclTarget: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynOpenDeclTarget: Int32 Tag
+FSharp.Compiler.Syntax.SynOpenDeclTarget: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynOpenDeclTarget: System.String ToString()
+FSharp.Compiler.Syntax.SynPat+Ands: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynPat+Ands: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynPat+Ands: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynPat] get_pats()
+FSharp.Compiler.Syntax.SynPat+Ands: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynPat] pats
+FSharp.Compiler.Syntax.SynPat+ArrayOrList: Boolean get_isArray()
+FSharp.Compiler.Syntax.SynPat+ArrayOrList: Boolean isArray
+FSharp.Compiler.Syntax.SynPat+ArrayOrList: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynPat+ArrayOrList: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynPat+ArrayOrList: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynPat] elementPats
+FSharp.Compiler.Syntax.SynPat+ArrayOrList: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynPat] get_elementPats()
+FSharp.Compiler.Syntax.SynPat+As: FSharp.Compiler.Syntax.SynPat get_lhsPat()
+FSharp.Compiler.Syntax.SynPat+As: FSharp.Compiler.Syntax.SynPat get_rhsPat()
+FSharp.Compiler.Syntax.SynPat+As: FSharp.Compiler.Syntax.SynPat lhsPat
+FSharp.Compiler.Syntax.SynPat+As: FSharp.Compiler.Syntax.SynPat rhsPat
+FSharp.Compiler.Syntax.SynPat+As: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynPat+As: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynPat+Attrib: FSharp.Compiler.Syntax.SynPat get_pat()
+FSharp.Compiler.Syntax.SynPat+Attrib: FSharp.Compiler.Syntax.SynPat pat
+FSharp.Compiler.Syntax.SynPat+Attrib: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynPat+Attrib: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynPat+Attrib: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] attributes
+FSharp.Compiler.Syntax.SynPat+Attrib: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] get_attributes()
+FSharp.Compiler.Syntax.SynPat+Const: FSharp.Compiler.Syntax.SynConst constant
+FSharp.Compiler.Syntax.SynPat+Const: FSharp.Compiler.Syntax.SynConst get_constant()
+FSharp.Compiler.Syntax.SynPat+Const: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynPat+Const: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynPat+DeprecatedCharRange: Char endChar
+FSharp.Compiler.Syntax.SynPat+DeprecatedCharRange: Char get_endChar()
+FSharp.Compiler.Syntax.SynPat+DeprecatedCharRange: Char get_startChar()
+FSharp.Compiler.Syntax.SynPat+DeprecatedCharRange: Char startChar
+FSharp.Compiler.Syntax.SynPat+DeprecatedCharRange: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynPat+DeprecatedCharRange: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynPat+FromParseError: FSharp.Compiler.Syntax.SynPat get_pat()
+FSharp.Compiler.Syntax.SynPat+FromParseError: FSharp.Compiler.Syntax.SynPat pat
+FSharp.Compiler.Syntax.SynPat+FromParseError: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynPat+FromParseError: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynPat+InstanceMember: FSharp.Compiler.Syntax.Ident get_memberId()
+FSharp.Compiler.Syntax.SynPat+InstanceMember: FSharp.Compiler.Syntax.Ident get_thisId()
+FSharp.Compiler.Syntax.SynPat+InstanceMember: FSharp.Compiler.Syntax.Ident memberId
+FSharp.Compiler.Syntax.SynPat+InstanceMember: FSharp.Compiler.Syntax.Ident thisId
+FSharp.Compiler.Syntax.SynPat+InstanceMember: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynPat+InstanceMember: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynPat+InstanceMember: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] get_toolingId()
+FSharp.Compiler.Syntax.SynPat+InstanceMember: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] toolingId
+FSharp.Compiler.Syntax.SynPat+InstanceMember: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] accessibility
+FSharp.Compiler.Syntax.SynPat+InstanceMember: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] get_accessibility()
+FSharp.Compiler.Syntax.SynPat+IsInst: FSharp.Compiler.Syntax.SynType get_pat()
+FSharp.Compiler.Syntax.SynPat+IsInst: FSharp.Compiler.Syntax.SynType pat
+FSharp.Compiler.Syntax.SynPat+IsInst: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynPat+IsInst: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynPat+ListCons: FSharp.Compiler.Syntax.SynPat get_lhsPat()
+FSharp.Compiler.Syntax.SynPat+ListCons: FSharp.Compiler.Syntax.SynPat get_rhsPat()
+FSharp.Compiler.Syntax.SynPat+ListCons: FSharp.Compiler.Syntax.SynPat lhsPat
+FSharp.Compiler.Syntax.SynPat+ListCons: FSharp.Compiler.Syntax.SynPat rhsPat
+FSharp.Compiler.Syntax.SynPat+ListCons: FSharp.Compiler.SyntaxTrivia.SynPatListConsTrivia get_trivia()
+FSharp.Compiler.Syntax.SynPat+ListCons: FSharp.Compiler.SyntaxTrivia.SynPatListConsTrivia trivia
+FSharp.Compiler.Syntax.SynPat+ListCons: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynPat+ListCons: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynPat+LongIdent: FSharp.Compiler.Syntax.SynArgPats argPats
+FSharp.Compiler.Syntax.SynPat+LongIdent: FSharp.Compiler.Syntax.SynArgPats get_argPats()
+FSharp.Compiler.Syntax.SynPat+LongIdent: FSharp.Compiler.Syntax.SynLongIdent get_longDotId()
+FSharp.Compiler.Syntax.SynPat+LongIdent: FSharp.Compiler.Syntax.SynLongIdent longDotId
+FSharp.Compiler.Syntax.SynPat+LongIdent: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynPat+LongIdent: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynPat+LongIdent: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] extraId
+FSharp.Compiler.Syntax.SynPat+LongIdent: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] get_extraId()
+FSharp.Compiler.Syntax.SynPat+LongIdent: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] accessibility
+FSharp.Compiler.Syntax.SynPat+LongIdent: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] get_accessibility()
+FSharp.Compiler.Syntax.SynPat+LongIdent: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynValTyparDecls] get_typarDecls()
+FSharp.Compiler.Syntax.SynPat+LongIdent: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynValTyparDecls] typarDecls
+FSharp.Compiler.Syntax.SynPat+Named: Boolean get_isThisVal()
+FSharp.Compiler.Syntax.SynPat+Named: Boolean isThisVal
+FSharp.Compiler.Syntax.SynPat+Named: FSharp.Compiler.Syntax.SynIdent get_ident()
+FSharp.Compiler.Syntax.SynPat+Named: FSharp.Compiler.Syntax.SynIdent ident
+FSharp.Compiler.Syntax.SynPat+Named: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynPat+Named: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynPat+Named: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] accessibility
+FSharp.Compiler.Syntax.SynPat+Named: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] get_accessibility()
+FSharp.Compiler.Syntax.SynPat+Null: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynPat+Null: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynPat+OptionalVal: FSharp.Compiler.Syntax.Ident get_ident()
+FSharp.Compiler.Syntax.SynPat+OptionalVal: FSharp.Compiler.Syntax.Ident ident
+FSharp.Compiler.Syntax.SynPat+OptionalVal: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynPat+OptionalVal: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynPat+Or: FSharp.Compiler.Syntax.SynPat get_lhsPat()
+FSharp.Compiler.Syntax.SynPat+Or: FSharp.Compiler.Syntax.SynPat get_rhsPat()
+FSharp.Compiler.Syntax.SynPat+Or: FSharp.Compiler.Syntax.SynPat lhsPat
+FSharp.Compiler.Syntax.SynPat+Or: FSharp.Compiler.Syntax.SynPat rhsPat
+FSharp.Compiler.Syntax.SynPat+Or: FSharp.Compiler.SyntaxTrivia.SynPatOrTrivia get_trivia()
+FSharp.Compiler.Syntax.SynPat+Or: FSharp.Compiler.SyntaxTrivia.SynPatOrTrivia trivia
+FSharp.Compiler.Syntax.SynPat+Or: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynPat+Or: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynPat+Paren: FSharp.Compiler.Syntax.SynPat get_pat()
+FSharp.Compiler.Syntax.SynPat+Paren: FSharp.Compiler.Syntax.SynPat pat
+FSharp.Compiler.Syntax.SynPat+Paren: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynPat+Paren: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynPat+QuoteExpr: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynPat+QuoteExpr: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynPat+QuoteExpr: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynPat+QuoteExpr: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynPat+Record: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynPat+Record: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynPat+Record: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident],FSharp.Compiler.Syntax.Ident],FSharp.Compiler.Text.Range,FSharp.Compiler.Syntax.SynPat]] fieldPats
+FSharp.Compiler.Syntax.SynPat+Record: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident],FSharp.Compiler.Syntax.Ident],FSharp.Compiler.Text.Range,FSharp.Compiler.Syntax.SynPat]] get_fieldPats()
+FSharp.Compiler.Syntax.SynPat+Tags: Int32 Ands
+FSharp.Compiler.Syntax.SynPat+Tags: Int32 ArrayOrList
+FSharp.Compiler.Syntax.SynPat+Tags: Int32 As
+FSharp.Compiler.Syntax.SynPat+Tags: Int32 Attrib
+FSharp.Compiler.Syntax.SynPat+Tags: Int32 Const
+FSharp.Compiler.Syntax.SynPat+Tags: Int32 DeprecatedCharRange
+FSharp.Compiler.Syntax.SynPat+Tags: Int32 FromParseError
+FSharp.Compiler.Syntax.SynPat+Tags: Int32 InstanceMember
+FSharp.Compiler.Syntax.SynPat+Tags: Int32 IsInst
+FSharp.Compiler.Syntax.SynPat+Tags: Int32 ListCons
+FSharp.Compiler.Syntax.SynPat+Tags: Int32 LongIdent
+FSharp.Compiler.Syntax.SynPat+Tags: Int32 Named
+FSharp.Compiler.Syntax.SynPat+Tags: Int32 Null
+FSharp.Compiler.Syntax.SynPat+Tags: Int32 OptionalVal
+FSharp.Compiler.Syntax.SynPat+Tags: Int32 Or
+FSharp.Compiler.Syntax.SynPat+Tags: Int32 Paren
+FSharp.Compiler.Syntax.SynPat+Tags: Int32 QuoteExpr
+FSharp.Compiler.Syntax.SynPat+Tags: Int32 Record
+FSharp.Compiler.Syntax.SynPat+Tags: Int32 Tuple
+FSharp.Compiler.Syntax.SynPat+Tags: Int32 Typed
+FSharp.Compiler.Syntax.SynPat+Tags: Int32 Wild
+FSharp.Compiler.Syntax.SynPat+Tuple: Boolean get_isStruct()
+FSharp.Compiler.Syntax.SynPat+Tuple: Boolean isStruct
+FSharp.Compiler.Syntax.SynPat+Tuple: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynPat+Tuple: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynPat+Tuple: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynPat] elementPats
+FSharp.Compiler.Syntax.SynPat+Tuple: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynPat] get_elementPats()
+FSharp.Compiler.Syntax.SynPat+Typed: FSharp.Compiler.Syntax.SynPat get_pat()
+FSharp.Compiler.Syntax.SynPat+Typed: FSharp.Compiler.Syntax.SynPat pat
+FSharp.Compiler.Syntax.SynPat+Typed: FSharp.Compiler.Syntax.SynType get_targetType()
+FSharp.Compiler.Syntax.SynPat+Typed: FSharp.Compiler.Syntax.SynType targetType
+FSharp.Compiler.Syntax.SynPat+Typed: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynPat+Typed: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynPat+Wild: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynPat+Wild: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynPat: Boolean IsAnds
+FSharp.Compiler.Syntax.SynPat: Boolean IsArrayOrList
+FSharp.Compiler.Syntax.SynPat: Boolean IsAs
+FSharp.Compiler.Syntax.SynPat: Boolean IsAttrib
+FSharp.Compiler.Syntax.SynPat: Boolean IsConst
+FSharp.Compiler.Syntax.SynPat: Boolean IsDeprecatedCharRange
+FSharp.Compiler.Syntax.SynPat: Boolean IsFromParseError
+FSharp.Compiler.Syntax.SynPat: Boolean IsInstanceMember
+FSharp.Compiler.Syntax.SynPat: Boolean IsIsInst
+FSharp.Compiler.Syntax.SynPat: Boolean IsListCons
+FSharp.Compiler.Syntax.SynPat: Boolean IsLongIdent
+FSharp.Compiler.Syntax.SynPat: Boolean IsNamed
+FSharp.Compiler.Syntax.SynPat: Boolean IsNull
+FSharp.Compiler.Syntax.SynPat: Boolean IsOptionalVal
+FSharp.Compiler.Syntax.SynPat: Boolean IsOr
+FSharp.Compiler.Syntax.SynPat: Boolean IsParen
+FSharp.Compiler.Syntax.SynPat: Boolean IsQuoteExpr
+FSharp.Compiler.Syntax.SynPat: Boolean IsRecord
+FSharp.Compiler.Syntax.SynPat: Boolean IsTuple
+FSharp.Compiler.Syntax.SynPat: Boolean IsTyped
+FSharp.Compiler.Syntax.SynPat: Boolean IsWild
+FSharp.Compiler.Syntax.SynPat: Boolean get_IsAnds()
+FSharp.Compiler.Syntax.SynPat: Boolean get_IsArrayOrList()
+FSharp.Compiler.Syntax.SynPat: Boolean get_IsAs()
+FSharp.Compiler.Syntax.SynPat: Boolean get_IsAttrib()
+FSharp.Compiler.Syntax.SynPat: Boolean get_IsConst()
+FSharp.Compiler.Syntax.SynPat: Boolean get_IsDeprecatedCharRange()
+FSharp.Compiler.Syntax.SynPat: Boolean get_IsFromParseError()
+FSharp.Compiler.Syntax.SynPat: Boolean get_IsInstanceMember()
+FSharp.Compiler.Syntax.SynPat: Boolean get_IsIsInst()
+FSharp.Compiler.Syntax.SynPat: Boolean get_IsListCons()
+FSharp.Compiler.Syntax.SynPat: Boolean get_IsLongIdent()
+FSharp.Compiler.Syntax.SynPat: Boolean get_IsNamed()
+FSharp.Compiler.Syntax.SynPat: Boolean get_IsNull()
+FSharp.Compiler.Syntax.SynPat: Boolean get_IsOptionalVal()
+FSharp.Compiler.Syntax.SynPat: Boolean get_IsOr()
+FSharp.Compiler.Syntax.SynPat: Boolean get_IsParen()
+FSharp.Compiler.Syntax.SynPat: Boolean get_IsQuoteExpr()
+FSharp.Compiler.Syntax.SynPat: Boolean get_IsRecord()
+FSharp.Compiler.Syntax.SynPat: Boolean get_IsTuple()
+FSharp.Compiler.Syntax.SynPat: Boolean get_IsTyped()
+FSharp.Compiler.Syntax.SynPat: Boolean get_IsWild()
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat NewAnds(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynPat], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat NewArrayOrList(Boolean, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynPat], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat NewAs(FSharp.Compiler.Syntax.SynPat, FSharp.Compiler.Syntax.SynPat, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat NewAttrib(FSharp.Compiler.Syntax.SynPat, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat NewConst(FSharp.Compiler.Syntax.SynConst, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat NewDeprecatedCharRange(Char, Char, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat NewFromParseError(FSharp.Compiler.Syntax.SynPat, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat NewInstanceMember(FSharp.Compiler.Syntax.Ident, FSharp.Compiler.Syntax.Ident, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat NewIsInst(FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat NewListCons(FSharp.Compiler.Syntax.SynPat, FSharp.Compiler.Syntax.SynPat, FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynPatListConsTrivia)
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat NewLongIdent(FSharp.Compiler.Syntax.SynLongIdent, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynValTyparDecls], FSharp.Compiler.Syntax.SynArgPats, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat NewNamed(FSharp.Compiler.Syntax.SynIdent, Boolean, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat NewNull(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat NewOptionalVal(FSharp.Compiler.Syntax.Ident, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat NewOr(FSharp.Compiler.Syntax.SynPat, FSharp.Compiler.Syntax.SynPat, FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynPatOrTrivia)
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat NewParen(FSharp.Compiler.Syntax.SynPat, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat NewQuoteExpr(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat NewRecord(Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.Ident],FSharp.Compiler.Syntax.Ident],FSharp.Compiler.Text.Range,FSharp.Compiler.Syntax.SynPat]], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat NewTuple(Boolean, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynPat], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat NewTyped(FSharp.Compiler.Syntax.SynPat, FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat NewWild(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat+Ands
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat+ArrayOrList
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat+As
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat+Attrib
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat+Const
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat+DeprecatedCharRange
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat+FromParseError
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat+InstanceMember
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat+IsInst
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat+ListCons
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat+LongIdent
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat+Named
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat+Null
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat+OptionalVal
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat+Or
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat+Paren
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat+QuoteExpr
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat+Record
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat+Tags
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat+Tuple
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat+Typed
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Syntax.SynPat+Wild
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynPat: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynPat: Int32 Tag
+FSharp.Compiler.Syntax.SynPat: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynPat: System.String ToString()
+FSharp.Compiler.Syntax.SynRationalConst+Integer: Int32 get_value()
+FSharp.Compiler.Syntax.SynRationalConst+Integer: Int32 value
+FSharp.Compiler.Syntax.SynRationalConst+Negate: FSharp.Compiler.Syntax.SynRationalConst Item
+FSharp.Compiler.Syntax.SynRationalConst+Negate: FSharp.Compiler.Syntax.SynRationalConst get_Item()
+FSharp.Compiler.Syntax.SynRationalConst+Rational: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynRationalConst+Rational: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynRationalConst+Rational: Int32 denominator
+FSharp.Compiler.Syntax.SynRationalConst+Rational: Int32 get_denominator()
+FSharp.Compiler.Syntax.SynRationalConst+Rational: Int32 get_numerator()
+FSharp.Compiler.Syntax.SynRationalConst+Rational: Int32 numerator
+FSharp.Compiler.Syntax.SynRationalConst+Tags: Int32 Integer
+FSharp.Compiler.Syntax.SynRationalConst+Tags: Int32 Negate
+FSharp.Compiler.Syntax.SynRationalConst+Tags: Int32 Rational
+FSharp.Compiler.Syntax.SynRationalConst: Boolean IsInteger
+FSharp.Compiler.Syntax.SynRationalConst: Boolean IsNegate
+FSharp.Compiler.Syntax.SynRationalConst: Boolean IsRational
+FSharp.Compiler.Syntax.SynRationalConst: Boolean get_IsInteger()
+FSharp.Compiler.Syntax.SynRationalConst: Boolean get_IsNegate()
+FSharp.Compiler.Syntax.SynRationalConst: Boolean get_IsRational()
+FSharp.Compiler.Syntax.SynRationalConst: FSharp.Compiler.Syntax.SynRationalConst NewInteger(Int32)
+FSharp.Compiler.Syntax.SynRationalConst: FSharp.Compiler.Syntax.SynRationalConst NewNegate(FSharp.Compiler.Syntax.SynRationalConst)
+FSharp.Compiler.Syntax.SynRationalConst: FSharp.Compiler.Syntax.SynRationalConst NewRational(Int32, Int32, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynRationalConst: FSharp.Compiler.Syntax.SynRationalConst+Integer
+FSharp.Compiler.Syntax.SynRationalConst: FSharp.Compiler.Syntax.SynRationalConst+Negate
+FSharp.Compiler.Syntax.SynRationalConst: FSharp.Compiler.Syntax.SynRationalConst+Rational
+FSharp.Compiler.Syntax.SynRationalConst: FSharp.Compiler.Syntax.SynRationalConst+Tags
+FSharp.Compiler.Syntax.SynRationalConst: Int32 Tag
+FSharp.Compiler.Syntax.SynRationalConst: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynRationalConst: System.String ToString()
+FSharp.Compiler.Syntax.SynReturnInfo: FSharp.Compiler.Syntax.SynReturnInfo NewSynReturnInfo(System.Tuple`2[FSharp.Compiler.Syntax.SynType,FSharp.Compiler.Syntax.SynArgInfo], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynReturnInfo: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynReturnInfo: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynReturnInfo: Int32 Tag
+FSharp.Compiler.Syntax.SynReturnInfo: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynReturnInfo: System.String ToString()
+FSharp.Compiler.Syntax.SynReturnInfo: System.Tuple`2[FSharp.Compiler.Syntax.SynType,FSharp.Compiler.Syntax.SynArgInfo] get_returnType()
+FSharp.Compiler.Syntax.SynReturnInfo: System.Tuple`2[FSharp.Compiler.Syntax.SynType,FSharp.Compiler.Syntax.SynArgInfo] returnType
+FSharp.Compiler.Syntax.SynSimplePat+Attrib: FSharp.Compiler.Syntax.SynSimplePat get_pat()
+FSharp.Compiler.Syntax.SynSimplePat+Attrib: FSharp.Compiler.Syntax.SynSimplePat pat
+FSharp.Compiler.Syntax.SynSimplePat+Attrib: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynSimplePat+Attrib: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynSimplePat+Attrib: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] attributes
+FSharp.Compiler.Syntax.SynSimplePat+Attrib: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] get_attributes()
+FSharp.Compiler.Syntax.SynSimplePat+Id: Boolean get_isCompilerGenerated()
+FSharp.Compiler.Syntax.SynSimplePat+Id: Boolean get_isOptional()
+FSharp.Compiler.Syntax.SynSimplePat+Id: Boolean get_isThisVal()
+FSharp.Compiler.Syntax.SynSimplePat+Id: Boolean isCompilerGenerated
+FSharp.Compiler.Syntax.SynSimplePat+Id: Boolean isOptional
+FSharp.Compiler.Syntax.SynSimplePat+Id: Boolean isThisVal
+FSharp.Compiler.Syntax.SynSimplePat+Id: FSharp.Compiler.Syntax.Ident get_ident()
+FSharp.Compiler.Syntax.SynSimplePat+Id: FSharp.Compiler.Syntax.Ident ident
+FSharp.Compiler.Syntax.SynSimplePat+Id: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynSimplePat+Id: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynSimplePat+Id: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpRef`1[FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo]] altNameRefCell
+FSharp.Compiler.Syntax.SynSimplePat+Id: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpRef`1[FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo]] get_altNameRefCell()
+FSharp.Compiler.Syntax.SynSimplePat+Tags: Int32 Attrib
+FSharp.Compiler.Syntax.SynSimplePat+Tags: Int32 Id
+FSharp.Compiler.Syntax.SynSimplePat+Tags: Int32 Typed
+FSharp.Compiler.Syntax.SynSimplePat+Typed: FSharp.Compiler.Syntax.SynSimplePat get_pat()
+FSharp.Compiler.Syntax.SynSimplePat+Typed: FSharp.Compiler.Syntax.SynSimplePat pat
+FSharp.Compiler.Syntax.SynSimplePat+Typed: FSharp.Compiler.Syntax.SynType get_targetType()
+FSharp.Compiler.Syntax.SynSimplePat+Typed: FSharp.Compiler.Syntax.SynType targetType
+FSharp.Compiler.Syntax.SynSimplePat+Typed: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynSimplePat+Typed: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynSimplePat: Boolean IsAttrib
+FSharp.Compiler.Syntax.SynSimplePat: Boolean IsId
+FSharp.Compiler.Syntax.SynSimplePat: Boolean IsTyped
+FSharp.Compiler.Syntax.SynSimplePat: Boolean get_IsAttrib()
+FSharp.Compiler.Syntax.SynSimplePat: Boolean get_IsId()
+FSharp.Compiler.Syntax.SynSimplePat: Boolean get_IsTyped()
+FSharp.Compiler.Syntax.SynSimplePat: FSharp.Compiler.Syntax.SynSimplePat NewAttrib(FSharp.Compiler.Syntax.SynSimplePat, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynSimplePat: FSharp.Compiler.Syntax.SynSimplePat NewId(FSharp.Compiler.Syntax.Ident, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpRef`1[FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo]], Boolean, Boolean, Boolean, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynSimplePat: FSharp.Compiler.Syntax.SynSimplePat NewTyped(FSharp.Compiler.Syntax.SynSimplePat, FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynSimplePat: FSharp.Compiler.Syntax.SynSimplePat+Attrib
+FSharp.Compiler.Syntax.SynSimplePat: FSharp.Compiler.Syntax.SynSimplePat+Id
+FSharp.Compiler.Syntax.SynSimplePat: FSharp.Compiler.Syntax.SynSimplePat+Tags
+FSharp.Compiler.Syntax.SynSimplePat: FSharp.Compiler.Syntax.SynSimplePat+Typed
+FSharp.Compiler.Syntax.SynSimplePat: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynSimplePat: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynSimplePat: Int32 Tag
+FSharp.Compiler.Syntax.SynSimplePat: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynSimplePat: System.String ToString()
+FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo+Decided: FSharp.Compiler.Syntax.Ident Item
+FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo+Decided: FSharp.Compiler.Syntax.Ident get_Item()
+FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo+Tags: Int32 Decided
+FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo+Tags: Int32 Undecided
+FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo+Undecided: FSharp.Compiler.Syntax.Ident Item
+FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo+Undecided: FSharp.Compiler.Syntax.Ident get_Item()
+FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo: Boolean IsDecided
+FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo: Boolean IsUndecided
+FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo: Boolean get_IsDecided()
+FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo: Boolean get_IsUndecided()
+FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo: FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo NewDecided(FSharp.Compiler.Syntax.Ident)
+FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo: FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo NewUndecided(FSharp.Compiler.Syntax.Ident)
+FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo: FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo+Decided
+FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo: FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo+Tags
+FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo: FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo+Undecided
+FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo: Int32 Tag
+FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynSimplePatAlternativeIdInfo: System.String ToString()
+FSharp.Compiler.Syntax.SynSimplePats+SimplePats: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynSimplePats+SimplePats: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynSimplePats+SimplePats: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynSimplePat] get_pats()
+FSharp.Compiler.Syntax.SynSimplePats+SimplePats: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynSimplePat] pats
+FSharp.Compiler.Syntax.SynSimplePats+Tags: Int32 SimplePats
+FSharp.Compiler.Syntax.SynSimplePats+Tags: Int32 Typed
+FSharp.Compiler.Syntax.SynSimplePats+Typed: FSharp.Compiler.Syntax.SynSimplePats get_pats()
+FSharp.Compiler.Syntax.SynSimplePats+Typed: FSharp.Compiler.Syntax.SynSimplePats pats
+FSharp.Compiler.Syntax.SynSimplePats+Typed: FSharp.Compiler.Syntax.SynType get_targetType()
+FSharp.Compiler.Syntax.SynSimplePats+Typed: FSharp.Compiler.Syntax.SynType targetType
+FSharp.Compiler.Syntax.SynSimplePats+Typed: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynSimplePats+Typed: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynSimplePats: Boolean IsSimplePats
+FSharp.Compiler.Syntax.SynSimplePats: Boolean IsTyped
+FSharp.Compiler.Syntax.SynSimplePats: Boolean get_IsSimplePats()
+FSharp.Compiler.Syntax.SynSimplePats: Boolean get_IsTyped()
+FSharp.Compiler.Syntax.SynSimplePats: FSharp.Compiler.Syntax.SynSimplePats NewSimplePats(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynSimplePat], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynSimplePats: FSharp.Compiler.Syntax.SynSimplePats NewTyped(FSharp.Compiler.Syntax.SynSimplePats, FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynSimplePats: FSharp.Compiler.Syntax.SynSimplePats+SimplePats
+FSharp.Compiler.Syntax.SynSimplePats: FSharp.Compiler.Syntax.SynSimplePats+Tags
+FSharp.Compiler.Syntax.SynSimplePats: FSharp.Compiler.Syntax.SynSimplePats+Typed
+FSharp.Compiler.Syntax.SynSimplePats: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynSimplePats: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynSimplePats: Int32 Tag
+FSharp.Compiler.Syntax.SynSimplePats: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynSimplePats: System.String ToString()
+FSharp.Compiler.Syntax.SynStaticOptimizationConstraint+Tags: Int32 WhenTyparIsStruct
+FSharp.Compiler.Syntax.SynStaticOptimizationConstraint+Tags: Int32 WhenTyparTyconEqualsTycon
+FSharp.Compiler.Syntax.SynStaticOptimizationConstraint+WhenTyparIsStruct: FSharp.Compiler.Syntax.SynTypar get_typar()
+FSharp.Compiler.Syntax.SynStaticOptimizationConstraint+WhenTyparIsStruct: FSharp.Compiler.Syntax.SynTypar typar
+FSharp.Compiler.Syntax.SynStaticOptimizationConstraint+WhenTyparIsStruct: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynStaticOptimizationConstraint+WhenTyparIsStruct: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynStaticOptimizationConstraint+WhenTyparTyconEqualsTycon: FSharp.Compiler.Syntax.SynTypar get_typar()
+FSharp.Compiler.Syntax.SynStaticOptimizationConstraint+WhenTyparTyconEqualsTycon: FSharp.Compiler.Syntax.SynTypar typar
+FSharp.Compiler.Syntax.SynStaticOptimizationConstraint+WhenTyparTyconEqualsTycon: FSharp.Compiler.Syntax.SynType get_rhsType()
+FSharp.Compiler.Syntax.SynStaticOptimizationConstraint+WhenTyparTyconEqualsTycon: FSharp.Compiler.Syntax.SynType rhsType
+FSharp.Compiler.Syntax.SynStaticOptimizationConstraint+WhenTyparTyconEqualsTycon: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynStaticOptimizationConstraint+WhenTyparTyconEqualsTycon: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynStaticOptimizationConstraint: Boolean IsWhenTyparIsStruct
+FSharp.Compiler.Syntax.SynStaticOptimizationConstraint: Boolean IsWhenTyparTyconEqualsTycon
+FSharp.Compiler.Syntax.SynStaticOptimizationConstraint: Boolean get_IsWhenTyparIsStruct()
+FSharp.Compiler.Syntax.SynStaticOptimizationConstraint: Boolean get_IsWhenTyparTyconEqualsTycon()
+FSharp.Compiler.Syntax.SynStaticOptimizationConstraint: FSharp.Compiler.Syntax.SynStaticOptimizationConstraint NewWhenTyparIsStruct(FSharp.Compiler.Syntax.SynTypar, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynStaticOptimizationConstraint: FSharp.Compiler.Syntax.SynStaticOptimizationConstraint NewWhenTyparTyconEqualsTycon(FSharp.Compiler.Syntax.SynTypar, FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynStaticOptimizationConstraint: FSharp.Compiler.Syntax.SynStaticOptimizationConstraint+Tags
+FSharp.Compiler.Syntax.SynStaticOptimizationConstraint: FSharp.Compiler.Syntax.SynStaticOptimizationConstraint+WhenTyparIsStruct
+FSharp.Compiler.Syntax.SynStaticOptimizationConstraint: FSharp.Compiler.Syntax.SynStaticOptimizationConstraint+WhenTyparTyconEqualsTycon
+FSharp.Compiler.Syntax.SynStaticOptimizationConstraint: Int32 Tag
+FSharp.Compiler.Syntax.SynStaticOptimizationConstraint: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynStaticOptimizationConstraint: System.String ToString()
+FSharp.Compiler.Syntax.SynStringKind+Tags: Int32 Regular
+FSharp.Compiler.Syntax.SynStringKind+Tags: Int32 TripleQuote
+FSharp.Compiler.Syntax.SynStringKind+Tags: Int32 Verbatim
+FSharp.Compiler.Syntax.SynStringKind: Boolean Equals(FSharp.Compiler.Syntax.SynStringKind)
+FSharp.Compiler.Syntax.SynStringKind: Boolean Equals(System.Object)
+FSharp.Compiler.Syntax.SynStringKind: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.SynStringKind: Boolean IsRegular
+FSharp.Compiler.Syntax.SynStringKind: Boolean IsTripleQuote
+FSharp.Compiler.Syntax.SynStringKind: Boolean IsVerbatim
+FSharp.Compiler.Syntax.SynStringKind: Boolean get_IsRegular()
+FSharp.Compiler.Syntax.SynStringKind: Boolean get_IsTripleQuote()
+FSharp.Compiler.Syntax.SynStringKind: Boolean get_IsVerbatim()
+FSharp.Compiler.Syntax.SynStringKind: FSharp.Compiler.Syntax.SynStringKind Regular
+FSharp.Compiler.Syntax.SynStringKind: FSharp.Compiler.Syntax.SynStringKind TripleQuote
+FSharp.Compiler.Syntax.SynStringKind: FSharp.Compiler.Syntax.SynStringKind Verbatim
+FSharp.Compiler.Syntax.SynStringKind: FSharp.Compiler.Syntax.SynStringKind get_Regular()
+FSharp.Compiler.Syntax.SynStringKind: FSharp.Compiler.Syntax.SynStringKind get_TripleQuote()
+FSharp.Compiler.Syntax.SynStringKind: FSharp.Compiler.Syntax.SynStringKind get_Verbatim()
+FSharp.Compiler.Syntax.SynStringKind: FSharp.Compiler.Syntax.SynStringKind+Tags
+FSharp.Compiler.Syntax.SynStringKind: Int32 CompareTo(FSharp.Compiler.Syntax.SynStringKind)
+FSharp.Compiler.Syntax.SynStringKind: Int32 CompareTo(System.Object)
+FSharp.Compiler.Syntax.SynStringKind: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.Syntax.SynStringKind: Int32 GetHashCode()
+FSharp.Compiler.Syntax.SynStringKind: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.SynStringKind: Int32 Tag
+FSharp.Compiler.Syntax.SynStringKind: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynStringKind: System.String ToString()
+FSharp.Compiler.Syntax.SynTupleTypeSegment+Slash: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTupleTypeSegment+Slash: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTupleTypeSegment+Star: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTupleTypeSegment+Star: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTupleTypeSegment+Tags: Int32 Slash
+FSharp.Compiler.Syntax.SynTupleTypeSegment+Tags: Int32 Star
+FSharp.Compiler.Syntax.SynTupleTypeSegment+Tags: Int32 Type
+FSharp.Compiler.Syntax.SynTupleTypeSegment+Type: FSharp.Compiler.Syntax.SynType get_typeName()
+FSharp.Compiler.Syntax.SynTupleTypeSegment+Type: FSharp.Compiler.Syntax.SynType typeName
+FSharp.Compiler.Syntax.SynTupleTypeSegment: Boolean IsSlash
+FSharp.Compiler.Syntax.SynTupleTypeSegment: Boolean IsStar
+FSharp.Compiler.Syntax.SynTupleTypeSegment: Boolean IsType
+FSharp.Compiler.Syntax.SynTupleTypeSegment: Boolean get_IsSlash()
+FSharp.Compiler.Syntax.SynTupleTypeSegment: Boolean get_IsStar()
+FSharp.Compiler.Syntax.SynTupleTypeSegment: Boolean get_IsType()
+FSharp.Compiler.Syntax.SynTupleTypeSegment: FSharp.Compiler.Syntax.SynTupleTypeSegment NewSlash(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTupleTypeSegment: FSharp.Compiler.Syntax.SynTupleTypeSegment NewStar(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTupleTypeSegment: FSharp.Compiler.Syntax.SynTupleTypeSegment NewType(FSharp.Compiler.Syntax.SynType)
+FSharp.Compiler.Syntax.SynTupleTypeSegment: FSharp.Compiler.Syntax.SynTupleTypeSegment+Slash
+FSharp.Compiler.Syntax.SynTupleTypeSegment: FSharp.Compiler.Syntax.SynTupleTypeSegment+Star
+FSharp.Compiler.Syntax.SynTupleTypeSegment: FSharp.Compiler.Syntax.SynTupleTypeSegment+Tags
+FSharp.Compiler.Syntax.SynTupleTypeSegment: FSharp.Compiler.Syntax.SynTupleTypeSegment+Type
+FSharp.Compiler.Syntax.SynTupleTypeSegment: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynTupleTypeSegment: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynTupleTypeSegment: Int32 Tag
+FSharp.Compiler.Syntax.SynTupleTypeSegment: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynTupleTypeSegment: System.String ToString()
+FSharp.Compiler.Syntax.SynTypar: Boolean get_isCompGen()
+FSharp.Compiler.Syntax.SynTypar: Boolean isCompGen
+FSharp.Compiler.Syntax.SynTypar: FSharp.Compiler.Syntax.Ident get_ident()
+FSharp.Compiler.Syntax.SynTypar: FSharp.Compiler.Syntax.Ident ident
+FSharp.Compiler.Syntax.SynTypar: FSharp.Compiler.Syntax.SynTypar NewSynTypar(FSharp.Compiler.Syntax.Ident, FSharp.Compiler.Syntax.TyparStaticReq, Boolean)
+FSharp.Compiler.Syntax.SynTypar: FSharp.Compiler.Syntax.TyparStaticReq get_staticReq()
+FSharp.Compiler.Syntax.SynTypar: FSharp.Compiler.Syntax.TyparStaticReq staticReq
+FSharp.Compiler.Syntax.SynTypar: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynTypar: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynTypar: Int32 Tag
+FSharp.Compiler.Syntax.SynTypar: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynTypar: System.String ToString()
+FSharp.Compiler.Syntax.SynTyparDecl: FSharp.Compiler.Syntax.SynTypar Item2
+FSharp.Compiler.Syntax.SynTyparDecl: FSharp.Compiler.Syntax.SynTypar get_Item2()
+FSharp.Compiler.Syntax.SynTyparDecl: FSharp.Compiler.Syntax.SynTyparDecl NewSynTyparDecl(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], FSharp.Compiler.Syntax.SynTypar)
+FSharp.Compiler.Syntax.SynTyparDecl: Int32 Tag
+FSharp.Compiler.Syntax.SynTyparDecl: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynTyparDecl: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] attributes
+FSharp.Compiler.Syntax.SynTyparDecl: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] get_attributes()
+FSharp.Compiler.Syntax.SynTyparDecl: System.String ToString()
+FSharp.Compiler.Syntax.SynTyparDecls+PostfixList: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTyparDecls+PostfixList: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTyparDecls+PostfixList: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTyparDecl] decls
+FSharp.Compiler.Syntax.SynTyparDecls+PostfixList: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTyparDecl] get_decls()
+FSharp.Compiler.Syntax.SynTyparDecls+PostfixList: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTypeConstraint] constraints
+FSharp.Compiler.Syntax.SynTyparDecls+PostfixList: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTypeConstraint] get_constraints()
+FSharp.Compiler.Syntax.SynTyparDecls+PrefixList: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTyparDecls+PrefixList: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTyparDecls+PrefixList: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTyparDecl] decls
+FSharp.Compiler.Syntax.SynTyparDecls+PrefixList: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTyparDecl] get_decls()
+FSharp.Compiler.Syntax.SynTyparDecls+SinglePrefix: FSharp.Compiler.Syntax.SynTyparDecl decl
+FSharp.Compiler.Syntax.SynTyparDecls+SinglePrefix: FSharp.Compiler.Syntax.SynTyparDecl get_decl()
+FSharp.Compiler.Syntax.SynTyparDecls+SinglePrefix: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTyparDecls+SinglePrefix: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTyparDecls+Tags: Int32 PostfixList
+FSharp.Compiler.Syntax.SynTyparDecls+Tags: Int32 PrefixList
+FSharp.Compiler.Syntax.SynTyparDecls+Tags: Int32 SinglePrefix
+FSharp.Compiler.Syntax.SynTyparDecls: Boolean IsPostfixList
+FSharp.Compiler.Syntax.SynTyparDecls: Boolean IsPrefixList
+FSharp.Compiler.Syntax.SynTyparDecls: Boolean IsSinglePrefix
+FSharp.Compiler.Syntax.SynTyparDecls: Boolean get_IsPostfixList()
+FSharp.Compiler.Syntax.SynTyparDecls: Boolean get_IsPrefixList()
+FSharp.Compiler.Syntax.SynTyparDecls: Boolean get_IsSinglePrefix()
+FSharp.Compiler.Syntax.SynTyparDecls: FSharp.Compiler.Syntax.SynTyparDecls NewPostfixList(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTyparDecl], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTypeConstraint], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTyparDecls: FSharp.Compiler.Syntax.SynTyparDecls NewPrefixList(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTyparDecl], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTyparDecls: FSharp.Compiler.Syntax.SynTyparDecls NewSinglePrefix(FSharp.Compiler.Syntax.SynTyparDecl, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTyparDecls: FSharp.Compiler.Syntax.SynTyparDecls+PostfixList
+FSharp.Compiler.Syntax.SynTyparDecls: FSharp.Compiler.Syntax.SynTyparDecls+PrefixList
+FSharp.Compiler.Syntax.SynTyparDecls: FSharp.Compiler.Syntax.SynTyparDecls+SinglePrefix
+FSharp.Compiler.Syntax.SynTyparDecls: FSharp.Compiler.Syntax.SynTyparDecls+Tags
+FSharp.Compiler.Syntax.SynTyparDecls: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynTyparDecls: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynTyparDecls: Int32 Tag
+FSharp.Compiler.Syntax.SynTyparDecls: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynTyparDecls: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTyparDecl] TyparDecls
+FSharp.Compiler.Syntax.SynTyparDecls: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTyparDecl] get_TyparDecls()
+FSharp.Compiler.Syntax.SynTyparDecls: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTypeConstraint] Constraints
+FSharp.Compiler.Syntax.SynTyparDecls: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTypeConstraint] get_Constraints()
+FSharp.Compiler.Syntax.SynTyparDecls: System.String ToString()
+FSharp.Compiler.Syntax.SynType+Anon: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynType+Anon: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynType+AnonRecd: Boolean get_isStruct()
+FSharp.Compiler.Syntax.SynType+AnonRecd: Boolean isStruct
+FSharp.Compiler.Syntax.SynType+AnonRecd: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynType+AnonRecd: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynType+AnonRecd: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[FSharp.Compiler.Syntax.Ident,FSharp.Compiler.Syntax.SynType]] fields
+FSharp.Compiler.Syntax.SynType+AnonRecd: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[FSharp.Compiler.Syntax.Ident,FSharp.Compiler.Syntax.SynType]] get_fields()
+FSharp.Compiler.Syntax.SynType+App: Boolean get_isPostfix()
+FSharp.Compiler.Syntax.SynType+App: Boolean isPostfix
+FSharp.Compiler.Syntax.SynType+App: FSharp.Compiler.Syntax.SynType get_typeName()
+FSharp.Compiler.Syntax.SynType+App: FSharp.Compiler.Syntax.SynType typeName
+FSharp.Compiler.Syntax.SynType+App: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynType+App: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynType+App: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynType] get_typeArgs()
+FSharp.Compiler.Syntax.SynType+App: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynType] typeArgs
+FSharp.Compiler.Syntax.SynType+App: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.Range] commaRanges
+FSharp.Compiler.Syntax.SynType+App: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.Range] get_commaRanges()
+FSharp.Compiler.Syntax.SynType+App: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_greaterRange()
+FSharp.Compiler.Syntax.SynType+App: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_lessRange()
+FSharp.Compiler.Syntax.SynType+App: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] greaterRange
+FSharp.Compiler.Syntax.SynType+App: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] lessRange
+FSharp.Compiler.Syntax.SynType+Array: FSharp.Compiler.Syntax.SynType elementType
+FSharp.Compiler.Syntax.SynType+Array: FSharp.Compiler.Syntax.SynType get_elementType()
+FSharp.Compiler.Syntax.SynType+Array: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynType+Array: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynType+Array: Int32 get_rank()
+FSharp.Compiler.Syntax.SynType+Array: Int32 rank
+FSharp.Compiler.Syntax.SynType+Fun: FSharp.Compiler.Syntax.SynType argType
+FSharp.Compiler.Syntax.SynType+Fun: FSharp.Compiler.Syntax.SynType get_argType()
+FSharp.Compiler.Syntax.SynType+Fun: FSharp.Compiler.Syntax.SynType get_returnType()
+FSharp.Compiler.Syntax.SynType+Fun: FSharp.Compiler.Syntax.SynType returnType
+FSharp.Compiler.Syntax.SynType+Fun: FSharp.Compiler.SyntaxTrivia.SynTypeFunTrivia get_trivia()
+FSharp.Compiler.Syntax.SynType+Fun: FSharp.Compiler.SyntaxTrivia.SynTypeFunTrivia trivia
+FSharp.Compiler.Syntax.SynType+Fun: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynType+Fun: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynType+HashConstraint: FSharp.Compiler.Syntax.SynType get_innerType()
+FSharp.Compiler.Syntax.SynType+HashConstraint: FSharp.Compiler.Syntax.SynType innerType
+FSharp.Compiler.Syntax.SynType+HashConstraint: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynType+HashConstraint: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynType+LongIdent: FSharp.Compiler.Syntax.SynLongIdent get_longDotId()
+FSharp.Compiler.Syntax.SynType+LongIdent: FSharp.Compiler.Syntax.SynLongIdent longDotId
+FSharp.Compiler.Syntax.SynType+LongIdentApp: FSharp.Compiler.Syntax.SynLongIdent get_longDotId()
+FSharp.Compiler.Syntax.SynType+LongIdentApp: FSharp.Compiler.Syntax.SynLongIdent longDotId
+FSharp.Compiler.Syntax.SynType+LongIdentApp: FSharp.Compiler.Syntax.SynType get_typeName()
+FSharp.Compiler.Syntax.SynType+LongIdentApp: FSharp.Compiler.Syntax.SynType typeName
+FSharp.Compiler.Syntax.SynType+LongIdentApp: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynType+LongIdentApp: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynType+LongIdentApp: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynType] get_typeArgs()
+FSharp.Compiler.Syntax.SynType+LongIdentApp: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynType] typeArgs
+FSharp.Compiler.Syntax.SynType+LongIdentApp: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.Range] commaRanges
+FSharp.Compiler.Syntax.SynType+LongIdentApp: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.Range] get_commaRanges()
+FSharp.Compiler.Syntax.SynType+LongIdentApp: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_greaterRange()
+FSharp.Compiler.Syntax.SynType+LongIdentApp: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_lessRange()
+FSharp.Compiler.Syntax.SynType+LongIdentApp: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] greaterRange
+FSharp.Compiler.Syntax.SynType+LongIdentApp: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] lessRange
+FSharp.Compiler.Syntax.SynType+MeasurePower: FSharp.Compiler.Syntax.SynRationalConst exponent
+FSharp.Compiler.Syntax.SynType+MeasurePower: FSharp.Compiler.Syntax.SynRationalConst get_exponent()
+FSharp.Compiler.Syntax.SynType+MeasurePower: FSharp.Compiler.Syntax.SynType baseMeasure
+FSharp.Compiler.Syntax.SynType+MeasurePower: FSharp.Compiler.Syntax.SynType get_baseMeasure()
+FSharp.Compiler.Syntax.SynType+MeasurePower: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynType+MeasurePower: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynType+Or: FSharp.Compiler.Syntax.SynType get_lhsType()
+FSharp.Compiler.Syntax.SynType+Or: FSharp.Compiler.Syntax.SynType get_rhsType()
+FSharp.Compiler.Syntax.SynType+Or: FSharp.Compiler.Syntax.SynType lhsType
+FSharp.Compiler.Syntax.SynType+Or: FSharp.Compiler.Syntax.SynType rhsType
+FSharp.Compiler.Syntax.SynType+Or: FSharp.Compiler.SyntaxTrivia.SynTypeOrTrivia get_trivia()
+FSharp.Compiler.Syntax.SynType+Or: FSharp.Compiler.SyntaxTrivia.SynTypeOrTrivia trivia
+FSharp.Compiler.Syntax.SynType+Or: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynType+Or: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynType+Paren: FSharp.Compiler.Syntax.SynType get_innerType()
+FSharp.Compiler.Syntax.SynType+Paren: FSharp.Compiler.Syntax.SynType innerType
+FSharp.Compiler.Syntax.SynType+Paren: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynType+Paren: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynType+SignatureParameter: Boolean get_optional()
+FSharp.Compiler.Syntax.SynType+SignatureParameter: Boolean optional
+FSharp.Compiler.Syntax.SynType+SignatureParameter: FSharp.Compiler.Syntax.SynType get_usedType()
+FSharp.Compiler.Syntax.SynType+SignatureParameter: FSharp.Compiler.Syntax.SynType usedType
+FSharp.Compiler.Syntax.SynType+SignatureParameter: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynType+SignatureParameter: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynType+SignatureParameter: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] attributes
+FSharp.Compiler.Syntax.SynType+SignatureParameter: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] get_attributes()
+FSharp.Compiler.Syntax.SynType+SignatureParameter: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] get_id()
+FSharp.Compiler.Syntax.SynType+SignatureParameter: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] id
+FSharp.Compiler.Syntax.SynType+StaticConstant: FSharp.Compiler.Syntax.SynConst constant
+FSharp.Compiler.Syntax.SynType+StaticConstant: FSharp.Compiler.Syntax.SynConst get_constant()
+FSharp.Compiler.Syntax.SynType+StaticConstant: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynType+StaticConstant: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynType+StaticConstantExpr: FSharp.Compiler.Syntax.SynExpr expr
+FSharp.Compiler.Syntax.SynType+StaticConstantExpr: FSharp.Compiler.Syntax.SynExpr get_expr()
+FSharp.Compiler.Syntax.SynType+StaticConstantExpr: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynType+StaticConstantExpr: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynType+StaticConstantNamed: FSharp.Compiler.Syntax.SynType get_ident()
+FSharp.Compiler.Syntax.SynType+StaticConstantNamed: FSharp.Compiler.Syntax.SynType get_value()
+FSharp.Compiler.Syntax.SynType+StaticConstantNamed: FSharp.Compiler.Syntax.SynType ident
+FSharp.Compiler.Syntax.SynType+StaticConstantNamed: FSharp.Compiler.Syntax.SynType value
+FSharp.Compiler.Syntax.SynType+StaticConstantNamed: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynType+StaticConstantNamed: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynType+Tags: Int32 Anon
+FSharp.Compiler.Syntax.SynType+Tags: Int32 AnonRecd
+FSharp.Compiler.Syntax.SynType+Tags: Int32 App
+FSharp.Compiler.Syntax.SynType+Tags: Int32 Array
+FSharp.Compiler.Syntax.SynType+Tags: Int32 Fun
+FSharp.Compiler.Syntax.SynType+Tags: Int32 HashConstraint
+FSharp.Compiler.Syntax.SynType+Tags: Int32 LongIdent
+FSharp.Compiler.Syntax.SynType+Tags: Int32 LongIdentApp
+FSharp.Compiler.Syntax.SynType+Tags: Int32 MeasurePower
+FSharp.Compiler.Syntax.SynType+Tags: Int32 Or
+FSharp.Compiler.Syntax.SynType+Tags: Int32 Paren
+FSharp.Compiler.Syntax.SynType+Tags: Int32 SignatureParameter
+FSharp.Compiler.Syntax.SynType+Tags: Int32 StaticConstant
+FSharp.Compiler.Syntax.SynType+Tags: Int32 StaticConstantExpr
+FSharp.Compiler.Syntax.SynType+Tags: Int32 StaticConstantNamed
+FSharp.Compiler.Syntax.SynType+Tags: Int32 Tuple
+FSharp.Compiler.Syntax.SynType+Tags: Int32 Var
+FSharp.Compiler.Syntax.SynType+Tags: Int32 WithGlobalConstraints
+FSharp.Compiler.Syntax.SynType+Tuple: Boolean get_isStruct()
+FSharp.Compiler.Syntax.SynType+Tuple: Boolean isStruct
+FSharp.Compiler.Syntax.SynType+Tuple: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynType+Tuple: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynType+Tuple: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTupleTypeSegment] get_path()
+FSharp.Compiler.Syntax.SynType+Tuple: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTupleTypeSegment] path
+FSharp.Compiler.Syntax.SynType+Var: FSharp.Compiler.Syntax.SynTypar get_typar()
+FSharp.Compiler.Syntax.SynType+Var: FSharp.Compiler.Syntax.SynTypar typar
+FSharp.Compiler.Syntax.SynType+Var: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynType+Var: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynType+WithGlobalConstraints: FSharp.Compiler.Syntax.SynType get_typeName()
+FSharp.Compiler.Syntax.SynType+WithGlobalConstraints: FSharp.Compiler.Syntax.SynType typeName
+FSharp.Compiler.Syntax.SynType+WithGlobalConstraints: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynType+WithGlobalConstraints: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynType+WithGlobalConstraints: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTypeConstraint] constraints
+FSharp.Compiler.Syntax.SynType+WithGlobalConstraints: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTypeConstraint] get_constraints()
+FSharp.Compiler.Syntax.SynType: Boolean IsAnon
+FSharp.Compiler.Syntax.SynType: Boolean IsAnonRecd
+FSharp.Compiler.Syntax.SynType: Boolean IsApp
+FSharp.Compiler.Syntax.SynType: Boolean IsArray
+FSharp.Compiler.Syntax.SynType: Boolean IsFun
+FSharp.Compiler.Syntax.SynType: Boolean IsHashConstraint
+FSharp.Compiler.Syntax.SynType: Boolean IsLongIdent
+FSharp.Compiler.Syntax.SynType: Boolean IsLongIdentApp
+FSharp.Compiler.Syntax.SynType: Boolean IsMeasurePower
+FSharp.Compiler.Syntax.SynType: Boolean IsOr
+FSharp.Compiler.Syntax.SynType: Boolean IsParen
+FSharp.Compiler.Syntax.SynType: Boolean IsSignatureParameter
+FSharp.Compiler.Syntax.SynType: Boolean IsStaticConstant
+FSharp.Compiler.Syntax.SynType: Boolean IsStaticConstantExpr
+FSharp.Compiler.Syntax.SynType: Boolean IsStaticConstantNamed
+FSharp.Compiler.Syntax.SynType: Boolean IsTuple
+FSharp.Compiler.Syntax.SynType: Boolean IsVar
+FSharp.Compiler.Syntax.SynType: Boolean IsWithGlobalConstraints
+FSharp.Compiler.Syntax.SynType: Boolean get_IsAnon()
+FSharp.Compiler.Syntax.SynType: Boolean get_IsAnonRecd()
+FSharp.Compiler.Syntax.SynType: Boolean get_IsApp()
+FSharp.Compiler.Syntax.SynType: Boolean get_IsArray()
+FSharp.Compiler.Syntax.SynType: Boolean get_IsFun()
+FSharp.Compiler.Syntax.SynType: Boolean get_IsHashConstraint()
+FSharp.Compiler.Syntax.SynType: Boolean get_IsLongIdent()
+FSharp.Compiler.Syntax.SynType: Boolean get_IsLongIdentApp()
+FSharp.Compiler.Syntax.SynType: Boolean get_IsMeasurePower()
+FSharp.Compiler.Syntax.SynType: Boolean get_IsOr()
+FSharp.Compiler.Syntax.SynType: Boolean get_IsParen()
+FSharp.Compiler.Syntax.SynType: Boolean get_IsSignatureParameter()
+FSharp.Compiler.Syntax.SynType: Boolean get_IsStaticConstant()
+FSharp.Compiler.Syntax.SynType: Boolean get_IsStaticConstantExpr()
+FSharp.Compiler.Syntax.SynType: Boolean get_IsStaticConstantNamed()
+FSharp.Compiler.Syntax.SynType: Boolean get_IsTuple()
+FSharp.Compiler.Syntax.SynType: Boolean get_IsVar()
+FSharp.Compiler.Syntax.SynType: Boolean get_IsWithGlobalConstraints()
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewAnon(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewAnonRecd(Boolean, Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[FSharp.Compiler.Syntax.Ident,FSharp.Compiler.Syntax.SynType]], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewApp(FSharp.Compiler.Syntax.SynType, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynType], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Boolean, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewArray(Int32, FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewFun(FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynTypeFunTrivia)
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewHashConstraint(FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewLongIdent(FSharp.Compiler.Syntax.SynLongIdent)
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewLongIdentApp(FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Syntax.SynLongIdent, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynType], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewMeasurePower(FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Syntax.SynRationalConst, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewOr(FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynTypeOrTrivia)
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewParen(FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewSignatureParameter(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], Boolean, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident], FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewStaticConstant(FSharp.Compiler.Syntax.SynConst, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewStaticConstantExpr(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewStaticConstantNamed(FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewTuple(Boolean, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTupleTypeSegment], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewVar(FSharp.Compiler.Syntax.SynTypar, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewWithGlobalConstraints(FSharp.Compiler.Syntax.SynType, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTypeConstraint], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType+Anon
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType+AnonRecd
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType+App
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType+Array
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType+Fun
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType+HashConstraint
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType+LongIdent
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType+LongIdentApp
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType+MeasurePower
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType+Or
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType+Paren
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType+SignatureParameter
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType+StaticConstant
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType+StaticConstantExpr
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType+StaticConstantNamed
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType+Tags
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType+Tuple
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType+Var
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType+WithGlobalConstraints
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynType: Int32 Tag
+FSharp.Compiler.Syntax.SynType: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynType: System.String ToString()
+FSharp.Compiler.Syntax.SynTypeConstraint+Tags: Int32 WhereSelfConstrained
+FSharp.Compiler.Syntax.SynTypeConstraint+Tags: Int32 WhereTyparDefaultsToType
+FSharp.Compiler.Syntax.SynTypeConstraint+Tags: Int32 WhereTyparIsComparable
+FSharp.Compiler.Syntax.SynTypeConstraint+Tags: Int32 WhereTyparIsDelegate
+FSharp.Compiler.Syntax.SynTypeConstraint+Tags: Int32 WhereTyparIsEnum
+FSharp.Compiler.Syntax.SynTypeConstraint+Tags: Int32 WhereTyparIsEquatable
+FSharp.Compiler.Syntax.SynTypeConstraint+Tags: Int32 WhereTyparIsReferenceType
+FSharp.Compiler.Syntax.SynTypeConstraint+Tags: Int32 WhereTyparIsUnmanaged
+FSharp.Compiler.Syntax.SynTypeConstraint+Tags: Int32 WhereTyparIsValueType
+FSharp.Compiler.Syntax.SynTypeConstraint+Tags: Int32 WhereTyparSubtypeOfType
+FSharp.Compiler.Syntax.SynTypeConstraint+Tags: Int32 WhereTyparSupportsMember
+FSharp.Compiler.Syntax.SynTypeConstraint+Tags: Int32 WhereTyparSupportsNull
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereSelfConstrained: FSharp.Compiler.Syntax.SynType get_selfConstraint()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereSelfConstrained: FSharp.Compiler.Syntax.SynType selfConstraint
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereSelfConstrained: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereSelfConstrained: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparDefaultsToType: FSharp.Compiler.Syntax.SynTypar get_typar()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparDefaultsToType: FSharp.Compiler.Syntax.SynTypar typar
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparDefaultsToType: FSharp.Compiler.Syntax.SynType get_typeName()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparDefaultsToType: FSharp.Compiler.Syntax.SynType typeName
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparDefaultsToType: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparDefaultsToType: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsComparable: FSharp.Compiler.Syntax.SynTypar get_typar()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsComparable: FSharp.Compiler.Syntax.SynTypar typar
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsComparable: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsComparable: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsDelegate: FSharp.Compiler.Syntax.SynTypar get_typar()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsDelegate: FSharp.Compiler.Syntax.SynTypar typar
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsDelegate: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsDelegate: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsDelegate: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynType] get_typeArgs()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsDelegate: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynType] typeArgs
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsEnum: FSharp.Compiler.Syntax.SynTypar get_typar()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsEnum: FSharp.Compiler.Syntax.SynTypar typar
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsEnum: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsEnum: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsEnum: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynType] get_typeArgs()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsEnum: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynType] typeArgs
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsEquatable: FSharp.Compiler.Syntax.SynTypar get_typar()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsEquatable: FSharp.Compiler.Syntax.SynTypar typar
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsEquatable: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsEquatable: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsReferenceType: FSharp.Compiler.Syntax.SynTypar get_typar()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsReferenceType: FSharp.Compiler.Syntax.SynTypar typar
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsReferenceType: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsReferenceType: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsUnmanaged: FSharp.Compiler.Syntax.SynTypar get_typar()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsUnmanaged: FSharp.Compiler.Syntax.SynTypar typar
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsUnmanaged: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsUnmanaged: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsValueType: FSharp.Compiler.Syntax.SynTypar get_typar()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsValueType: FSharp.Compiler.Syntax.SynTypar typar
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsValueType: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsValueType: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparSubtypeOfType: FSharp.Compiler.Syntax.SynTypar get_typar()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparSubtypeOfType: FSharp.Compiler.Syntax.SynTypar typar
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparSubtypeOfType: FSharp.Compiler.Syntax.SynType get_typeName()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparSubtypeOfType: FSharp.Compiler.Syntax.SynType typeName
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparSubtypeOfType: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparSubtypeOfType: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparSupportsMember: FSharp.Compiler.Syntax.SynMemberSig get_memberSig()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparSupportsMember: FSharp.Compiler.Syntax.SynMemberSig memberSig
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparSupportsMember: FSharp.Compiler.Syntax.SynType get_typars()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparSupportsMember: FSharp.Compiler.Syntax.SynType typars
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparSupportsMember: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparSupportsMember: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparSupportsNull: FSharp.Compiler.Syntax.SynTypar get_typar()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparSupportsNull: FSharp.Compiler.Syntax.SynTypar typar
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparSupportsNull: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparSupportsNull: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTypeConstraint: Boolean IsWhereSelfConstrained
+FSharp.Compiler.Syntax.SynTypeConstraint: Boolean IsWhereTyparDefaultsToType
+FSharp.Compiler.Syntax.SynTypeConstraint: Boolean IsWhereTyparIsComparable
+FSharp.Compiler.Syntax.SynTypeConstraint: Boolean IsWhereTyparIsDelegate
+FSharp.Compiler.Syntax.SynTypeConstraint: Boolean IsWhereTyparIsEnum
+FSharp.Compiler.Syntax.SynTypeConstraint: Boolean IsWhereTyparIsEquatable
+FSharp.Compiler.Syntax.SynTypeConstraint: Boolean IsWhereTyparIsReferenceType
+FSharp.Compiler.Syntax.SynTypeConstraint: Boolean IsWhereTyparIsUnmanaged
+FSharp.Compiler.Syntax.SynTypeConstraint: Boolean IsWhereTyparIsValueType
+FSharp.Compiler.Syntax.SynTypeConstraint: Boolean IsWhereTyparSubtypeOfType
+FSharp.Compiler.Syntax.SynTypeConstraint: Boolean IsWhereTyparSupportsMember
+FSharp.Compiler.Syntax.SynTypeConstraint: Boolean IsWhereTyparSupportsNull
+FSharp.Compiler.Syntax.SynTypeConstraint: Boolean get_IsWhereSelfConstrained()
+FSharp.Compiler.Syntax.SynTypeConstraint: Boolean get_IsWhereTyparDefaultsToType()
+FSharp.Compiler.Syntax.SynTypeConstraint: Boolean get_IsWhereTyparIsComparable()
+FSharp.Compiler.Syntax.SynTypeConstraint: Boolean get_IsWhereTyparIsDelegate()
+FSharp.Compiler.Syntax.SynTypeConstraint: Boolean get_IsWhereTyparIsEnum()
+FSharp.Compiler.Syntax.SynTypeConstraint: Boolean get_IsWhereTyparIsEquatable()
+FSharp.Compiler.Syntax.SynTypeConstraint: Boolean get_IsWhereTyparIsReferenceType()
+FSharp.Compiler.Syntax.SynTypeConstraint: Boolean get_IsWhereTyparIsUnmanaged()
+FSharp.Compiler.Syntax.SynTypeConstraint: Boolean get_IsWhereTyparIsValueType()
+FSharp.Compiler.Syntax.SynTypeConstraint: Boolean get_IsWhereTyparSubtypeOfType()
+FSharp.Compiler.Syntax.SynTypeConstraint: Boolean get_IsWhereTyparSupportsMember()
+FSharp.Compiler.Syntax.SynTypeConstraint: Boolean get_IsWhereTyparSupportsNull()
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Syntax.SynTypeConstraint NewWhereSelfConstrained(FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Syntax.SynTypeConstraint NewWhereTyparDefaultsToType(FSharp.Compiler.Syntax.SynTypar, FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Syntax.SynTypeConstraint NewWhereTyparIsComparable(FSharp.Compiler.Syntax.SynTypar, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Syntax.SynTypeConstraint NewWhereTyparIsDelegate(FSharp.Compiler.Syntax.SynTypar, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynType], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Syntax.SynTypeConstraint NewWhereTyparIsEnum(FSharp.Compiler.Syntax.SynTypar, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynType], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Syntax.SynTypeConstraint NewWhereTyparIsEquatable(FSharp.Compiler.Syntax.SynTypar, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Syntax.SynTypeConstraint NewWhereTyparIsReferenceType(FSharp.Compiler.Syntax.SynTypar, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Syntax.SynTypeConstraint NewWhereTyparIsUnmanaged(FSharp.Compiler.Syntax.SynTypar, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Syntax.SynTypeConstraint NewWhereTyparIsValueType(FSharp.Compiler.Syntax.SynTypar, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Syntax.SynTypeConstraint NewWhereTyparSubtypeOfType(FSharp.Compiler.Syntax.SynTypar, FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Syntax.SynTypeConstraint NewWhereTyparSupportsMember(FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Syntax.SynMemberSig, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Syntax.SynTypeConstraint NewWhereTyparSupportsNull(FSharp.Compiler.Syntax.SynTypar, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Syntax.SynTypeConstraint+Tags
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Syntax.SynTypeConstraint+WhereSelfConstrained
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparDefaultsToType
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsComparable
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsDelegate
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsEnum
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsEquatable
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsReferenceType
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsUnmanaged
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparIsValueType
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparSubtypeOfType
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparSupportsMember
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Syntax.SynTypeConstraint+WhereTyparSupportsNull
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynTypeConstraint: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynTypeConstraint: Int32 Tag
+FSharp.Compiler.Syntax.SynTypeConstraint: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynTypeConstraint: System.String ToString()
+FSharp.Compiler.Syntax.SynTypeDefn: FSharp.Compiler.Syntax.SynComponentInfo get_typeInfo()
+FSharp.Compiler.Syntax.SynTypeDefn: FSharp.Compiler.Syntax.SynComponentInfo typeInfo
+FSharp.Compiler.Syntax.SynTypeDefn: FSharp.Compiler.Syntax.SynTypeDefn NewSynTypeDefn(FSharp.Compiler.Syntax.SynComponentInfo, FSharp.Compiler.Syntax.SynTypeDefnRepr, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynMemberDefn], FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynTypeDefnTrivia)
+FSharp.Compiler.Syntax.SynTypeDefn: FSharp.Compiler.Syntax.SynTypeDefnRepr get_typeRepr()
+FSharp.Compiler.Syntax.SynTypeDefn: FSharp.Compiler.Syntax.SynTypeDefnRepr typeRepr
+FSharp.Compiler.Syntax.SynTypeDefn: FSharp.Compiler.SyntaxTrivia.SynTypeDefnTrivia get_trivia()
+FSharp.Compiler.Syntax.SynTypeDefn: FSharp.Compiler.SyntaxTrivia.SynTypeDefnTrivia trivia
+FSharp.Compiler.Syntax.SynTypeDefn: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynTypeDefn: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynTypeDefn: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTypeDefn: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTypeDefn: Int32 Tag
+FSharp.Compiler.Syntax.SynTypeDefn: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynTypeDefn: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn] get_members()
+FSharp.Compiler.Syntax.SynTypeDefn: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn] members
+FSharp.Compiler.Syntax.SynTypeDefn: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynMemberDefn] get_implicitConstructor()
+FSharp.Compiler.Syntax.SynTypeDefn: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynMemberDefn] implicitConstructor
+FSharp.Compiler.Syntax.SynTypeDefn: System.String ToString()
+FSharp.Compiler.Syntax.SynTypeDefnKind+Augmentation: FSharp.Compiler.Text.Range get_withKeyword()
+FSharp.Compiler.Syntax.SynTypeDefnKind+Augmentation: FSharp.Compiler.Text.Range withKeyword
+FSharp.Compiler.Syntax.SynTypeDefnKind+Delegate: FSharp.Compiler.Syntax.SynType get_signature()
+FSharp.Compiler.Syntax.SynTypeDefnKind+Delegate: FSharp.Compiler.Syntax.SynType signature
+FSharp.Compiler.Syntax.SynTypeDefnKind+Delegate: FSharp.Compiler.Syntax.SynValInfo get_signatureInfo()
+FSharp.Compiler.Syntax.SynTypeDefnKind+Delegate: FSharp.Compiler.Syntax.SynValInfo signatureInfo
+FSharp.Compiler.Syntax.SynTypeDefnKind+Tags: Int32 Abbrev
+FSharp.Compiler.Syntax.SynTypeDefnKind+Tags: Int32 Augmentation
+FSharp.Compiler.Syntax.SynTypeDefnKind+Tags: Int32 Class
+FSharp.Compiler.Syntax.SynTypeDefnKind+Tags: Int32 Delegate
+FSharp.Compiler.Syntax.SynTypeDefnKind+Tags: Int32 IL
+FSharp.Compiler.Syntax.SynTypeDefnKind+Tags: Int32 Interface
+FSharp.Compiler.Syntax.SynTypeDefnKind+Tags: Int32 Opaque
+FSharp.Compiler.Syntax.SynTypeDefnKind+Tags: Int32 Record
+FSharp.Compiler.Syntax.SynTypeDefnKind+Tags: Int32 Struct
+FSharp.Compiler.Syntax.SynTypeDefnKind+Tags: Int32 Union
+FSharp.Compiler.Syntax.SynTypeDefnKind+Tags: Int32 Unspecified
+FSharp.Compiler.Syntax.SynTypeDefnKind: Boolean IsAbbrev
+FSharp.Compiler.Syntax.SynTypeDefnKind: Boolean IsAugmentation
+FSharp.Compiler.Syntax.SynTypeDefnKind: Boolean IsClass
+FSharp.Compiler.Syntax.SynTypeDefnKind: Boolean IsDelegate
+FSharp.Compiler.Syntax.SynTypeDefnKind: Boolean IsIL
+FSharp.Compiler.Syntax.SynTypeDefnKind: Boolean IsInterface
+FSharp.Compiler.Syntax.SynTypeDefnKind: Boolean IsOpaque
+FSharp.Compiler.Syntax.SynTypeDefnKind: Boolean IsRecord
+FSharp.Compiler.Syntax.SynTypeDefnKind: Boolean IsStruct
+FSharp.Compiler.Syntax.SynTypeDefnKind: Boolean IsUnion
+FSharp.Compiler.Syntax.SynTypeDefnKind: Boolean IsUnspecified
+FSharp.Compiler.Syntax.SynTypeDefnKind: Boolean get_IsAbbrev()
+FSharp.Compiler.Syntax.SynTypeDefnKind: Boolean get_IsAugmentation()
+FSharp.Compiler.Syntax.SynTypeDefnKind: Boolean get_IsClass()
+FSharp.Compiler.Syntax.SynTypeDefnKind: Boolean get_IsDelegate()
+FSharp.Compiler.Syntax.SynTypeDefnKind: Boolean get_IsIL()
+FSharp.Compiler.Syntax.SynTypeDefnKind: Boolean get_IsInterface()
+FSharp.Compiler.Syntax.SynTypeDefnKind: Boolean get_IsOpaque()
+FSharp.Compiler.Syntax.SynTypeDefnKind: Boolean get_IsRecord()
+FSharp.Compiler.Syntax.SynTypeDefnKind: Boolean get_IsStruct()
+FSharp.Compiler.Syntax.SynTypeDefnKind: Boolean get_IsUnion()
+FSharp.Compiler.Syntax.SynTypeDefnKind: Boolean get_IsUnspecified()
+FSharp.Compiler.Syntax.SynTypeDefnKind: FSharp.Compiler.Syntax.SynTypeDefnKind Abbrev
+FSharp.Compiler.Syntax.SynTypeDefnKind: FSharp.Compiler.Syntax.SynTypeDefnKind Class
+FSharp.Compiler.Syntax.SynTypeDefnKind: FSharp.Compiler.Syntax.SynTypeDefnKind IL
+FSharp.Compiler.Syntax.SynTypeDefnKind: FSharp.Compiler.Syntax.SynTypeDefnKind Interface
+FSharp.Compiler.Syntax.SynTypeDefnKind: FSharp.Compiler.Syntax.SynTypeDefnKind NewAugmentation(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTypeDefnKind: FSharp.Compiler.Syntax.SynTypeDefnKind NewDelegate(FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Syntax.SynValInfo)
+FSharp.Compiler.Syntax.SynTypeDefnKind: FSharp.Compiler.Syntax.SynTypeDefnKind Opaque
+FSharp.Compiler.Syntax.SynTypeDefnKind: FSharp.Compiler.Syntax.SynTypeDefnKind Record
+FSharp.Compiler.Syntax.SynTypeDefnKind: FSharp.Compiler.Syntax.SynTypeDefnKind Struct
+FSharp.Compiler.Syntax.SynTypeDefnKind: FSharp.Compiler.Syntax.SynTypeDefnKind Union
+FSharp.Compiler.Syntax.SynTypeDefnKind: FSharp.Compiler.Syntax.SynTypeDefnKind Unspecified
+FSharp.Compiler.Syntax.SynTypeDefnKind: FSharp.Compiler.Syntax.SynTypeDefnKind get_Abbrev()
+FSharp.Compiler.Syntax.SynTypeDefnKind: FSharp.Compiler.Syntax.SynTypeDefnKind get_Class()
+FSharp.Compiler.Syntax.SynTypeDefnKind: FSharp.Compiler.Syntax.SynTypeDefnKind get_IL()
+FSharp.Compiler.Syntax.SynTypeDefnKind: FSharp.Compiler.Syntax.SynTypeDefnKind get_Interface()
+FSharp.Compiler.Syntax.SynTypeDefnKind: FSharp.Compiler.Syntax.SynTypeDefnKind get_Opaque()
+FSharp.Compiler.Syntax.SynTypeDefnKind: FSharp.Compiler.Syntax.SynTypeDefnKind get_Record()
+FSharp.Compiler.Syntax.SynTypeDefnKind: FSharp.Compiler.Syntax.SynTypeDefnKind get_Struct()
+FSharp.Compiler.Syntax.SynTypeDefnKind: FSharp.Compiler.Syntax.SynTypeDefnKind get_Union()
+FSharp.Compiler.Syntax.SynTypeDefnKind: FSharp.Compiler.Syntax.SynTypeDefnKind get_Unspecified()
+FSharp.Compiler.Syntax.SynTypeDefnKind: FSharp.Compiler.Syntax.SynTypeDefnKind+Augmentation
+FSharp.Compiler.Syntax.SynTypeDefnKind: FSharp.Compiler.Syntax.SynTypeDefnKind+Delegate
+FSharp.Compiler.Syntax.SynTypeDefnKind: FSharp.Compiler.Syntax.SynTypeDefnKind+Tags
+FSharp.Compiler.Syntax.SynTypeDefnKind: Int32 Tag
+FSharp.Compiler.Syntax.SynTypeDefnKind: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynTypeDefnKind: System.String ToString()
+FSharp.Compiler.Syntax.SynTypeDefnRepr+Exception: FSharp.Compiler.Syntax.SynExceptionDefnRepr exnRepr
+FSharp.Compiler.Syntax.SynTypeDefnRepr+Exception: FSharp.Compiler.Syntax.SynExceptionDefnRepr get_exnRepr()
+FSharp.Compiler.Syntax.SynTypeDefnRepr+ObjectModel: FSharp.Compiler.Syntax.SynTypeDefnKind get_kind()
+FSharp.Compiler.Syntax.SynTypeDefnRepr+ObjectModel: FSharp.Compiler.Syntax.SynTypeDefnKind kind
+FSharp.Compiler.Syntax.SynTypeDefnRepr+ObjectModel: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTypeDefnRepr+ObjectModel: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTypeDefnRepr+ObjectModel: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn] get_members()
+FSharp.Compiler.Syntax.SynTypeDefnRepr+ObjectModel: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn] members
+FSharp.Compiler.Syntax.SynTypeDefnRepr+Simple: FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr get_simpleRepr()
+FSharp.Compiler.Syntax.SynTypeDefnRepr+Simple: FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr simpleRepr
+FSharp.Compiler.Syntax.SynTypeDefnRepr+Simple: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTypeDefnRepr+Simple: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTypeDefnRepr+Tags: Int32 Exception
+FSharp.Compiler.Syntax.SynTypeDefnRepr+Tags: Int32 ObjectModel
+FSharp.Compiler.Syntax.SynTypeDefnRepr+Tags: Int32 Simple
+FSharp.Compiler.Syntax.SynTypeDefnRepr: Boolean IsException
+FSharp.Compiler.Syntax.SynTypeDefnRepr: Boolean IsObjectModel
+FSharp.Compiler.Syntax.SynTypeDefnRepr: Boolean IsSimple
+FSharp.Compiler.Syntax.SynTypeDefnRepr: Boolean get_IsException()
+FSharp.Compiler.Syntax.SynTypeDefnRepr: Boolean get_IsObjectModel()
+FSharp.Compiler.Syntax.SynTypeDefnRepr: Boolean get_IsSimple()
+FSharp.Compiler.Syntax.SynTypeDefnRepr: FSharp.Compiler.Syntax.SynTypeDefnRepr NewException(FSharp.Compiler.Syntax.SynExceptionDefnRepr)
+FSharp.Compiler.Syntax.SynTypeDefnRepr: FSharp.Compiler.Syntax.SynTypeDefnRepr NewObjectModel(FSharp.Compiler.Syntax.SynTypeDefnKind, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTypeDefnRepr: FSharp.Compiler.Syntax.SynTypeDefnRepr NewSimple(FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTypeDefnRepr: FSharp.Compiler.Syntax.SynTypeDefnRepr+Exception
+FSharp.Compiler.Syntax.SynTypeDefnRepr: FSharp.Compiler.Syntax.SynTypeDefnRepr+ObjectModel
+FSharp.Compiler.Syntax.SynTypeDefnRepr: FSharp.Compiler.Syntax.SynTypeDefnRepr+Simple
+FSharp.Compiler.Syntax.SynTypeDefnRepr: FSharp.Compiler.Syntax.SynTypeDefnRepr+Tags
+FSharp.Compiler.Syntax.SynTypeDefnRepr: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynTypeDefnRepr: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynTypeDefnRepr: Int32 Tag
+FSharp.Compiler.Syntax.SynTypeDefnRepr: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynTypeDefnRepr: System.String ToString()
+FSharp.Compiler.Syntax.SynTypeDefnSig: FSharp.Compiler.Syntax.SynComponentInfo get_typeInfo()
+FSharp.Compiler.Syntax.SynTypeDefnSig: FSharp.Compiler.Syntax.SynComponentInfo typeInfo
+FSharp.Compiler.Syntax.SynTypeDefnSig: FSharp.Compiler.Syntax.SynTypeDefnSig NewSynTypeDefnSig(FSharp.Compiler.Syntax.SynComponentInfo, FSharp.Compiler.Syntax.SynTypeDefnSigRepr, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberSig], FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynTypeDefnSigTrivia)
+FSharp.Compiler.Syntax.SynTypeDefnSig: FSharp.Compiler.Syntax.SynTypeDefnSigRepr get_typeRepr()
+FSharp.Compiler.Syntax.SynTypeDefnSig: FSharp.Compiler.Syntax.SynTypeDefnSigRepr typeRepr
+FSharp.Compiler.Syntax.SynTypeDefnSig: FSharp.Compiler.SyntaxTrivia.SynTypeDefnSigTrivia get_trivia()
+FSharp.Compiler.Syntax.SynTypeDefnSig: FSharp.Compiler.SyntaxTrivia.SynTypeDefnSigTrivia trivia
+FSharp.Compiler.Syntax.SynTypeDefnSig: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynTypeDefnSig: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynTypeDefnSig: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTypeDefnSig: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTypeDefnSig: Int32 Tag
+FSharp.Compiler.Syntax.SynTypeDefnSig: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynTypeDefnSig: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberSig] get_members()
+FSharp.Compiler.Syntax.SynTypeDefnSig: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberSig] members
+FSharp.Compiler.Syntax.SynTypeDefnSig: System.String ToString()
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr+Exception: FSharp.Compiler.Syntax.SynExceptionDefnRepr get_repr()
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr+Exception: FSharp.Compiler.Syntax.SynExceptionDefnRepr repr
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr+ObjectModel: FSharp.Compiler.Syntax.SynTypeDefnKind get_kind()
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr+ObjectModel: FSharp.Compiler.Syntax.SynTypeDefnKind kind
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr+ObjectModel: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr+ObjectModel: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr+ObjectModel: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberSig] get_memberSigs()
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr+ObjectModel: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberSig] memberSigs
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr+Simple: FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr get_repr()
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr+Simple: FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr repr
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr+Simple: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr+Simple: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr+Tags: Int32 Exception
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr+Tags: Int32 ObjectModel
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr+Tags: Int32 Simple
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr: Boolean IsException
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr: Boolean IsObjectModel
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr: Boolean IsSimple
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr: Boolean get_IsException()
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr: Boolean get_IsObjectModel()
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr: Boolean get_IsSimple()
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr: FSharp.Compiler.Syntax.SynTypeDefnSigRepr NewException(FSharp.Compiler.Syntax.SynExceptionDefnRepr)
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr: FSharp.Compiler.Syntax.SynTypeDefnSigRepr NewObjectModel(FSharp.Compiler.Syntax.SynTypeDefnKind, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberSig], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr: FSharp.Compiler.Syntax.SynTypeDefnSigRepr NewSimple(FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr: FSharp.Compiler.Syntax.SynTypeDefnSigRepr+Exception
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr: FSharp.Compiler.Syntax.SynTypeDefnSigRepr+ObjectModel
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr: FSharp.Compiler.Syntax.SynTypeDefnSigRepr+Simple
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr: FSharp.Compiler.Syntax.SynTypeDefnSigRepr+Tags
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr: Int32 Tag
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynTypeDefnSigRepr: System.String ToString()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Enum: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Enum: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Enum: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynEnumCase] cases
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Enum: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynEnumCase] get_cases()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Exception: FSharp.Compiler.Syntax.SynExceptionDefnRepr exnRepr
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Exception: FSharp.Compiler.Syntax.SynExceptionDefnRepr get_exnRepr()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+General: Boolean get_isConcrete()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+General: Boolean get_isIncrClass()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+General: Boolean isConcrete
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+General: Boolean isIncrClass
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+General: FSharp.Compiler.Syntax.SynTypeDefnKind get_kind()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+General: FSharp.Compiler.Syntax.SynTypeDefnKind kind
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+General: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+General: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+General: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynField] fields
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+General: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynField] get_fields()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+General: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[FSharp.Compiler.Syntax.SynValSig,FSharp.Compiler.Syntax.SynMemberFlags]] get_slotsigs()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+General: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[FSharp.Compiler.Syntax.SynValSig,FSharp.Compiler.Syntax.SynMemberFlags]] slotsigs
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+General: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[FSharp.Compiler.Syntax.SynType,FSharp.Compiler.Text.Range,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident]]] get_inherits()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+General: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[FSharp.Compiler.Syntax.SynType,FSharp.Compiler.Text.Range,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident]]] inherits
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+General: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynSimplePats] get_implicitCtorSynPats()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+General: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynSimplePats] implicitCtorSynPats
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+LibraryOnlyILAssembly: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+LibraryOnlyILAssembly: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+LibraryOnlyILAssembly: System.Object get_ilType()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+LibraryOnlyILAssembly: System.Object ilType
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+None: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+None: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Record: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Record: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Record: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynField] get_recordFields()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Record: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynField] recordFields
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Record: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] accessibility
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Record: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] get_accessibility()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Tags: Int32 Enum
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Tags: Int32 Exception
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Tags: Int32 General
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Tags: Int32 LibraryOnlyILAssembly
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Tags: Int32 None
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Tags: Int32 Record
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Tags: Int32 TypeAbbrev
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Tags: Int32 Union
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+TypeAbbrev: FSharp.Compiler.Syntax.ParserDetail detail
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+TypeAbbrev: FSharp.Compiler.Syntax.ParserDetail get_detail()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+TypeAbbrev: FSharp.Compiler.Syntax.SynType get_rhsType()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+TypeAbbrev: FSharp.Compiler.Syntax.SynType rhsType
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+TypeAbbrev: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+TypeAbbrev: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Union: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Union: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Union: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynUnionCase] get_unionCases()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Union: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynUnionCase] unionCases
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Union: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] accessibility
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Union: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] get_accessibility()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: Boolean IsEnum
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: Boolean IsException
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: Boolean IsGeneral
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: Boolean IsLibraryOnlyILAssembly
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: Boolean IsNone
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: Boolean IsRecord
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: Boolean IsTypeAbbrev
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: Boolean IsUnion
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: Boolean get_IsEnum()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: Boolean get_IsException()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: Boolean get_IsGeneral()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: Boolean get_IsLibraryOnlyILAssembly()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: Boolean get_IsNone()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: Boolean get_IsRecord()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: Boolean get_IsTypeAbbrev()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: Boolean get_IsUnion()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr NewEnum(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynEnumCase], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr NewException(FSharp.Compiler.Syntax.SynExceptionDefnRepr)
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr NewGeneral(FSharp.Compiler.Syntax.SynTypeDefnKind, Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[FSharp.Compiler.Syntax.SynType,FSharp.Compiler.Text.Range,Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident]]], Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[FSharp.Compiler.Syntax.SynValSig,FSharp.Compiler.Syntax.SynMemberFlags]], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynField], Boolean, Boolean, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynSimplePats], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr NewLibraryOnlyILAssembly(System.Object, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr NewNone(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr NewRecord(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynField], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr NewTypeAbbrev(FSharp.Compiler.Syntax.ParserDetail, FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr NewUnion(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynUnionCase], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Enum
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Exception
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+General
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+LibraryOnlyILAssembly
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+None
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Record
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Tags
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+TypeAbbrev
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr+Union
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: Int32 Tag
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynTypeDefnSimpleRepr: System.String ToString()
+FSharp.Compiler.Syntax.SynUnionCase: FSharp.Compiler.Syntax.SynIdent get_ident()
+FSharp.Compiler.Syntax.SynUnionCase: FSharp.Compiler.Syntax.SynIdent ident
+FSharp.Compiler.Syntax.SynUnionCase: FSharp.Compiler.Syntax.SynUnionCase NewSynUnionCase(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], FSharp.Compiler.Syntax.SynIdent, FSharp.Compiler.Syntax.SynUnionCaseKind, FSharp.Compiler.Xml.PreXmlDoc, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess], FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynUnionCaseTrivia)
+FSharp.Compiler.Syntax.SynUnionCase: FSharp.Compiler.Syntax.SynUnionCaseKind caseType
+FSharp.Compiler.Syntax.SynUnionCase: FSharp.Compiler.Syntax.SynUnionCaseKind get_caseType()
+FSharp.Compiler.Syntax.SynUnionCase: FSharp.Compiler.SyntaxTrivia.SynUnionCaseTrivia get_trivia()
+FSharp.Compiler.Syntax.SynUnionCase: FSharp.Compiler.SyntaxTrivia.SynUnionCaseTrivia trivia
+FSharp.Compiler.Syntax.SynUnionCase: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Syntax.SynUnionCase: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Syntax.SynUnionCase: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynUnionCase: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynUnionCase: FSharp.Compiler.Xml.PreXmlDoc get_xmlDoc()
+FSharp.Compiler.Syntax.SynUnionCase: FSharp.Compiler.Xml.PreXmlDoc xmlDoc
+FSharp.Compiler.Syntax.SynUnionCase: Int32 Tag
+FSharp.Compiler.Syntax.SynUnionCase: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynUnionCase: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] attributes
+FSharp.Compiler.Syntax.SynUnionCase: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] get_attributes()
+FSharp.Compiler.Syntax.SynUnionCase: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] accessibility
+FSharp.Compiler.Syntax.SynUnionCase: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] get_accessibility()
+FSharp.Compiler.Syntax.SynUnionCase: System.String ToString()
+FSharp.Compiler.Syntax.SynUnionCaseKind+Fields: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynField] cases
+FSharp.Compiler.Syntax.SynUnionCaseKind+Fields: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynField] get_cases()
+FSharp.Compiler.Syntax.SynUnionCaseKind+FullType: FSharp.Compiler.Syntax.SynType fullType
+FSharp.Compiler.Syntax.SynUnionCaseKind+FullType: FSharp.Compiler.Syntax.SynType get_fullType()
+FSharp.Compiler.Syntax.SynUnionCaseKind+FullType: FSharp.Compiler.Syntax.SynValInfo fullTypeInfo
+FSharp.Compiler.Syntax.SynUnionCaseKind+FullType: FSharp.Compiler.Syntax.SynValInfo get_fullTypeInfo()
+FSharp.Compiler.Syntax.SynUnionCaseKind+Tags: Int32 Fields
+FSharp.Compiler.Syntax.SynUnionCaseKind+Tags: Int32 FullType
+FSharp.Compiler.Syntax.SynUnionCaseKind: Boolean IsFields
+FSharp.Compiler.Syntax.SynUnionCaseKind: Boolean IsFullType
+FSharp.Compiler.Syntax.SynUnionCaseKind: Boolean get_IsFields()
+FSharp.Compiler.Syntax.SynUnionCaseKind: Boolean get_IsFullType()
+FSharp.Compiler.Syntax.SynUnionCaseKind: FSharp.Compiler.Syntax.SynUnionCaseKind NewFields(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynField])
+FSharp.Compiler.Syntax.SynUnionCaseKind: FSharp.Compiler.Syntax.SynUnionCaseKind NewFullType(FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Syntax.SynValInfo)
+FSharp.Compiler.Syntax.SynUnionCaseKind: FSharp.Compiler.Syntax.SynUnionCaseKind+Fields
+FSharp.Compiler.Syntax.SynUnionCaseKind: FSharp.Compiler.Syntax.SynUnionCaseKind+FullType
+FSharp.Compiler.Syntax.SynUnionCaseKind: FSharp.Compiler.Syntax.SynUnionCaseKind+Tags
+FSharp.Compiler.Syntax.SynUnionCaseKind: Int32 Tag
+FSharp.Compiler.Syntax.SynUnionCaseKind: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynUnionCaseKind: System.String ToString()
+FSharp.Compiler.Syntax.SynValData: FSharp.Compiler.Syntax.SynValData NewSynValData(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynMemberFlags], FSharp.Compiler.Syntax.SynValInfo, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident])
+FSharp.Compiler.Syntax.SynValData: FSharp.Compiler.Syntax.SynValInfo SynValInfo
+FSharp.Compiler.Syntax.SynValData: FSharp.Compiler.Syntax.SynValInfo get_SynValInfo()
+FSharp.Compiler.Syntax.SynValData: FSharp.Compiler.Syntax.SynValInfo get_valInfo()
+FSharp.Compiler.Syntax.SynValData: FSharp.Compiler.Syntax.SynValInfo valInfo
+FSharp.Compiler.Syntax.SynValData: Int32 Tag
+FSharp.Compiler.Syntax.SynValData: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynValData: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] get_thisIdOpt()
+FSharp.Compiler.Syntax.SynValData: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.Ident] thisIdOpt
+FSharp.Compiler.Syntax.SynValData: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynMemberFlags] get_memberFlags()
+FSharp.Compiler.Syntax.SynValData: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynMemberFlags] memberFlags
+FSharp.Compiler.Syntax.SynValData: System.String ToString()
+FSharp.Compiler.Syntax.SynValInfo: FSharp.Compiler.Syntax.SynArgInfo get_returnInfo()
+FSharp.Compiler.Syntax.SynValInfo: FSharp.Compiler.Syntax.SynArgInfo returnInfo
+FSharp.Compiler.Syntax.SynValInfo: FSharp.Compiler.Syntax.SynValInfo NewSynValInfo(Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynArgInfo]], FSharp.Compiler.Syntax.SynArgInfo)
+FSharp.Compiler.Syntax.SynValInfo: Int32 Tag
+FSharp.Compiler.Syntax.SynValInfo: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynValInfo: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynArgInfo]] CurriedArgInfos
+FSharp.Compiler.Syntax.SynValInfo: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynArgInfo]] curriedArgInfos
+FSharp.Compiler.Syntax.SynValInfo: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynArgInfo]] get_CurriedArgInfos()
+FSharp.Compiler.Syntax.SynValInfo: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynArgInfo]] get_curriedArgInfos()
+FSharp.Compiler.Syntax.SynValInfo: Microsoft.FSharp.Collections.FSharpList`1[System.String] ArgNames
+FSharp.Compiler.Syntax.SynValInfo: Microsoft.FSharp.Collections.FSharpList`1[System.String] get_ArgNames()
+FSharp.Compiler.Syntax.SynValInfo: System.String ToString()
+FSharp.Compiler.Syntax.SynValSig: Boolean get_isInline()
+FSharp.Compiler.Syntax.SynValSig: Boolean get_isMutable()
+FSharp.Compiler.Syntax.SynValSig: Boolean isInline
+FSharp.Compiler.Syntax.SynValSig: Boolean isMutable
+FSharp.Compiler.Syntax.SynValSig: FSharp.Compiler.Syntax.SynIdent get_ident()
+FSharp.Compiler.Syntax.SynValSig: FSharp.Compiler.Syntax.SynIdent ident
+FSharp.Compiler.Syntax.SynValSig: FSharp.Compiler.Syntax.SynType SynType
+FSharp.Compiler.Syntax.SynValSig: FSharp.Compiler.Syntax.SynType get_SynType()
+FSharp.Compiler.Syntax.SynValSig: FSharp.Compiler.Syntax.SynType get_synType()
+FSharp.Compiler.Syntax.SynValSig: FSharp.Compiler.Syntax.SynType synType
+FSharp.Compiler.Syntax.SynValSig: FSharp.Compiler.Syntax.SynValInfo SynInfo
+FSharp.Compiler.Syntax.SynValSig: FSharp.Compiler.Syntax.SynValInfo arity
+FSharp.Compiler.Syntax.SynValSig: FSharp.Compiler.Syntax.SynValInfo get_SynInfo()
+FSharp.Compiler.Syntax.SynValSig: FSharp.Compiler.Syntax.SynValInfo get_arity()
+FSharp.Compiler.Syntax.SynValSig: FSharp.Compiler.Syntax.SynValSig NewSynValSig(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList], FSharp.Compiler.Syntax.SynIdent, FSharp.Compiler.Syntax.SynValTyparDecls, FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Syntax.SynValInfo, Boolean, Boolean, FSharp.Compiler.Xml.PreXmlDoc, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynExpr], FSharp.Compiler.Text.Range, FSharp.Compiler.SyntaxTrivia.SynValSigTrivia)
+FSharp.Compiler.Syntax.SynValSig: FSharp.Compiler.Syntax.SynValTyparDecls explicitTypeParams
+FSharp.Compiler.Syntax.SynValSig: FSharp.Compiler.Syntax.SynValTyparDecls get_explicitTypeParams()
+FSharp.Compiler.Syntax.SynValSig: FSharp.Compiler.SyntaxTrivia.SynValSigTrivia get_trivia()
+FSharp.Compiler.Syntax.SynValSig: FSharp.Compiler.SyntaxTrivia.SynValSigTrivia trivia
+FSharp.Compiler.Syntax.SynValSig: FSharp.Compiler.Text.Range RangeOfId
+FSharp.Compiler.Syntax.SynValSig: FSharp.Compiler.Text.Range get_RangeOfId()
+FSharp.Compiler.Syntax.SynValSig: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.Syntax.SynValSig: FSharp.Compiler.Text.Range range
+FSharp.Compiler.Syntax.SynValSig: FSharp.Compiler.Xml.PreXmlDoc get_xmlDoc()
+FSharp.Compiler.Syntax.SynValSig: FSharp.Compiler.Xml.PreXmlDoc xmlDoc
+FSharp.Compiler.Syntax.SynValSig: Int32 Tag
+FSharp.Compiler.Syntax.SynValSig: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynValSig: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] attributes
+FSharp.Compiler.Syntax.SynValSig: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynAttributeList] get_attributes()
+FSharp.Compiler.Syntax.SynValSig: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] accessibility
+FSharp.Compiler.Syntax.SynValSig: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynAccess] get_accessibility()
+FSharp.Compiler.Syntax.SynValSig: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynExpr] get_synExpr()
+FSharp.Compiler.Syntax.SynValSig: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynExpr] synExpr
+FSharp.Compiler.Syntax.SynValSig: System.String ToString()
+FSharp.Compiler.Syntax.SynValTyparDecls: Boolean canInfer
+FSharp.Compiler.Syntax.SynValTyparDecls: Boolean get_canInfer()
+FSharp.Compiler.Syntax.SynValTyparDecls: FSharp.Compiler.Syntax.SynValTyparDecls NewSynValTyparDecls(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynTyparDecls], Boolean)
+FSharp.Compiler.Syntax.SynValTyparDecls: Int32 Tag
+FSharp.Compiler.Syntax.SynValTyparDecls: Int32 get_Tag()
+FSharp.Compiler.Syntax.SynValTyparDecls: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynTyparDecls] get_typars()
+FSharp.Compiler.Syntax.SynValTyparDecls: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynTyparDecls] typars
+FSharp.Compiler.Syntax.SynValTyparDecls: System.String ToString()
+FSharp.Compiler.Syntax.SyntaxNode+SynBinding: FSharp.Compiler.Syntax.SynBinding Item
+FSharp.Compiler.Syntax.SyntaxNode+SynBinding: FSharp.Compiler.Syntax.SynBinding get_Item()
+FSharp.Compiler.Syntax.SyntaxNode+SynExpr: FSharp.Compiler.Syntax.SynExpr Item
+FSharp.Compiler.Syntax.SyntaxNode+SynExpr: FSharp.Compiler.Syntax.SynExpr get_Item()
+FSharp.Compiler.Syntax.SyntaxNode+SynMatchClause: FSharp.Compiler.Syntax.SynMatchClause Item
+FSharp.Compiler.Syntax.SyntaxNode+SynMatchClause: FSharp.Compiler.Syntax.SynMatchClause get_Item()
+FSharp.Compiler.Syntax.SyntaxNode+SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn Item
+FSharp.Compiler.Syntax.SyntaxNode+SynMemberDefn: FSharp.Compiler.Syntax.SynMemberDefn get_Item()
+FSharp.Compiler.Syntax.SyntaxNode+SynModule: FSharp.Compiler.Syntax.SynModuleDecl Item
+FSharp.Compiler.Syntax.SyntaxNode+SynModule: FSharp.Compiler.Syntax.SynModuleDecl get_Item()
+FSharp.Compiler.Syntax.SyntaxNode+SynModuleOrNamespace: FSharp.Compiler.Syntax.SynModuleOrNamespace Item
+FSharp.Compiler.Syntax.SyntaxNode+SynModuleOrNamespace: FSharp.Compiler.Syntax.SynModuleOrNamespace get_Item()
+FSharp.Compiler.Syntax.SyntaxNode+SynPat: FSharp.Compiler.Syntax.SynPat Item
+FSharp.Compiler.Syntax.SyntaxNode+SynPat: FSharp.Compiler.Syntax.SynPat get_Item()
+FSharp.Compiler.Syntax.SyntaxNode+SynType: FSharp.Compiler.Syntax.SynType Item
+FSharp.Compiler.Syntax.SyntaxNode+SynType: FSharp.Compiler.Syntax.SynType get_Item()
+FSharp.Compiler.Syntax.SyntaxNode+SynTypeDefn: FSharp.Compiler.Syntax.SynTypeDefn Item
+FSharp.Compiler.Syntax.SyntaxNode+SynTypeDefn: FSharp.Compiler.Syntax.SynTypeDefn get_Item()
+FSharp.Compiler.Syntax.SyntaxNode+Tags: Int32 SynBinding
+FSharp.Compiler.Syntax.SyntaxNode+Tags: Int32 SynExpr
+FSharp.Compiler.Syntax.SyntaxNode+Tags: Int32 SynMatchClause
+FSharp.Compiler.Syntax.SyntaxNode+Tags: Int32 SynMemberDefn
+FSharp.Compiler.Syntax.SyntaxNode+Tags: Int32 SynModule
+FSharp.Compiler.Syntax.SyntaxNode+Tags: Int32 SynModuleOrNamespace
+FSharp.Compiler.Syntax.SyntaxNode+Tags: Int32 SynPat
+FSharp.Compiler.Syntax.SyntaxNode+Tags: Int32 SynType
+FSharp.Compiler.Syntax.SyntaxNode+Tags: Int32 SynTypeDefn
+FSharp.Compiler.Syntax.SyntaxNode: Boolean IsSynBinding
+FSharp.Compiler.Syntax.SyntaxNode: Boolean IsSynExpr
+FSharp.Compiler.Syntax.SyntaxNode: Boolean IsSynMatchClause
+FSharp.Compiler.Syntax.SyntaxNode: Boolean IsSynMemberDefn
+FSharp.Compiler.Syntax.SyntaxNode: Boolean IsSynModule
+FSharp.Compiler.Syntax.SyntaxNode: Boolean IsSynModuleOrNamespace
+FSharp.Compiler.Syntax.SyntaxNode: Boolean IsSynPat
+FSharp.Compiler.Syntax.SyntaxNode: Boolean IsSynType
+FSharp.Compiler.Syntax.SyntaxNode: Boolean IsSynTypeDefn
+FSharp.Compiler.Syntax.SyntaxNode: Boolean get_IsSynBinding()
+FSharp.Compiler.Syntax.SyntaxNode: Boolean get_IsSynExpr()
+FSharp.Compiler.Syntax.SyntaxNode: Boolean get_IsSynMatchClause()
+FSharp.Compiler.Syntax.SyntaxNode: Boolean get_IsSynMemberDefn()
+FSharp.Compiler.Syntax.SyntaxNode: Boolean get_IsSynModule()
+FSharp.Compiler.Syntax.SyntaxNode: Boolean get_IsSynModuleOrNamespace()
+FSharp.Compiler.Syntax.SyntaxNode: Boolean get_IsSynPat()
+FSharp.Compiler.Syntax.SyntaxNode: Boolean get_IsSynType()
+FSharp.Compiler.Syntax.SyntaxNode: Boolean get_IsSynTypeDefn()
+FSharp.Compiler.Syntax.SyntaxNode: FSharp.Compiler.Syntax.SyntaxNode NewSynBinding(FSharp.Compiler.Syntax.SynBinding)
+FSharp.Compiler.Syntax.SyntaxNode: FSharp.Compiler.Syntax.SyntaxNode NewSynExpr(FSharp.Compiler.Syntax.SynExpr)
+FSharp.Compiler.Syntax.SyntaxNode: FSharp.Compiler.Syntax.SyntaxNode NewSynMatchClause(FSharp.Compiler.Syntax.SynMatchClause)
+FSharp.Compiler.Syntax.SyntaxNode: FSharp.Compiler.Syntax.SyntaxNode NewSynMemberDefn(FSharp.Compiler.Syntax.SynMemberDefn)
+FSharp.Compiler.Syntax.SyntaxNode: FSharp.Compiler.Syntax.SyntaxNode NewSynModule(FSharp.Compiler.Syntax.SynModuleDecl)
+FSharp.Compiler.Syntax.SyntaxNode: FSharp.Compiler.Syntax.SyntaxNode NewSynModuleOrNamespace(FSharp.Compiler.Syntax.SynModuleOrNamespace)
+FSharp.Compiler.Syntax.SyntaxNode: FSharp.Compiler.Syntax.SyntaxNode NewSynPat(FSharp.Compiler.Syntax.SynPat)
+FSharp.Compiler.Syntax.SyntaxNode: FSharp.Compiler.Syntax.SyntaxNode NewSynType(FSharp.Compiler.Syntax.SynType)
+FSharp.Compiler.Syntax.SyntaxNode: FSharp.Compiler.Syntax.SyntaxNode NewSynTypeDefn(FSharp.Compiler.Syntax.SynTypeDefn)
+FSharp.Compiler.Syntax.SyntaxNode: FSharp.Compiler.Syntax.SyntaxNode+SynBinding
+FSharp.Compiler.Syntax.SyntaxNode: FSharp.Compiler.Syntax.SyntaxNode+SynExpr
+FSharp.Compiler.Syntax.SyntaxNode: FSharp.Compiler.Syntax.SyntaxNode+SynMatchClause
+FSharp.Compiler.Syntax.SyntaxNode: FSharp.Compiler.Syntax.SyntaxNode+SynMemberDefn
+FSharp.Compiler.Syntax.SyntaxNode: FSharp.Compiler.Syntax.SyntaxNode+SynModule
+FSharp.Compiler.Syntax.SyntaxNode: FSharp.Compiler.Syntax.SyntaxNode+SynModuleOrNamespace
+FSharp.Compiler.Syntax.SyntaxNode: FSharp.Compiler.Syntax.SyntaxNode+SynPat
+FSharp.Compiler.Syntax.SyntaxNode: FSharp.Compiler.Syntax.SyntaxNode+SynType
+FSharp.Compiler.Syntax.SyntaxNode: FSharp.Compiler.Syntax.SyntaxNode+SynTypeDefn
+FSharp.Compiler.Syntax.SyntaxNode: FSharp.Compiler.Syntax.SyntaxNode+Tags
+FSharp.Compiler.Syntax.SyntaxNode: Int32 Tag
+FSharp.Compiler.Syntax.SyntaxNode: Int32 get_Tag()
+FSharp.Compiler.Syntax.SyntaxNode: System.String ToString()
+FSharp.Compiler.Syntax.SyntaxTraversal: Microsoft.FSharp.Core.FSharpOption`1[T] Traverse[T](FSharp.Compiler.Text.Position, FSharp.Compiler.Syntax.ParsedInput, FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T])
+FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitBinding(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.Syntax.SynBinding,Microsoft.FSharp.Core.FSharpOption`1[T]], FSharp.Compiler.Syntax.SynBinding)
+FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitComponentInfo(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], FSharp.Compiler.Syntax.SynComponentInfo)
+FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitEnumDefn(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynEnumCase], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitExpr(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.Syntax.SynExpr,Microsoft.FSharp.Core.FSharpOption`1[T]], Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.Syntax.SynExpr,Microsoft.FSharp.Core.FSharpOption`1[T]], FSharp.Compiler.Syntax.SynExpr)
+FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitHashDirective(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], FSharp.Compiler.Syntax.ParsedHashDirective, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitImplicitInherit(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.Syntax.SynExpr,Microsoft.FSharp.Core.FSharpOption`1[T]], FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitInheritSynMemberDefn(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], FSharp.Compiler.Syntax.SynComponentInfo, FSharp.Compiler.Syntax.SynTypeDefnKind, FSharp.Compiler.Syntax.SynType, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynMemberDefn], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitInterfaceSynMemberDefnType(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], FSharp.Compiler.Syntax.SynType)
+FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitLetOrUse(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], Boolean, Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.Syntax.SynBinding,Microsoft.FSharp.Core.FSharpOption`1[T]], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynBinding], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitMatchClause(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.Syntax.SynMatchClause,Microsoft.FSharp.Core.FSharpOption`1[T]], FSharp.Compiler.Syntax.SynMatchClause)
+FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitModuleDecl(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.Syntax.SynModuleDecl,Microsoft.FSharp.Core.FSharpOption`1[T]], FSharp.Compiler.Syntax.SynModuleDecl)
+FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitModuleOrNamespace(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], FSharp.Compiler.Syntax.SynModuleOrNamespace)
+FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitPat(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.Syntax.SynPat,Microsoft.FSharp.Core.FSharpOption`1[T]], FSharp.Compiler.Syntax.SynPat)
+FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitRecordDefn(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynField], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitRecordField(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynExpr], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Syntax.SynLongIdent])
+FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitSimplePats(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynSimplePat])
+FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitType(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.Syntax.SynType,Microsoft.FSharp.Core.FSharpOption`1[T]], FSharp.Compiler.Syntax.SynType)
+FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitTypeAbbrev(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitUnionDefn(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynUnionCase], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Void .ctor()
+FSharp.Compiler.Syntax.TyparStaticReq+Tags: Int32 HeadType
+FSharp.Compiler.Syntax.TyparStaticReq+Tags: Int32 None
+FSharp.Compiler.Syntax.TyparStaticReq: Boolean Equals(FSharp.Compiler.Syntax.TyparStaticReq)
+FSharp.Compiler.Syntax.TyparStaticReq: Boolean Equals(System.Object)
+FSharp.Compiler.Syntax.TyparStaticReq: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.TyparStaticReq: Boolean IsHeadType
+FSharp.Compiler.Syntax.TyparStaticReq: Boolean IsNone
+FSharp.Compiler.Syntax.TyparStaticReq: Boolean get_IsHeadType()
+FSharp.Compiler.Syntax.TyparStaticReq: Boolean get_IsNone()
+FSharp.Compiler.Syntax.TyparStaticReq: FSharp.Compiler.Syntax.TyparStaticReq HeadType
+FSharp.Compiler.Syntax.TyparStaticReq: FSharp.Compiler.Syntax.TyparStaticReq None
+FSharp.Compiler.Syntax.TyparStaticReq: FSharp.Compiler.Syntax.TyparStaticReq get_HeadType()
+FSharp.Compiler.Syntax.TyparStaticReq: FSharp.Compiler.Syntax.TyparStaticReq get_None()
+FSharp.Compiler.Syntax.TyparStaticReq: FSharp.Compiler.Syntax.TyparStaticReq+Tags
+FSharp.Compiler.Syntax.TyparStaticReq: Int32 CompareTo(FSharp.Compiler.Syntax.TyparStaticReq)
+FSharp.Compiler.Syntax.TyparStaticReq: Int32 CompareTo(System.Object)
+FSharp.Compiler.Syntax.TyparStaticReq: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.Syntax.TyparStaticReq: Int32 GetHashCode()
+FSharp.Compiler.Syntax.TyparStaticReq: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Syntax.TyparStaticReq: Int32 Tag
+FSharp.Compiler.Syntax.TyparStaticReq: Int32 get_Tag()
+FSharp.Compiler.Syntax.TyparStaticReq: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.CommentTrivia+BlockComment: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.SyntaxTrivia.CommentTrivia+BlockComment: FSharp.Compiler.Text.Range range
+FSharp.Compiler.SyntaxTrivia.CommentTrivia+LineComment: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.SyntaxTrivia.CommentTrivia+LineComment: FSharp.Compiler.Text.Range range
+FSharp.Compiler.SyntaxTrivia.CommentTrivia+Tags: Int32 BlockComment
+FSharp.Compiler.SyntaxTrivia.CommentTrivia+Tags: Int32 LineComment
+FSharp.Compiler.SyntaxTrivia.CommentTrivia: Boolean IsBlockComment
+FSharp.Compiler.SyntaxTrivia.CommentTrivia: Boolean IsLineComment
+FSharp.Compiler.SyntaxTrivia.CommentTrivia: Boolean get_IsBlockComment()
+FSharp.Compiler.SyntaxTrivia.CommentTrivia: Boolean get_IsLineComment()
+FSharp.Compiler.SyntaxTrivia.CommentTrivia: FSharp.Compiler.SyntaxTrivia.CommentTrivia NewBlockComment(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.CommentTrivia: FSharp.Compiler.SyntaxTrivia.CommentTrivia NewLineComment(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.CommentTrivia: FSharp.Compiler.SyntaxTrivia.CommentTrivia+BlockComment
+FSharp.Compiler.SyntaxTrivia.CommentTrivia: FSharp.Compiler.SyntaxTrivia.CommentTrivia+LineComment
+FSharp.Compiler.SyntaxTrivia.CommentTrivia: FSharp.Compiler.SyntaxTrivia.CommentTrivia+Tags
+FSharp.Compiler.SyntaxTrivia.CommentTrivia: Int32 Tag
+FSharp.Compiler.SyntaxTrivia.CommentTrivia: Int32 get_Tag()
+FSharp.Compiler.SyntaxTrivia.CommentTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia+Else: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia+Else: FSharp.Compiler.Text.Range range
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia+EndIf: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia+EndIf: FSharp.Compiler.Text.Range range
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia+If: FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression expr
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia+If: FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression get_expr()
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia+If: FSharp.Compiler.Text.Range get_range()
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia+If: FSharp.Compiler.Text.Range range
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia+Tags: Int32 Else
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia+Tags: Int32 EndIf
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia+Tags: Int32 If
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia: Boolean IsElse
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia: Boolean IsEndIf
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia: Boolean IsIf
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia: Boolean get_IsElse()
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia: Boolean get_IsEndIf()
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia: Boolean get_IsIf()
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia: FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia NewElse(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia: FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia NewEndIf(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia: FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia NewIf(FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression, FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia: FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia+Else
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia: FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia+EndIf
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia: FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia+If
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia: FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia+Tags
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia: Int32 Tag
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia: Int32 get_Tag()
+FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords+Get: FSharp.Compiler.Text.Range Item
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords+Get: FSharp.Compiler.Text.Range get_Item()
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords+GetSet: FSharp.Compiler.Text.Range get
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords+GetSet: FSharp.Compiler.Text.Range get_get()
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords+GetSet: FSharp.Compiler.Text.Range get_set()
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords+GetSet: FSharp.Compiler.Text.Range set
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords+Set: FSharp.Compiler.Text.Range Item
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords+Set: FSharp.Compiler.Text.Range get_Item()
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords+Tags: Int32 Get
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords+Tags: Int32 GetSet
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords+Tags: Int32 Set
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords: Boolean IsGet
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords: Boolean IsGetSet
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords: Boolean IsSet
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords: Boolean get_IsGet()
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords: Boolean get_IsGetSet()
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords: Boolean get_IsSet()
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords: FSharp.Compiler.SyntaxTrivia.GetSetKeywords NewGet(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords: FSharp.Compiler.SyntaxTrivia.GetSetKeywords NewGetSet(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords: FSharp.Compiler.SyntaxTrivia.GetSetKeywords NewSet(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords: FSharp.Compiler.SyntaxTrivia.GetSetKeywords+Get
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords: FSharp.Compiler.SyntaxTrivia.GetSetKeywords+GetSet
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords: FSharp.Compiler.SyntaxTrivia.GetSetKeywords+Set
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords: FSharp.Compiler.SyntaxTrivia.GetSetKeywords+Tags
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords: Int32 Tag
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords: Int32 get_Tag()
+FSharp.Compiler.SyntaxTrivia.GetSetKeywords: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.IdentTrivia+HasParenthesis: FSharp.Compiler.Text.Range get_leftParenRange()
+FSharp.Compiler.SyntaxTrivia.IdentTrivia+HasParenthesis: FSharp.Compiler.Text.Range get_rightParenRange()
+FSharp.Compiler.SyntaxTrivia.IdentTrivia+HasParenthesis: FSharp.Compiler.Text.Range leftParenRange
+FSharp.Compiler.SyntaxTrivia.IdentTrivia+HasParenthesis: FSharp.Compiler.Text.Range rightParenRange
+FSharp.Compiler.SyntaxTrivia.IdentTrivia+OriginalNotation: System.String get_text()
+FSharp.Compiler.SyntaxTrivia.IdentTrivia+OriginalNotation: System.String text
+FSharp.Compiler.SyntaxTrivia.IdentTrivia+OriginalNotationWithParen: FSharp.Compiler.Text.Range get_leftParenRange()
+FSharp.Compiler.SyntaxTrivia.IdentTrivia+OriginalNotationWithParen: FSharp.Compiler.Text.Range get_rightParenRange()
+FSharp.Compiler.SyntaxTrivia.IdentTrivia+OriginalNotationWithParen: FSharp.Compiler.Text.Range leftParenRange
+FSharp.Compiler.SyntaxTrivia.IdentTrivia+OriginalNotationWithParen: FSharp.Compiler.Text.Range rightParenRange
+FSharp.Compiler.SyntaxTrivia.IdentTrivia+OriginalNotationWithParen: System.String get_text()
+FSharp.Compiler.SyntaxTrivia.IdentTrivia+OriginalNotationWithParen: System.String text
+FSharp.Compiler.SyntaxTrivia.IdentTrivia+Tags: Int32 HasParenthesis
+FSharp.Compiler.SyntaxTrivia.IdentTrivia+Tags: Int32 OriginalNotation
+FSharp.Compiler.SyntaxTrivia.IdentTrivia+Tags: Int32 OriginalNotationWithParen
+FSharp.Compiler.SyntaxTrivia.IdentTrivia: Boolean IsHasParenthesis
+FSharp.Compiler.SyntaxTrivia.IdentTrivia: Boolean IsOriginalNotation
+FSharp.Compiler.SyntaxTrivia.IdentTrivia: Boolean IsOriginalNotationWithParen
+FSharp.Compiler.SyntaxTrivia.IdentTrivia: Boolean get_IsHasParenthesis()
+FSharp.Compiler.SyntaxTrivia.IdentTrivia: Boolean get_IsOriginalNotation()
+FSharp.Compiler.SyntaxTrivia.IdentTrivia: Boolean get_IsOriginalNotationWithParen()
+FSharp.Compiler.SyntaxTrivia.IdentTrivia: FSharp.Compiler.SyntaxTrivia.IdentTrivia NewHasParenthesis(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.IdentTrivia: FSharp.Compiler.SyntaxTrivia.IdentTrivia NewOriginalNotation(System.String)
+FSharp.Compiler.SyntaxTrivia.IdentTrivia: FSharp.Compiler.SyntaxTrivia.IdentTrivia NewOriginalNotationWithParen(FSharp.Compiler.Text.Range, System.String, FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.IdentTrivia: FSharp.Compiler.SyntaxTrivia.IdentTrivia+HasParenthesis
+FSharp.Compiler.SyntaxTrivia.IdentTrivia: FSharp.Compiler.SyntaxTrivia.IdentTrivia+OriginalNotation
+FSharp.Compiler.SyntaxTrivia.IdentTrivia: FSharp.Compiler.SyntaxTrivia.IdentTrivia+OriginalNotationWithParen
+FSharp.Compiler.SyntaxTrivia.IdentTrivia: FSharp.Compiler.SyntaxTrivia.IdentTrivia+Tags
+FSharp.Compiler.SyntaxTrivia.IdentTrivia: Int32 Tag
+FSharp.Compiler.SyntaxTrivia.IdentTrivia: Int32 get_Tag()
+FSharp.Compiler.SyntaxTrivia.IdentTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression+And: FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression Item1
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression+And: FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression Item2
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression+And: FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression get_Item1()
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression+And: FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression get_Item2()
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression+Ident: System.String Item
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression+Ident: System.String get_Item()
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression+Not: FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression Item
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression+Not: FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression get_Item()
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression+Or: FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression Item1
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression+Or: FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression Item2
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression+Or: FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression get_Item1()
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression+Or: FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression get_Item2()
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression+Tags: Int32 And
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression+Tags: Int32 Ident
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression+Tags: Int32 Not
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression+Tags: Int32 Or
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression: Boolean IsAnd
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression: Boolean IsIdent
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression: Boolean IsNot
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression: Boolean IsOr
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression: Boolean get_IsAnd()
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression: Boolean get_IsIdent()
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression: Boolean get_IsNot()
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression: Boolean get_IsOr()
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression: FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression NewAnd(FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression, FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression)
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression: FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression NewIdent(System.String)
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression: FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression NewNot(FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression)
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression: FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression NewOr(FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression, FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression)
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression: FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression+And
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression: FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression+Ident
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression: FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression+Not
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression: FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression+Or
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression: FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression+Tags
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression: Int32 Tag
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression: Int32 get_Tag()
+FSharp.Compiler.SyntaxTrivia.IfDirectiveExpression: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.ParsedImplFileInputTrivia: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.CommentTrivia] CodeComments
+FSharp.Compiler.SyntaxTrivia.ParsedImplFileInputTrivia: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.CommentTrivia] get_CodeComments()
+FSharp.Compiler.SyntaxTrivia.ParsedImplFileInputTrivia: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia] ConditionalDirectives
+FSharp.Compiler.SyntaxTrivia.ParsedImplFileInputTrivia: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia] get_ConditionalDirectives()
+FSharp.Compiler.SyntaxTrivia.ParsedImplFileInputTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.ParsedImplFileInputTrivia: Void .ctor(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.CommentTrivia])
+FSharp.Compiler.SyntaxTrivia.ParsedSigFileInputTrivia: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.CommentTrivia] CodeComments
+FSharp.Compiler.SyntaxTrivia.ParsedSigFileInputTrivia: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.CommentTrivia] get_CodeComments()
+FSharp.Compiler.SyntaxTrivia.ParsedSigFileInputTrivia: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia] ConditionalDirectives
+FSharp.Compiler.SyntaxTrivia.ParsedSigFileInputTrivia: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia] get_ConditionalDirectives()
+FSharp.Compiler.SyntaxTrivia.ParsedSigFileInputTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.ParsedSigFileInputTrivia: Void .ctor(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.ConditionalDirectiveTrivia], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTrivia.CommentTrivia])
+FSharp.Compiler.SyntaxTrivia.SynArgPatsNamePatPairsTrivia: FSharp.Compiler.Text.Range ParenRange
+FSharp.Compiler.SyntaxTrivia.SynArgPatsNamePatPairsTrivia: FSharp.Compiler.Text.Range get_ParenRange()
+FSharp.Compiler.SyntaxTrivia.SynArgPatsNamePatPairsTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynArgPatsNamePatPairsTrivia: Void .ctor(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynBindingReturnInfoTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] ColonRange
+FSharp.Compiler.SyntaxTrivia.SynBindingReturnInfoTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_ColonRange()
+FSharp.Compiler.SyntaxTrivia.SynBindingReturnInfoTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynBindingReturnInfoTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
+FSharp.Compiler.SyntaxTrivia.SynBindingTrivia: FSharp.Compiler.SyntaxTrivia.SynBindingTrivia Zero
+FSharp.Compiler.SyntaxTrivia.SynBindingTrivia: FSharp.Compiler.SyntaxTrivia.SynBindingTrivia get_Zero()
+FSharp.Compiler.SyntaxTrivia.SynBindingTrivia: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword LeadingKeyword
+FSharp.Compiler.SyntaxTrivia.SynBindingTrivia: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword get_LeadingKeyword()
+FSharp.Compiler.SyntaxTrivia.SynBindingTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] EqualsRange
+FSharp.Compiler.SyntaxTrivia.SynBindingTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] InlineKeyword
+FSharp.Compiler.SyntaxTrivia.SynBindingTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_EqualsRange()
+FSharp.Compiler.SyntaxTrivia.SynBindingTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_InlineKeyword()
+FSharp.Compiler.SyntaxTrivia.SynBindingTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynBindingTrivia: Void .ctor(FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
+FSharp.Compiler.SyntaxTrivia.SynEnumCaseTrivia: FSharp.Compiler.Text.Range EqualsRange
+FSharp.Compiler.SyntaxTrivia.SynEnumCaseTrivia: FSharp.Compiler.Text.Range get_EqualsRange()
+FSharp.Compiler.SyntaxTrivia.SynEnumCaseTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] BarRange
+FSharp.Compiler.SyntaxTrivia.SynEnumCaseTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_BarRange()
+FSharp.Compiler.SyntaxTrivia.SynEnumCaseTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynEnumCaseTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynExprAndBangTrivia: FSharp.Compiler.Text.Range EqualsRange
+FSharp.Compiler.SyntaxTrivia.SynExprAndBangTrivia: FSharp.Compiler.Text.Range get_EqualsRange()
+FSharp.Compiler.SyntaxTrivia.SynExprAndBangTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] InKeyword
+FSharp.Compiler.SyntaxTrivia.SynExprAndBangTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_InKeyword()
+FSharp.Compiler.SyntaxTrivia.SynExprAndBangTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynExprAndBangTrivia: Void .ctor(FSharp.Compiler.Text.Range, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
+FSharp.Compiler.SyntaxTrivia.SynExprIfThenElseTrivia: Boolean IsElif
+FSharp.Compiler.SyntaxTrivia.SynExprIfThenElseTrivia: Boolean get_IsElif()
+FSharp.Compiler.SyntaxTrivia.SynExprIfThenElseTrivia: FSharp.Compiler.Text.Range IfKeyword
+FSharp.Compiler.SyntaxTrivia.SynExprIfThenElseTrivia: FSharp.Compiler.Text.Range IfToThenRange
+FSharp.Compiler.SyntaxTrivia.SynExprIfThenElseTrivia: FSharp.Compiler.Text.Range ThenKeyword
+FSharp.Compiler.SyntaxTrivia.SynExprIfThenElseTrivia: FSharp.Compiler.Text.Range get_IfKeyword()
+FSharp.Compiler.SyntaxTrivia.SynExprIfThenElseTrivia: FSharp.Compiler.Text.Range get_IfToThenRange()
+FSharp.Compiler.SyntaxTrivia.SynExprIfThenElseTrivia: FSharp.Compiler.Text.Range get_ThenKeyword()
+FSharp.Compiler.SyntaxTrivia.SynExprIfThenElseTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] ElseKeyword
+FSharp.Compiler.SyntaxTrivia.SynExprIfThenElseTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_ElseKeyword()
+FSharp.Compiler.SyntaxTrivia.SynExprIfThenElseTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynExprIfThenElseTrivia: Void .ctor(FSharp.Compiler.Text.Range, Boolean, FSharp.Compiler.Text.Range, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynExprLambdaTrivia: FSharp.Compiler.SyntaxTrivia.SynExprLambdaTrivia Zero
+FSharp.Compiler.SyntaxTrivia.SynExprLambdaTrivia: FSharp.Compiler.SyntaxTrivia.SynExprLambdaTrivia get_Zero()
+FSharp.Compiler.SyntaxTrivia.SynExprLambdaTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] ArrowRange
+FSharp.Compiler.SyntaxTrivia.SynExprLambdaTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_ArrowRange()
+FSharp.Compiler.SyntaxTrivia.SynExprLambdaTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynExprLambdaTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
+FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseBangTrivia: FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseBangTrivia Zero
+FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseBangTrivia: FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseBangTrivia get_Zero()
+FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseBangTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] EqualsRange
+FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseBangTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_EqualsRange()
+FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseBangTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseBangTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
+FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] InKeyword
+FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_InKeyword()
+FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
+FSharp.Compiler.SyntaxTrivia.SynExprMatchBangTrivia: FSharp.Compiler.Text.Range MatchBangKeyword
+FSharp.Compiler.SyntaxTrivia.SynExprMatchBangTrivia: FSharp.Compiler.Text.Range WithKeyword
+FSharp.Compiler.SyntaxTrivia.SynExprMatchBangTrivia: FSharp.Compiler.Text.Range get_MatchBangKeyword()
+FSharp.Compiler.SyntaxTrivia.SynExprMatchBangTrivia: FSharp.Compiler.Text.Range get_WithKeyword()
+FSharp.Compiler.SyntaxTrivia.SynExprMatchBangTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynExprMatchBangTrivia: Void .ctor(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynExprMatchTrivia: FSharp.Compiler.Text.Range MatchKeyword
+FSharp.Compiler.SyntaxTrivia.SynExprMatchTrivia: FSharp.Compiler.Text.Range WithKeyword
+FSharp.Compiler.SyntaxTrivia.SynExprMatchTrivia: FSharp.Compiler.Text.Range get_MatchKeyword()
+FSharp.Compiler.SyntaxTrivia.SynExprMatchTrivia: FSharp.Compiler.Text.Range get_WithKeyword()
+FSharp.Compiler.SyntaxTrivia.SynExprMatchTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynExprMatchTrivia: Void .ctor(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynExprTryFinallyTrivia: FSharp.Compiler.Text.Range FinallyKeyword
+FSharp.Compiler.SyntaxTrivia.SynExprTryFinallyTrivia: FSharp.Compiler.Text.Range TryKeyword
+FSharp.Compiler.SyntaxTrivia.SynExprTryFinallyTrivia: FSharp.Compiler.Text.Range get_FinallyKeyword()
+FSharp.Compiler.SyntaxTrivia.SynExprTryFinallyTrivia: FSharp.Compiler.Text.Range get_TryKeyword()
+FSharp.Compiler.SyntaxTrivia.SynExprTryFinallyTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynExprTryFinallyTrivia: Void .ctor(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynExprTryWithTrivia: FSharp.Compiler.Text.Range TryKeyword
+FSharp.Compiler.SyntaxTrivia.SynExprTryWithTrivia: FSharp.Compiler.Text.Range TryToWithRange
+FSharp.Compiler.SyntaxTrivia.SynExprTryWithTrivia: FSharp.Compiler.Text.Range WithKeyword
+FSharp.Compiler.SyntaxTrivia.SynExprTryWithTrivia: FSharp.Compiler.Text.Range WithToEndRange
+FSharp.Compiler.SyntaxTrivia.SynExprTryWithTrivia: FSharp.Compiler.Text.Range get_TryKeyword()
+FSharp.Compiler.SyntaxTrivia.SynExprTryWithTrivia: FSharp.Compiler.Text.Range get_TryToWithRange()
+FSharp.Compiler.SyntaxTrivia.SynExprTryWithTrivia: FSharp.Compiler.Text.Range get_WithKeyword()
+FSharp.Compiler.SyntaxTrivia.SynExprTryWithTrivia: FSharp.Compiler.Text.Range get_WithToEndRange()
+FSharp.Compiler.SyntaxTrivia.SynExprTryWithTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynExprTryWithTrivia: Void .ctor(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynFieldTrivia: FSharp.Compiler.SyntaxTrivia.SynFieldTrivia Zero
+FSharp.Compiler.SyntaxTrivia.SynFieldTrivia: FSharp.Compiler.SyntaxTrivia.SynFieldTrivia get_Zero()
+FSharp.Compiler.SyntaxTrivia.SynFieldTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword] LeadingKeyword
+FSharp.Compiler.SyntaxTrivia.SynFieldTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword] get_LeadingKeyword()
+FSharp.Compiler.SyntaxTrivia.SynFieldTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynFieldTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword])
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Abstract: FSharp.Compiler.Text.Range abstractRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Abstract: FSharp.Compiler.Text.Range get_abstractRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+AbstractMember: FSharp.Compiler.Text.Range abstractRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+AbstractMember: FSharp.Compiler.Text.Range get_abstractRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+AbstractMember: FSharp.Compiler.Text.Range get_memberRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+AbstractMember: FSharp.Compiler.Text.Range memberRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+And: FSharp.Compiler.Text.Range andRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+And: FSharp.Compiler.Text.Range get_andRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Default: FSharp.Compiler.Text.Range defaultRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Default: FSharp.Compiler.Text.Range get_defaultRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+DefaultVal: FSharp.Compiler.Text.Range defaultRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+DefaultVal: FSharp.Compiler.Text.Range get_defaultRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+DefaultVal: FSharp.Compiler.Text.Range get_valRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+DefaultVal: FSharp.Compiler.Text.Range valRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Do: FSharp.Compiler.Text.Range doRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Do: FSharp.Compiler.Text.Range get_doRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Extern: FSharp.Compiler.Text.Range externRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Extern: FSharp.Compiler.Text.Range get_externRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Let: FSharp.Compiler.Text.Range get_letRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Let: FSharp.Compiler.Text.Range letRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+LetRec: FSharp.Compiler.Text.Range get_letRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+LetRec: FSharp.Compiler.Text.Range get_recRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+LetRec: FSharp.Compiler.Text.Range letRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+LetRec: FSharp.Compiler.Text.Range recRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Member: FSharp.Compiler.Text.Range get_memberRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Member: FSharp.Compiler.Text.Range memberRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+MemberVal: FSharp.Compiler.Text.Range get_memberRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+MemberVal: FSharp.Compiler.Text.Range get_valRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+MemberVal: FSharp.Compiler.Text.Range memberRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+MemberVal: FSharp.Compiler.Text.Range valRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+New: FSharp.Compiler.Text.Range get_newRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+New: FSharp.Compiler.Text.Range newRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Override: FSharp.Compiler.Text.Range get_overrideRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Override: FSharp.Compiler.Text.Range overrideRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+OverrideVal: FSharp.Compiler.Text.Range get_overrideRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+OverrideVal: FSharp.Compiler.Text.Range get_valRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+OverrideVal: FSharp.Compiler.Text.Range overrideRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+OverrideVal: FSharp.Compiler.Text.Range valRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticAbstract: FSharp.Compiler.Text.Range abstractRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticAbstract: FSharp.Compiler.Text.Range get_abstractRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticAbstract: FSharp.Compiler.Text.Range get_staticRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticAbstract: FSharp.Compiler.Text.Range staticRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticAbstractMember: FSharp.Compiler.Text.Range abstractMember
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticAbstractMember: FSharp.Compiler.Text.Range get_abstractMember()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticAbstractMember: FSharp.Compiler.Text.Range get_memberRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticAbstractMember: FSharp.Compiler.Text.Range get_staticRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticAbstractMember: FSharp.Compiler.Text.Range memberRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticAbstractMember: FSharp.Compiler.Text.Range staticRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticDo: FSharp.Compiler.Text.Range doRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticDo: FSharp.Compiler.Text.Range get_doRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticDo: FSharp.Compiler.Text.Range get_staticRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticDo: FSharp.Compiler.Text.Range staticRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticLet: FSharp.Compiler.Text.Range get_letRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticLet: FSharp.Compiler.Text.Range get_staticRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticLet: FSharp.Compiler.Text.Range letRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticLet: FSharp.Compiler.Text.Range staticRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticLetRec: FSharp.Compiler.Text.Range get_letRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticLetRec: FSharp.Compiler.Text.Range get_recRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticLetRec: FSharp.Compiler.Text.Range get_staticRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticLetRec: FSharp.Compiler.Text.Range letRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticLetRec: FSharp.Compiler.Text.Range recRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticLetRec: FSharp.Compiler.Text.Range staticRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticMember: FSharp.Compiler.Text.Range get_memberRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticMember: FSharp.Compiler.Text.Range get_staticRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticMember: FSharp.Compiler.Text.Range memberRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticMember: FSharp.Compiler.Text.Range staticRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticMemberVal: FSharp.Compiler.Text.Range get_memberRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticMemberVal: FSharp.Compiler.Text.Range get_staticRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticMemberVal: FSharp.Compiler.Text.Range get_valRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticMemberVal: FSharp.Compiler.Text.Range memberRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticMemberVal: FSharp.Compiler.Text.Range staticRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticMemberVal: FSharp.Compiler.Text.Range valRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticVal: FSharp.Compiler.Text.Range get_staticRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticVal: FSharp.Compiler.Text.Range get_valRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticVal: FSharp.Compiler.Text.Range staticRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticVal: FSharp.Compiler.Text.Range valRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 Abstract
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 AbstractMember
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 And
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 Default
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 DefaultVal
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 Do
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 Extern
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 Let
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 LetRec
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 Member
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 MemberVal
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 New
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 Override
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 OverrideVal
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 StaticAbstract
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 StaticAbstractMember
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 StaticDo
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 StaticLet
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 StaticLetRec
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 StaticMember
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 StaticMemberVal
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 StaticVal
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 Synthetic
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 Use
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 UseRec
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags: Int32 Val
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Use: FSharp.Compiler.Text.Range get_useRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Use: FSharp.Compiler.Text.Range useRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+UseRec: FSharp.Compiler.Text.Range get_recRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+UseRec: FSharp.Compiler.Text.Range get_useRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+UseRec: FSharp.Compiler.Text.Range recRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+UseRec: FSharp.Compiler.Text.Range useRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Val: FSharp.Compiler.Text.Range get_valRange()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Val: FSharp.Compiler.Text.Range valRange
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsAbstract
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsAbstractMember
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsAnd
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsDefault
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsDefaultVal
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsDo
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsExtern
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsLet
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsLetRec
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsMember
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsMemberVal
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsNew
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsOverride
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsOverrideVal
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsStaticAbstract
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsStaticAbstractMember
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsStaticDo
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsStaticLet
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsStaticLetRec
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsStaticMember
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsStaticMemberVal
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsStaticVal
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsSynthetic
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsUse
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsUseRec
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean IsVal
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsAbstract()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsAbstractMember()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsAnd()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsDefault()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsDefaultVal()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsDo()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsExtern()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsLet()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsLetRec()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsMember()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsMemberVal()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsNew()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsOverride()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsOverrideVal()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsStaticAbstract()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsStaticAbstractMember()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsStaticDo()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsStaticLet()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsStaticLetRec()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsStaticMember()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsStaticMemberVal()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsStaticVal()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsSynthetic()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsUse()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsUseRec()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Boolean get_IsVal()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword NewAbstract(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword NewAbstractMember(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword NewAnd(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword NewDefault(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword NewDefaultVal(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword NewDo(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword NewExtern(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword NewLet(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword NewLetRec(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword NewMember(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword NewMemberVal(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword NewNew(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword NewOverride(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword NewOverrideVal(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword NewStaticAbstract(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword NewStaticAbstractMember(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword NewStaticDo(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword NewStaticLet(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword NewStaticLetRec(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword NewStaticMember(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword NewStaticMemberVal(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword NewStaticVal(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword NewUse(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword NewUseRec(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword NewVal(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword Synthetic
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword get_Synthetic()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Abstract
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+AbstractMember
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+And
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Default
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+DefaultVal
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Do
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Extern
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Let
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+LetRec
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Member
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+MemberVal
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+New
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Override
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+OverrideVal
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticAbstract
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticAbstractMember
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticDo
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticLet
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticLetRec
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticMember
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticMemberVal
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+StaticVal
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Tags
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Use
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+UseRec
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword+Val
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Int32 Tag
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: Int32 get_Tag()
+FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynMatchClauseTrivia: FSharp.Compiler.SyntaxTrivia.SynMatchClauseTrivia Zero
+FSharp.Compiler.SyntaxTrivia.SynMatchClauseTrivia: FSharp.Compiler.SyntaxTrivia.SynMatchClauseTrivia get_Zero()
+FSharp.Compiler.SyntaxTrivia.SynMatchClauseTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] ArrowRange
+FSharp.Compiler.SyntaxTrivia.SynMatchClauseTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] BarRange
+FSharp.Compiler.SyntaxTrivia.SynMatchClauseTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_ArrowRange()
+FSharp.Compiler.SyntaxTrivia.SynMatchClauseTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_BarRange()
+FSharp.Compiler.SyntaxTrivia.SynMatchClauseTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynMatchClauseTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
+FSharp.Compiler.SyntaxTrivia.SynMemberDefnAbstractSlotTrivia: FSharp.Compiler.SyntaxTrivia.SynMemberDefnAbstractSlotTrivia Zero
+FSharp.Compiler.SyntaxTrivia.SynMemberDefnAbstractSlotTrivia: FSharp.Compiler.SyntaxTrivia.SynMemberDefnAbstractSlotTrivia get_Zero()
+FSharp.Compiler.SyntaxTrivia.SynMemberDefnAbstractSlotTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.GetSetKeywords] GetSetKeywords
+FSharp.Compiler.SyntaxTrivia.SynMemberDefnAbstractSlotTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.GetSetKeywords] get_GetSetKeywords()
+FSharp.Compiler.SyntaxTrivia.SynMemberDefnAbstractSlotTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynMemberDefnAbstractSlotTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.GetSetKeywords])
+FSharp.Compiler.SyntaxTrivia.SynMemberDefnAutoPropertyTrivia: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword LeadingKeyword
+FSharp.Compiler.SyntaxTrivia.SynMemberDefnAutoPropertyTrivia: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword get_LeadingKeyword()
+FSharp.Compiler.SyntaxTrivia.SynMemberDefnAutoPropertyTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.GetSetKeywords] GetSetKeywords
+FSharp.Compiler.SyntaxTrivia.SynMemberDefnAutoPropertyTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.GetSetKeywords] get_GetSetKeywords()
+FSharp.Compiler.SyntaxTrivia.SynMemberDefnAutoPropertyTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] EqualsRange
+FSharp.Compiler.SyntaxTrivia.SynMemberDefnAutoPropertyTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] WithKeyword
+FSharp.Compiler.SyntaxTrivia.SynMemberDefnAutoPropertyTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_EqualsRange()
+FSharp.Compiler.SyntaxTrivia.SynMemberDefnAutoPropertyTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_WithKeyword()
+FSharp.Compiler.SyntaxTrivia.SynMemberDefnAutoPropertyTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynMemberDefnAutoPropertyTrivia: Void .ctor(FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.GetSetKeywords])
+FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia: FSharp.Compiler.Text.Range WithKeyword
+FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia: FSharp.Compiler.Text.Range get_WithKeyword()
+FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] AndKeyword
+FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] GetKeyword
+FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] InlineKeyword
+FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] SetKeyword
+FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_AndKeyword()
+FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_GetKeyword()
+FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_InlineKeyword()
+FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_SetKeyword()
+FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynMemberGetSetTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], FSharp.Compiler.Text.Range, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
+FSharp.Compiler.SyntaxTrivia.SynMemberSigMemberTrivia: FSharp.Compiler.SyntaxTrivia.SynMemberSigMemberTrivia Zero
+FSharp.Compiler.SyntaxTrivia.SynMemberSigMemberTrivia: FSharp.Compiler.SyntaxTrivia.SynMemberSigMemberTrivia get_Zero()
+FSharp.Compiler.SyntaxTrivia.SynMemberSigMemberTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.GetSetKeywords] GetSetKeywords
+FSharp.Compiler.SyntaxTrivia.SynMemberSigMemberTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.GetSetKeywords] get_GetSetKeywords()
+FSharp.Compiler.SyntaxTrivia.SynMemberSigMemberTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynMemberSigMemberTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.SyntaxTrivia.GetSetKeywords])
+FSharp.Compiler.SyntaxTrivia.SynModuleDeclNestedModuleTrivia: FSharp.Compiler.SyntaxTrivia.SynModuleDeclNestedModuleTrivia Zero
+FSharp.Compiler.SyntaxTrivia.SynModuleDeclNestedModuleTrivia: FSharp.Compiler.SyntaxTrivia.SynModuleDeclNestedModuleTrivia get_Zero()
+FSharp.Compiler.SyntaxTrivia.SynModuleDeclNestedModuleTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] EqualsRange
+FSharp.Compiler.SyntaxTrivia.SynModuleDeclNestedModuleTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] ModuleKeyword
+FSharp.Compiler.SyntaxTrivia.SynModuleDeclNestedModuleTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_EqualsRange()
+FSharp.Compiler.SyntaxTrivia.SynModuleDeclNestedModuleTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_ModuleKeyword()
+FSharp.Compiler.SyntaxTrivia.SynModuleDeclNestedModuleTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynModuleDeclNestedModuleTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword+Module: FSharp.Compiler.Text.Range get_moduleRange()
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword+Module: FSharp.Compiler.Text.Range moduleRange
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword+Namespace: FSharp.Compiler.Text.Range get_namespaceRange()
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword+Namespace: FSharp.Compiler.Text.Range namespaceRange
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword+Tags: Int32 Module
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword+Tags: Int32 Namespace
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword+Tags: Int32 None
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword: Boolean IsModule
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword: Boolean IsNamespace
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword: Boolean IsNone
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword: Boolean get_IsModule()
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword: Boolean get_IsNamespace()
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword: Boolean get_IsNone()
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword NewModule(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword NewNamespace(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword None
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword get_None()
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword+Module
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword+Namespace
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword+Tags
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword: Int32 Tag
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword: Int32 get_Tag()
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceSigTrivia: FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword LeadingKeyword
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceSigTrivia: FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword get_LeadingKeyword()
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceSigTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceSigTrivia: Void .ctor(FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword)
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceTrivia: FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword LeadingKeyword
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceTrivia: FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword get_LeadingKeyword()
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceTrivia: Void .ctor(FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceLeadingKeyword)
+FSharp.Compiler.SyntaxTrivia.SynModuleSigDeclNestedModuleTrivia: FSharp.Compiler.SyntaxTrivia.SynModuleSigDeclNestedModuleTrivia Zero
+FSharp.Compiler.SyntaxTrivia.SynModuleSigDeclNestedModuleTrivia: FSharp.Compiler.SyntaxTrivia.SynModuleSigDeclNestedModuleTrivia get_Zero()
+FSharp.Compiler.SyntaxTrivia.SynModuleSigDeclNestedModuleTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] EqualsRange
+FSharp.Compiler.SyntaxTrivia.SynModuleSigDeclNestedModuleTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] ModuleKeyword
+FSharp.Compiler.SyntaxTrivia.SynModuleSigDeclNestedModuleTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_EqualsRange()
+FSharp.Compiler.SyntaxTrivia.SynModuleSigDeclNestedModuleTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_ModuleKeyword()
+FSharp.Compiler.SyntaxTrivia.SynModuleSigDeclNestedModuleTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynModuleSigDeclNestedModuleTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
+FSharp.Compiler.SyntaxTrivia.SynPatListConsTrivia: FSharp.Compiler.Text.Range ColonColonRange
+FSharp.Compiler.SyntaxTrivia.SynPatListConsTrivia: FSharp.Compiler.Text.Range get_ColonColonRange()
+FSharp.Compiler.SyntaxTrivia.SynPatListConsTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynPatListConsTrivia: Void .ctor(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynPatOrTrivia: FSharp.Compiler.Text.Range BarRange
+FSharp.Compiler.SyntaxTrivia.SynPatOrTrivia: FSharp.Compiler.Text.Range get_BarRange()
+FSharp.Compiler.SyntaxTrivia.SynPatOrTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynPatOrTrivia: Void .ctor(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword+And: FSharp.Compiler.Text.Range Item
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword+And: FSharp.Compiler.Text.Range get_Item()
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword+StaticType: FSharp.Compiler.Text.Range get_staticRange()
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword+StaticType: FSharp.Compiler.Text.Range get_typeRange()
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword+StaticType: FSharp.Compiler.Text.Range staticRange
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword+StaticType: FSharp.Compiler.Text.Range typeRange
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword+Tags: Int32 And
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword+Tags: Int32 StaticType
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword+Tags: Int32 Synthetic
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword+Tags: Int32 Type
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword+Type: FSharp.Compiler.Text.Range Item
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword+Type: FSharp.Compiler.Text.Range get_Item()
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword: Boolean IsAnd
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword: Boolean IsStaticType
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword: Boolean IsSynthetic
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword: Boolean IsType
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword: Boolean get_IsAnd()
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword: Boolean get_IsStaticType()
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword: Boolean get_IsSynthetic()
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword: Boolean get_IsType()
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword NewAnd(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword NewStaticType(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword NewType(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword Synthetic
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword get_Synthetic()
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword+And
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword+StaticType
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword+Tags
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword: FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword+Type
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword: Int32 Tag
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword: Int32 get_Tag()
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnSigTrivia: FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword LeadingKeyword
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnSigTrivia: FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword get_LeadingKeyword()
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnSigTrivia: FSharp.Compiler.SyntaxTrivia.SynTypeDefnSigTrivia Zero
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnSigTrivia: FSharp.Compiler.SyntaxTrivia.SynTypeDefnSigTrivia get_Zero()
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnSigTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] EqualsRange
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnSigTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] WithKeyword
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnSigTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_EqualsRange()
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnSigTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_WithKeyword()
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnSigTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnSigTrivia: Void .ctor(FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnTrivia: FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword LeadingKeyword
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnTrivia: FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword get_LeadingKeyword()
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnTrivia: FSharp.Compiler.SyntaxTrivia.SynTypeDefnTrivia Zero
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnTrivia: FSharp.Compiler.SyntaxTrivia.SynTypeDefnTrivia get_Zero()
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] EqualsRange
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] WithKeyword
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_EqualsRange()
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_WithKeyword()
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynTypeDefnTrivia: Void .ctor(FSharp.Compiler.SyntaxTrivia.SynTypeDefnLeadingKeyword, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
+FSharp.Compiler.SyntaxTrivia.SynTypeFunTrivia: FSharp.Compiler.Text.Range ArrowRange
+FSharp.Compiler.SyntaxTrivia.SynTypeFunTrivia: FSharp.Compiler.Text.Range get_ArrowRange()
+FSharp.Compiler.SyntaxTrivia.SynTypeFunTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynTypeFunTrivia: Void .ctor(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynTypeOrTrivia: FSharp.Compiler.Text.Range OrKeyword
+FSharp.Compiler.SyntaxTrivia.SynTypeOrTrivia: FSharp.Compiler.Text.Range get_OrKeyword()
+FSharp.Compiler.SyntaxTrivia.SynTypeOrTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynTypeOrTrivia: Void .ctor(FSharp.Compiler.Text.Range)
+FSharp.Compiler.SyntaxTrivia.SynUnionCaseTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] BarRange
+FSharp.Compiler.SyntaxTrivia.SynUnionCaseTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_BarRange()
+FSharp.Compiler.SyntaxTrivia.SynUnionCaseTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynUnionCaseTrivia: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
+FSharp.Compiler.SyntaxTrivia.SynValSigTrivia: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword LeadingKeyword
+FSharp.Compiler.SyntaxTrivia.SynValSigTrivia: FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword get_LeadingKeyword()
+FSharp.Compiler.SyntaxTrivia.SynValSigTrivia: FSharp.Compiler.SyntaxTrivia.SynValSigTrivia Zero
+FSharp.Compiler.SyntaxTrivia.SynValSigTrivia: FSharp.Compiler.SyntaxTrivia.SynValSigTrivia get_Zero()
+FSharp.Compiler.SyntaxTrivia.SynValSigTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] EqualsRange
+FSharp.Compiler.SyntaxTrivia.SynValSigTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] InlineKeyword
+FSharp.Compiler.SyntaxTrivia.SynValSigTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] WithKeyword
+FSharp.Compiler.SyntaxTrivia.SynValSigTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_EqualsRange()
+FSharp.Compiler.SyntaxTrivia.SynValSigTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_InlineKeyword()
+FSharp.Compiler.SyntaxTrivia.SynValSigTrivia: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range] get_WithKeyword()
+FSharp.Compiler.SyntaxTrivia.SynValSigTrivia: System.String ToString()
+FSharp.Compiler.SyntaxTrivia.SynValSigTrivia: Void .ctor(FSharp.Compiler.SyntaxTrivia.SynLeadingKeyword, Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Text.Range])
+FSharp.Compiler.Text.ISourceText: Boolean ContentEquals(FSharp.Compiler.Text.ISourceText)
+FSharp.Compiler.Text.ISourceText: Boolean SubTextEquals(System.String, Int32)
+FSharp.Compiler.Text.ISourceText: Char Item [Int32]
+FSharp.Compiler.Text.ISourceText: Char get_Item(Int32)
+FSharp.Compiler.Text.ISourceText: Int32 GetLineCount()
+FSharp.Compiler.Text.ISourceText: Int32 Length
+FSharp.Compiler.Text.ISourceText: Int32 get_Length()
+FSharp.Compiler.Text.ISourceText: System.String GetLineString(Int32)
+FSharp.Compiler.Text.ISourceText: System.String GetSubTextString(Int32, Int32)
+FSharp.Compiler.Text.ISourceText: System.Tuple`2[System.Int32,System.Int32] GetLastCharacterPosition()
+FSharp.Compiler.Text.ISourceText: Void CopyTo(Int32, Char[], Int32, Int32)
+FSharp.Compiler.Text.Line: Int32 fromZ(Int32)
+FSharp.Compiler.Text.Line: Int32 toZ(Int32)
+FSharp.Compiler.Text.NavigableTaggedText: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Text.NavigableTaggedText: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Text.Position: Boolean Equals(System.Object)
+FSharp.Compiler.Text.Position: Int32 Column
+FSharp.Compiler.Text.Position: Int32 GetHashCode()
+FSharp.Compiler.Text.Position: Int32 Line
+FSharp.Compiler.Text.Position: Int32 get_Column()
+FSharp.Compiler.Text.Position: Int32 get_Line()
+FSharp.Compiler.Text.Position: System.String ToString()
+FSharp.Compiler.Text.PositionModule: Boolean posEq(FSharp.Compiler.Text.Position, FSharp.Compiler.Text.Position)
+FSharp.Compiler.Text.PositionModule: Boolean posGeq(FSharp.Compiler.Text.Position, FSharp.Compiler.Text.Position)
+FSharp.Compiler.Text.PositionModule: Boolean posGt(FSharp.Compiler.Text.Position, FSharp.Compiler.Text.Position)
+FSharp.Compiler.Text.PositionModule: Boolean posLt(FSharp.Compiler.Text.Position, FSharp.Compiler.Text.Position)
+FSharp.Compiler.Text.PositionModule: FSharp.Compiler.Text.Position fromZ(Int32, Int32)
+FSharp.Compiler.Text.PositionModule: FSharp.Compiler.Text.Position get_pos0()
+FSharp.Compiler.Text.PositionModule: FSharp.Compiler.Text.Position mkPos(Int32, Int32)
+FSharp.Compiler.Text.PositionModule: FSharp.Compiler.Text.Position pos0
+FSharp.Compiler.Text.PositionModule: System.String stringOfPos(FSharp.Compiler.Text.Position)
+FSharp.Compiler.Text.PositionModule: System.Tuple`2[System.Int32,System.Int32] toZ(FSharp.Compiler.Text.Position)
+FSharp.Compiler.Text.PositionModule: Void outputPos(System.IO.TextWriter, FSharp.Compiler.Text.Position)
+FSharp.Compiler.Text.Range: Boolean Equals(System.Object)
+FSharp.Compiler.Text.Range: Boolean IsSynthetic
+FSharp.Compiler.Text.Range: Boolean get_IsSynthetic()
+FSharp.Compiler.Text.Range: FSharp.Compiler.Text.Position End
+FSharp.Compiler.Text.Range: FSharp.Compiler.Text.Position Start
+FSharp.Compiler.Text.Range: FSharp.Compiler.Text.Position get_End()
+FSharp.Compiler.Text.Range: FSharp.Compiler.Text.Position get_Start()
+FSharp.Compiler.Text.Range: FSharp.Compiler.Text.Range EndRange
+FSharp.Compiler.Text.Range: FSharp.Compiler.Text.Range StartRange
+FSharp.Compiler.Text.Range: FSharp.Compiler.Text.Range Zero
+FSharp.Compiler.Text.Range: FSharp.Compiler.Text.Range get_EndRange()
+FSharp.Compiler.Text.Range: FSharp.Compiler.Text.Range get_StartRange()
+FSharp.Compiler.Text.Range: FSharp.Compiler.Text.Range get_Zero()
+FSharp.Compiler.Text.Range: Int32 EndColumn
+FSharp.Compiler.Text.Range: Int32 EndLine
+FSharp.Compiler.Text.Range: Int32 GetHashCode()
+FSharp.Compiler.Text.Range: Int32 StartColumn
+FSharp.Compiler.Text.Range: Int32 StartLine
+FSharp.Compiler.Text.Range: Int32 get_EndColumn()
+FSharp.Compiler.Text.Range: Int32 get_EndLine()
+FSharp.Compiler.Text.Range: Int32 get_StartColumn()
+FSharp.Compiler.Text.Range: Int32 get_StartLine()
+FSharp.Compiler.Text.Range: System.String FileName
+FSharp.Compiler.Text.Range: System.String ToString()
+FSharp.Compiler.Text.Range: System.String get_FileName()
+FSharp.Compiler.Text.RangeModule: Boolean equals(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Text.RangeModule: Boolean rangeBeforePos(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Position)
+FSharp.Compiler.Text.RangeModule: Boolean rangeContainsPos(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Position)
+FSharp.Compiler.Text.RangeModule: Boolean rangeContainsRange(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Text.RangeModule: FSharp.Compiler.Text.Range get_range0()
+FSharp.Compiler.Text.RangeModule: FSharp.Compiler.Text.Range get_rangeCmdArgs()
+FSharp.Compiler.Text.RangeModule: FSharp.Compiler.Text.Range get_rangeStartup()
+FSharp.Compiler.Text.RangeModule: FSharp.Compiler.Text.Range mkFileIndexRange(Int32, FSharp.Compiler.Text.Position, FSharp.Compiler.Text.Position)
+FSharp.Compiler.Text.RangeModule: FSharp.Compiler.Text.Range mkFirstLineOfFile(System.String)
+FSharp.Compiler.Text.RangeModule: FSharp.Compiler.Text.Range mkRange(System.String, FSharp.Compiler.Text.Position, FSharp.Compiler.Text.Position)
+FSharp.Compiler.Text.RangeModule: FSharp.Compiler.Text.Range range0
+FSharp.Compiler.Text.RangeModule: FSharp.Compiler.Text.Range rangeCmdArgs
+FSharp.Compiler.Text.RangeModule: FSharp.Compiler.Text.Range rangeN(System.String, Int32)
+FSharp.Compiler.Text.RangeModule: FSharp.Compiler.Text.Range rangeStartup
+FSharp.Compiler.Text.RangeModule: FSharp.Compiler.Text.Range trimRangeToLine(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Text.RangeModule: FSharp.Compiler.Text.Range unionRanges(FSharp.Compiler.Text.Range, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Text.RangeModule: System.Collections.Generic.IComparer`1[FSharp.Compiler.Text.Position] get_posOrder()
+FSharp.Compiler.Text.RangeModule: System.Collections.Generic.IComparer`1[FSharp.Compiler.Text.Position] posOrder
+FSharp.Compiler.Text.RangeModule: System.Collections.Generic.IComparer`1[FSharp.Compiler.Text.Range] get_rangeOrder()
+FSharp.Compiler.Text.RangeModule: System.Collections.Generic.IComparer`1[FSharp.Compiler.Text.Range] rangeOrder
+FSharp.Compiler.Text.RangeModule: System.Collections.Generic.IEqualityComparer`1[FSharp.Compiler.Text.Range] comparer
+FSharp.Compiler.Text.RangeModule: System.Collections.Generic.IEqualityComparer`1[FSharp.Compiler.Text.Range] get_comparer()
+FSharp.Compiler.Text.RangeModule: System.String stringOfRange(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Text.RangeModule: System.Tuple`2[System.String,System.Tuple`2[System.Tuple`2[System.Int32,System.Int32],System.Tuple`2[System.Int32,System.Int32]]] toFileZ(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Text.RangeModule: System.Tuple`2[System.Tuple`2[System.Int32,System.Int32],System.Tuple`2[System.Int32,System.Int32]] toZ(FSharp.Compiler.Text.Range)
+FSharp.Compiler.Text.RangeModule: Void outputRange(System.IO.TextWriter, FSharp.Compiler.Text.Range)
+FSharp.Compiler.Text.SourceText: FSharp.Compiler.Text.ISourceText ofString(System.String)
+FSharp.Compiler.Text.TaggedText: FSharp.Compiler.Text.TextTag Tag
+FSharp.Compiler.Text.TaggedText: FSharp.Compiler.Text.TextTag get_Tag()
+FSharp.Compiler.Text.TaggedText: System.String Text
+FSharp.Compiler.Text.TaggedText: System.String ToString()
+FSharp.Compiler.Text.TaggedText: System.String get_Text()
+FSharp.Compiler.Text.TaggedText: Void .ctor(FSharp.Compiler.Text.TextTag, System.String)
+FSharp.Compiler.Text.TaggedTextModule: FSharp.Compiler.Text.TaggedText colon
+FSharp.Compiler.Text.TaggedTextModule: FSharp.Compiler.Text.TaggedText comma
+FSharp.Compiler.Text.TaggedTextModule: FSharp.Compiler.Text.TaggedText dot
+FSharp.Compiler.Text.TaggedTextModule: FSharp.Compiler.Text.TaggedText get_colon()
+FSharp.Compiler.Text.TaggedTextModule: FSharp.Compiler.Text.TaggedText get_comma()
+FSharp.Compiler.Text.TaggedTextModule: FSharp.Compiler.Text.TaggedText get_dot()
+FSharp.Compiler.Text.TaggedTextModule: FSharp.Compiler.Text.TaggedText get_lineBreak()
+FSharp.Compiler.Text.TaggedTextModule: FSharp.Compiler.Text.TaggedText get_minus()
+FSharp.Compiler.Text.TaggedTextModule: FSharp.Compiler.Text.TaggedText get_space()
+FSharp.Compiler.Text.TaggedTextModule: FSharp.Compiler.Text.TaggedText lineBreak
+FSharp.Compiler.Text.TaggedTextModule: FSharp.Compiler.Text.TaggedText minus
+FSharp.Compiler.Text.TaggedTextModule: FSharp.Compiler.Text.TaggedText space
+FSharp.Compiler.Text.TaggedTextModule: FSharp.Compiler.Text.TaggedText tagClass(System.String)
+FSharp.Compiler.Text.TaggedTextModule: FSharp.Compiler.Text.TaggedText tagNamespace(System.String)
+FSharp.Compiler.Text.TaggedTextModule: FSharp.Compiler.Text.TaggedText tagParameter(System.String)
+FSharp.Compiler.Text.TaggedTextModule: FSharp.Compiler.Text.TaggedText tagSpace(System.String)
+FSharp.Compiler.Text.TaggedTextModule: FSharp.Compiler.Text.TaggedText tagText(System.String)
+FSharp.Compiler.Text.TextTag+Tags: Int32 ActivePatternCase
+FSharp.Compiler.Text.TextTag+Tags: Int32 ActivePatternResult
+FSharp.Compiler.Text.TextTag+Tags: Int32 Alias
+FSharp.Compiler.Text.TextTag+Tags: Int32 Class
+FSharp.Compiler.Text.TextTag+Tags: Int32 Delegate
+FSharp.Compiler.Text.TextTag+Tags: Int32 Enum
+FSharp.Compiler.Text.TextTag+Tags: Int32 Event
+FSharp.Compiler.Text.TextTag+Tags: Int32 Field
+FSharp.Compiler.Text.TextTag+Tags: Int32 Function
+FSharp.Compiler.Text.TextTag+Tags: Int32 Interface
+FSharp.Compiler.Text.TextTag+Tags: Int32 Keyword
+FSharp.Compiler.Text.TextTag+Tags: Int32 LineBreak
+FSharp.Compiler.Text.TextTag+Tags: Int32 Local
+FSharp.Compiler.Text.TextTag+Tags: Int32 Member
+FSharp.Compiler.Text.TextTag+Tags: Int32 Method
+FSharp.Compiler.Text.TextTag+Tags: Int32 Module
+FSharp.Compiler.Text.TextTag+Tags: Int32 ModuleBinding
+FSharp.Compiler.Text.TextTag+Tags: Int32 Namespace
+FSharp.Compiler.Text.TextTag+Tags: Int32 NumericLiteral
+FSharp.Compiler.Text.TextTag+Tags: Int32 Operator
+FSharp.Compiler.Text.TextTag+Tags: Int32 Parameter
+FSharp.Compiler.Text.TextTag+Tags: Int32 Property
+FSharp.Compiler.Text.TextTag+Tags: Int32 Punctuation
+FSharp.Compiler.Text.TextTag+Tags: Int32 Record
+FSharp.Compiler.Text.TextTag+Tags: Int32 RecordField
+FSharp.Compiler.Text.TextTag+Tags: Int32 Space
+FSharp.Compiler.Text.TextTag+Tags: Int32 StringLiteral
+FSharp.Compiler.Text.TextTag+Tags: Int32 Struct
+FSharp.Compiler.Text.TextTag+Tags: Int32 Text
+FSharp.Compiler.Text.TextTag+Tags: Int32 TypeParameter
+FSharp.Compiler.Text.TextTag+Tags: Int32 Union
+FSharp.Compiler.Text.TextTag+Tags: Int32 UnionCase
+FSharp.Compiler.Text.TextTag+Tags: Int32 UnknownEntity
+FSharp.Compiler.Text.TextTag+Tags: Int32 UnknownType
+FSharp.Compiler.Text.TextTag: Boolean Equals(FSharp.Compiler.Text.TextTag)
+FSharp.Compiler.Text.TextTag: Boolean Equals(System.Object)
+FSharp.Compiler.Text.TextTag: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Text.TextTag: Boolean IsActivePatternCase
+FSharp.Compiler.Text.TextTag: Boolean IsActivePatternResult
+FSharp.Compiler.Text.TextTag: Boolean IsAlias
+FSharp.Compiler.Text.TextTag: Boolean IsClass
+FSharp.Compiler.Text.TextTag: Boolean IsDelegate
+FSharp.Compiler.Text.TextTag: Boolean IsEnum
+FSharp.Compiler.Text.TextTag: Boolean IsEvent
+FSharp.Compiler.Text.TextTag: Boolean IsField
+FSharp.Compiler.Text.TextTag: Boolean IsFunction
+FSharp.Compiler.Text.TextTag: Boolean IsInterface
+FSharp.Compiler.Text.TextTag: Boolean IsKeyword
+FSharp.Compiler.Text.TextTag: Boolean IsLineBreak
+FSharp.Compiler.Text.TextTag: Boolean IsLocal
+FSharp.Compiler.Text.TextTag: Boolean IsMember
+FSharp.Compiler.Text.TextTag: Boolean IsMethod
+FSharp.Compiler.Text.TextTag: Boolean IsModule
+FSharp.Compiler.Text.TextTag: Boolean IsModuleBinding
+FSharp.Compiler.Text.TextTag: Boolean IsNamespace
+FSharp.Compiler.Text.TextTag: Boolean IsNumericLiteral
+FSharp.Compiler.Text.TextTag: Boolean IsOperator
+FSharp.Compiler.Text.TextTag: Boolean IsParameter
+FSharp.Compiler.Text.TextTag: Boolean IsProperty
+FSharp.Compiler.Text.TextTag: Boolean IsPunctuation
+FSharp.Compiler.Text.TextTag: Boolean IsRecord
+FSharp.Compiler.Text.TextTag: Boolean IsRecordField
+FSharp.Compiler.Text.TextTag: Boolean IsSpace
+FSharp.Compiler.Text.TextTag: Boolean IsStringLiteral
+FSharp.Compiler.Text.TextTag: Boolean IsStruct
+FSharp.Compiler.Text.TextTag: Boolean IsText
+FSharp.Compiler.Text.TextTag: Boolean IsTypeParameter
+FSharp.Compiler.Text.TextTag: Boolean IsUnion
+FSharp.Compiler.Text.TextTag: Boolean IsUnionCase
+FSharp.Compiler.Text.TextTag: Boolean IsUnknownEntity
+FSharp.Compiler.Text.TextTag: Boolean IsUnknownType
+FSharp.Compiler.Text.TextTag: Boolean get_IsActivePatternCase()
+FSharp.Compiler.Text.TextTag: Boolean get_IsActivePatternResult()
+FSharp.Compiler.Text.TextTag: Boolean get_IsAlias()
+FSharp.Compiler.Text.TextTag: Boolean get_IsClass()
+FSharp.Compiler.Text.TextTag: Boolean get_IsDelegate()
+FSharp.Compiler.Text.TextTag: Boolean get_IsEnum()
+FSharp.Compiler.Text.TextTag: Boolean get_IsEvent()
+FSharp.Compiler.Text.TextTag: Boolean get_IsField()
+FSharp.Compiler.Text.TextTag: Boolean get_IsFunction()
+FSharp.Compiler.Text.TextTag: Boolean get_IsInterface()
+FSharp.Compiler.Text.TextTag: Boolean get_IsKeyword()
+FSharp.Compiler.Text.TextTag: Boolean get_IsLineBreak()
+FSharp.Compiler.Text.TextTag: Boolean get_IsLocal()
+FSharp.Compiler.Text.TextTag: Boolean get_IsMember()
+FSharp.Compiler.Text.TextTag: Boolean get_IsMethod()
+FSharp.Compiler.Text.TextTag: Boolean get_IsModule()
+FSharp.Compiler.Text.TextTag: Boolean get_IsModuleBinding()
+FSharp.Compiler.Text.TextTag: Boolean get_IsNamespace()
+FSharp.Compiler.Text.TextTag: Boolean get_IsNumericLiteral()
+FSharp.Compiler.Text.TextTag: Boolean get_IsOperator()
+FSharp.Compiler.Text.TextTag: Boolean get_IsParameter()
+FSharp.Compiler.Text.TextTag: Boolean get_IsProperty()
+FSharp.Compiler.Text.TextTag: Boolean get_IsPunctuation()
+FSharp.Compiler.Text.TextTag: Boolean get_IsRecord()
+FSharp.Compiler.Text.TextTag: Boolean get_IsRecordField()
+FSharp.Compiler.Text.TextTag: Boolean get_IsSpace()
+FSharp.Compiler.Text.TextTag: Boolean get_IsStringLiteral()
+FSharp.Compiler.Text.TextTag: Boolean get_IsStruct()
+FSharp.Compiler.Text.TextTag: Boolean get_IsText()
+FSharp.Compiler.Text.TextTag: Boolean get_IsTypeParameter()
+FSharp.Compiler.Text.TextTag: Boolean get_IsUnion()
+FSharp.Compiler.Text.TextTag: Boolean get_IsUnionCase()
+FSharp.Compiler.Text.TextTag: Boolean get_IsUnknownEntity()
+FSharp.Compiler.Text.TextTag: Boolean get_IsUnknownType()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag ActivePatternCase
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag ActivePatternResult
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag Alias
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag Class
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag Delegate
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag Enum
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag Event
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag Field
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag Function
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag Interface
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag Keyword
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag LineBreak
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag Local
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag Member
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag Method
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag Module
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag ModuleBinding
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag Namespace
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag NumericLiteral
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag Operator
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag Parameter
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag Property
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag Punctuation
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag Record
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag RecordField
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag Space
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag StringLiteral
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag Struct
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag Text
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag TypeParameter
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag Union
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag UnionCase
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag UnknownEntity
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag UnknownType
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_ActivePatternCase()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_ActivePatternResult()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_Alias()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_Class()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_Delegate()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_Enum()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_Event()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_Field()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_Function()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_Interface()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_Keyword()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_LineBreak()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_Local()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_Member()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_Method()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_Module()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_ModuleBinding()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_Namespace()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_NumericLiteral()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_Operator()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_Parameter()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_Property()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_Punctuation()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_Record()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_RecordField()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_Space()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_StringLiteral()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_Struct()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_Text()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_TypeParameter()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_Union()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_UnionCase()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_UnknownEntity()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag get_UnknownType()
+FSharp.Compiler.Text.TextTag: FSharp.Compiler.Text.TextTag+Tags
+FSharp.Compiler.Text.TextTag: Int32 GetHashCode()
+FSharp.Compiler.Text.TextTag: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Text.TextTag: Int32 Tag
+FSharp.Compiler.Text.TextTag: Int32 get_Tag()
+FSharp.Compiler.Text.TextTag: System.String ToString()
+FSharp.Compiler.Tokenization.FSharpKeywords: Microsoft.FSharp.Collections.FSharpList`1[System.String] KeywordNames
+FSharp.Compiler.Tokenization.FSharpKeywords: Microsoft.FSharp.Collections.FSharpList`1[System.String] get_KeywordNames()
+FSharp.Compiler.Tokenization.FSharpKeywords: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[System.String,System.String]] KeywordsWithDescription
+FSharp.Compiler.Tokenization.FSharpKeywords: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[System.String,System.String]] get_KeywordsWithDescription()
+FSharp.Compiler.Tokenization.FSharpKeywords: System.String NormalizeIdentifierBackticks(System.String)
+FSharp.Compiler.Tokenization.FSharpLexer: Void Tokenize(FSharp.Compiler.Text.ISourceText, Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.Tokenization.FSharpToken,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.String], Microsoft.FSharp.Core.FSharpOption`1[System.String], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[System.String]], Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Tokenization.FSharpLexerFlags], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpMap`2[System.String,System.String]], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+FSharp.Compiler.Tokenization.FSharpLexerFlags: FSharp.Compiler.Tokenization.FSharpLexerFlags Compiling
+FSharp.Compiler.Tokenization.FSharpLexerFlags: FSharp.Compiler.Tokenization.FSharpLexerFlags CompilingFSharpCore
+FSharp.Compiler.Tokenization.FSharpLexerFlags: FSharp.Compiler.Tokenization.FSharpLexerFlags Default
+FSharp.Compiler.Tokenization.FSharpLexerFlags: FSharp.Compiler.Tokenization.FSharpLexerFlags LightSyntaxOn
+FSharp.Compiler.Tokenization.FSharpLexerFlags: FSharp.Compiler.Tokenization.FSharpLexerFlags SkipTrivia
+FSharp.Compiler.Tokenization.FSharpLexerFlags: FSharp.Compiler.Tokenization.FSharpLexerFlags UseLexFilter
+FSharp.Compiler.Tokenization.FSharpLexerFlags: Int32 value__
+FSharp.Compiler.Tokenization.FSharpLineTokenizer: FSharp.Compiler.Tokenization.FSharpTokenizerColorState ColorStateOfLexState(FSharp.Compiler.Tokenization.FSharpTokenizerLexState)
+FSharp.Compiler.Tokenization.FSharpLineTokenizer: FSharp.Compiler.Tokenization.FSharpTokenizerLexState LexStateOfColorState(FSharp.Compiler.Tokenization.FSharpTokenizerColorState)
+FSharp.Compiler.Tokenization.FSharpLineTokenizer: System.Tuple`2[Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.Tokenization.FSharpTokenInfo],FSharp.Compiler.Tokenization.FSharpTokenizerLexState] ScanToken(FSharp.Compiler.Tokenization.FSharpTokenizerLexState)
+FSharp.Compiler.Tokenization.FSharpSourceTokenizer: FSharp.Compiler.Tokenization.FSharpLineTokenizer CreateBufferTokenizer(Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[System.Char[],System.Int32,System.Int32],System.Int32])
+FSharp.Compiler.Tokenization.FSharpSourceTokenizer: FSharp.Compiler.Tokenization.FSharpLineTokenizer CreateLineTokenizer(System.String)
+FSharp.Compiler.Tokenization.FSharpSourceTokenizer: Void .ctor(Microsoft.FSharp.Collections.FSharpList`1[System.String], Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.Tokenization.FSharpToken: Boolean IsCommentTrivia
+FSharp.Compiler.Tokenization.FSharpToken: Boolean IsIdentifier
+FSharp.Compiler.Tokenization.FSharpToken: Boolean IsKeyword
+FSharp.Compiler.Tokenization.FSharpToken: Boolean IsNumericLiteral
+FSharp.Compiler.Tokenization.FSharpToken: Boolean IsStringLiteral
+FSharp.Compiler.Tokenization.FSharpToken: Boolean get_IsCommentTrivia()
+FSharp.Compiler.Tokenization.FSharpToken: Boolean get_IsIdentifier()
+FSharp.Compiler.Tokenization.FSharpToken: Boolean get_IsKeyword()
+FSharp.Compiler.Tokenization.FSharpToken: Boolean get_IsNumericLiteral()
+FSharp.Compiler.Tokenization.FSharpToken: Boolean get_IsStringLiteral()
+FSharp.Compiler.Tokenization.FSharpToken: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Tokenization.FSharpToken: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Tokenization.FSharpToken: FSharp.Compiler.Tokenization.FSharpTokenKind Kind
+FSharp.Compiler.Tokenization.FSharpToken: FSharp.Compiler.Tokenization.FSharpTokenKind get_Kind()
+FSharp.Compiler.Tokenization.FSharpTokenCharKind: FSharp.Compiler.Tokenization.FSharpTokenCharKind Comment
+FSharp.Compiler.Tokenization.FSharpTokenCharKind: FSharp.Compiler.Tokenization.FSharpTokenCharKind Default
+FSharp.Compiler.Tokenization.FSharpTokenCharKind: FSharp.Compiler.Tokenization.FSharpTokenCharKind Delimiter
+FSharp.Compiler.Tokenization.FSharpTokenCharKind: FSharp.Compiler.Tokenization.FSharpTokenCharKind Identifier
+FSharp.Compiler.Tokenization.FSharpTokenCharKind: FSharp.Compiler.Tokenization.FSharpTokenCharKind Keyword
+FSharp.Compiler.Tokenization.FSharpTokenCharKind: FSharp.Compiler.Tokenization.FSharpTokenCharKind LineComment
+FSharp.Compiler.Tokenization.FSharpTokenCharKind: FSharp.Compiler.Tokenization.FSharpTokenCharKind Literal
+FSharp.Compiler.Tokenization.FSharpTokenCharKind: FSharp.Compiler.Tokenization.FSharpTokenCharKind Operator
+FSharp.Compiler.Tokenization.FSharpTokenCharKind: FSharp.Compiler.Tokenization.FSharpTokenCharKind String
+FSharp.Compiler.Tokenization.FSharpTokenCharKind: FSharp.Compiler.Tokenization.FSharpTokenCharKind Text
+FSharp.Compiler.Tokenization.FSharpTokenCharKind: FSharp.Compiler.Tokenization.FSharpTokenCharKind WhiteSpace
+FSharp.Compiler.Tokenization.FSharpTokenCharKind: Int32 value__
+FSharp.Compiler.Tokenization.FSharpTokenColorKind: FSharp.Compiler.Tokenization.FSharpTokenColorKind Comment
+FSharp.Compiler.Tokenization.FSharpTokenColorKind: FSharp.Compiler.Tokenization.FSharpTokenColorKind Default
+FSharp.Compiler.Tokenization.FSharpTokenColorKind: FSharp.Compiler.Tokenization.FSharpTokenColorKind Identifier
+FSharp.Compiler.Tokenization.FSharpTokenColorKind: FSharp.Compiler.Tokenization.FSharpTokenColorKind InactiveCode
+FSharp.Compiler.Tokenization.FSharpTokenColorKind: FSharp.Compiler.Tokenization.FSharpTokenColorKind Keyword
+FSharp.Compiler.Tokenization.FSharpTokenColorKind: FSharp.Compiler.Tokenization.FSharpTokenColorKind Number
+FSharp.Compiler.Tokenization.FSharpTokenColorKind: FSharp.Compiler.Tokenization.FSharpTokenColorKind Operator
+FSharp.Compiler.Tokenization.FSharpTokenColorKind: FSharp.Compiler.Tokenization.FSharpTokenColorKind PreprocessorKeyword
+FSharp.Compiler.Tokenization.FSharpTokenColorKind: FSharp.Compiler.Tokenization.FSharpTokenColorKind Punctuation
+FSharp.Compiler.Tokenization.FSharpTokenColorKind: FSharp.Compiler.Tokenization.FSharpTokenColorKind String
+FSharp.Compiler.Tokenization.FSharpTokenColorKind: FSharp.Compiler.Tokenization.FSharpTokenColorKind Text
+FSharp.Compiler.Tokenization.FSharpTokenColorKind: FSharp.Compiler.Tokenization.FSharpTokenColorKind UpperIdentifier
+FSharp.Compiler.Tokenization.FSharpTokenColorKind: Int32 value__
+FSharp.Compiler.Tokenization.FSharpTokenInfo: Boolean Equals(FSharp.Compiler.Tokenization.FSharpTokenInfo)
+FSharp.Compiler.Tokenization.FSharpTokenInfo: Boolean Equals(System.Object)
+FSharp.Compiler.Tokenization.FSharpTokenInfo: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Tokenization.FSharpTokenInfo: FSharp.Compiler.Tokenization.FSharpTokenCharKind CharClass
+FSharp.Compiler.Tokenization.FSharpTokenInfo: FSharp.Compiler.Tokenization.FSharpTokenCharKind get_CharClass()
+FSharp.Compiler.Tokenization.FSharpTokenInfo: FSharp.Compiler.Tokenization.FSharpTokenColorKind ColorClass
+FSharp.Compiler.Tokenization.FSharpTokenInfo: FSharp.Compiler.Tokenization.FSharpTokenColorKind get_ColorClass()
+FSharp.Compiler.Tokenization.FSharpTokenInfo: FSharp.Compiler.Tokenization.FSharpTokenTriggerClass FSharpTokenTriggerClass
+FSharp.Compiler.Tokenization.FSharpTokenInfo: FSharp.Compiler.Tokenization.FSharpTokenTriggerClass get_FSharpTokenTriggerClass()
+FSharp.Compiler.Tokenization.FSharpTokenInfo: Int32 CompareTo(FSharp.Compiler.Tokenization.FSharpTokenInfo)
+FSharp.Compiler.Tokenization.FSharpTokenInfo: Int32 CompareTo(System.Object)
+FSharp.Compiler.Tokenization.FSharpTokenInfo: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.Tokenization.FSharpTokenInfo: Int32 FullMatchedLength
+FSharp.Compiler.Tokenization.FSharpTokenInfo: Int32 GetHashCode()
+FSharp.Compiler.Tokenization.FSharpTokenInfo: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Tokenization.FSharpTokenInfo: Int32 LeftColumn
+FSharp.Compiler.Tokenization.FSharpTokenInfo: Int32 RightColumn
+FSharp.Compiler.Tokenization.FSharpTokenInfo: Int32 Tag
+FSharp.Compiler.Tokenization.FSharpTokenInfo: Int32 get_FullMatchedLength()
+FSharp.Compiler.Tokenization.FSharpTokenInfo: Int32 get_LeftColumn()
+FSharp.Compiler.Tokenization.FSharpTokenInfo: Int32 get_RightColumn()
+FSharp.Compiler.Tokenization.FSharpTokenInfo: Int32 get_Tag()
+FSharp.Compiler.Tokenization.FSharpTokenInfo: System.String ToString()
+FSharp.Compiler.Tokenization.FSharpTokenInfo: System.String TokenName
+FSharp.Compiler.Tokenization.FSharpTokenInfo: System.String get_TokenName()
+FSharp.Compiler.Tokenization.FSharpTokenInfo: Void .ctor(Int32, Int32, FSharp.Compiler.Tokenization.FSharpTokenColorKind, FSharp.Compiler.Tokenization.FSharpTokenCharKind, FSharp.Compiler.Tokenization.FSharpTokenTriggerClass, Int32, System.String, Int32)
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Abstract
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 AdjacentPrefixOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Ampersand
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 AmpersandAmpersand
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 And
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 As
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Asr
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Assert
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Bar
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 BarBar
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 BarRightBrace
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 BarRightBracket
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Base
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Begin
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 BigNumber
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Binder
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 ByteArray
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Char
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Class
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Colon
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 ColonColon
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 ColonEquals
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 ColonGreater
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 ColonQuestionMark
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 ColonQuestionMarkGreater
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Comma
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 CommentTrivia
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Const
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Constraint
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Constructor
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Decimal
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Default
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Delegate
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Do
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 DoBang
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Dollar
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Done
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Dot
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 DotDot
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 DotDotHat
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 DownTo
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Downcast
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Elif
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Else
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 End
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Equals
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Exception
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Extern
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 False
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Finally
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Fixed
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 For
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Fun
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Function
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 FunkyOperatorName
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Global
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Greater
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 GreaterBarRightBracket
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 GreaterRightBracket
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Hash
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 HashElse
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 HashEndIf
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 HashIf
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 HashLight
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 HashLine
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 HighPrecedenceBracketApp
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 HighPrecedenceParenthesisApp
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 HighPrecedenceTypeApp
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Identifier
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Ieee32
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Ieee64
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 If
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 In
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 InactiveCode
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 InfixAmpersandOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 InfixAsr
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 InfixAtHatOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 InfixBarOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 InfixCompareOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 InfixLand
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 InfixLor
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 InfixLsl
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 InfixLsr
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 InfixLxor
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 InfixMod
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 InfixStarDivideModuloOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 InfixStarStarOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Inherit
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Inline
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Instance
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Int16
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Int32
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Int32DotDot
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Int64
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Int8
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Interface
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Internal
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 JoinIn
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 KeywordString
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Lazy
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 LeftArrow
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 LeftBrace
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 LeftBraceBar
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 LeftBracket
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 LeftBracketBar
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 LeftBracketLess
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 LeftParenthesis
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 LeftParenthesisStarRightParenthesis
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 LeftQuote
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Less
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Let
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 LineCommentTrivia
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Match
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 MatchBang
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Member
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Minus
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Module
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Mutable
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Namespace
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 NativeInt
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 New
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 None
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Null
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Of
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 OffsideAssert
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 OffsideBinder
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 OffsideBlockBegin
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 OffsideBlockEnd
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 OffsideBlockSep
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 OffsideDeclEnd
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 OffsideDo
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 OffsideDoBang
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 OffsideElse
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 OffsideEnd
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 OffsideFun
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 OffsideFunction
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 OffsideInterfaceMember
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 OffsideLazy
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 OffsideLet
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 OffsideReset
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 OffsideRightBlockEnd
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 OffsideThen
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 OffsideWith
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Open
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Or
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Override
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 PercentOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 PlusMinusOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 PrefixOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Private
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Public
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 QuestionMark
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 QuestionMarkQuestionMark
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Quote
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Rec
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Reserved
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 RightArrow
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 RightBrace
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 RightBracket
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 RightParenthesis
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 RightQuote
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 RightQuoteDot
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Semicolon
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 SemicolonSemicolon
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Sig
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Star
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Static
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 String
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 StringText
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Struct
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Then
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 To
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 True
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Try
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Type
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 UInt16
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 UInt32
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 UInt64
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 UInt8
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 UNativeInt
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Underscore
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Upcast
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Val
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Void
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 When
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 While
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 WhitespaceTrivia
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 With
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 Yield
+FSharp.Compiler.Tokenization.FSharpTokenKind+Tags: Int32 YieldBang
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean Equals(FSharp.Compiler.Tokenization.FSharpTokenKind)
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean Equals(System.Object)
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsAbstract
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsAdjacentPrefixOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsAmpersand
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsAmpersandAmpersand
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsAnd
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsAs
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsAsr
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsAssert
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsBar
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsBarBar
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsBarRightBrace
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsBarRightBracket
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsBase
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsBegin
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsBigNumber
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsBinder
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsByteArray
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsChar
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsClass
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsColon
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsColonColon
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsColonEquals
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsColonGreater
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsColonQuestionMark
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsColonQuestionMarkGreater
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsComma
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsCommentTrivia
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsConst
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsConstraint
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsConstructor
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsDecimal
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsDefault
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsDelegate
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsDo
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsDoBang
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsDollar
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsDone
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsDot
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsDotDot
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsDotDotHat
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsDownTo
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsDowncast
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsElif
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsElse
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsEnd
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsEquals
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsException
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsExtern
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsFalse
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsFinally
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsFixed
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsFor
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsFun
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsFunction
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsFunkyOperatorName
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsGlobal
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsGreater
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsGreaterBarRightBracket
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsGreaterRightBracket
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsHash
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsHashElse
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsHashEndIf
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsHashIf
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsHashLight
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsHashLine
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsHighPrecedenceBracketApp
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsHighPrecedenceParenthesisApp
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsHighPrecedenceTypeApp
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsIdentifier
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsIeee32
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsIeee64
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsIf
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsIn
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsInactiveCode
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsInfixAmpersandOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsInfixAsr
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsInfixAtHatOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsInfixBarOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsInfixCompareOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsInfixLand
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsInfixLor
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsInfixLsl
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsInfixLsr
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsInfixLxor
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsInfixMod
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsInfixStarDivideModuloOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsInfixStarStarOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsInherit
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsInline
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsInstance
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsInt16
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsInt32
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsInt32DotDot
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsInt64
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsInt8
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsInterface
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsInternal
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsJoinIn
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsKeywordString
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsLazy
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsLeftArrow
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsLeftBrace
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsLeftBraceBar
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsLeftBracket
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsLeftBracketBar
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsLeftBracketLess
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsLeftParenthesis
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsLeftParenthesisStarRightParenthesis
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsLeftQuote
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsLess
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsLet
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsLineCommentTrivia
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsMatch
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsMatchBang
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsMember
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsMinus
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsModule
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsMutable
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsNamespace
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsNativeInt
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsNew
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsNone
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsNull
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsOf
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsOffsideAssert
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsOffsideBinder
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsOffsideBlockBegin
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsOffsideBlockEnd
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsOffsideBlockSep
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsOffsideDeclEnd
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsOffsideDo
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsOffsideDoBang
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsOffsideElse
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsOffsideEnd
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsOffsideFun
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsOffsideFunction
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsOffsideInterfaceMember
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsOffsideLazy
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsOffsideLet
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsOffsideReset
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsOffsideRightBlockEnd
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsOffsideThen
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsOffsideWith
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsOpen
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsOr
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsOverride
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsPercentOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsPlusMinusOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsPrefixOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsPrivate
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsPublic
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsQuestionMark
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsQuestionMarkQuestionMark
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsQuote
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsRec
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsReserved
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsRightArrow
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsRightBrace
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsRightBracket
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsRightParenthesis
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsRightQuote
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsRightQuoteDot
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsSemicolon
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsSemicolonSemicolon
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsSig
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsStar
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsStatic
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsString
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsStringText
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsStruct
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsThen
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsTo
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsTrue
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsTry
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsType
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsUInt16
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsUInt32
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsUInt64
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsUInt8
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsUNativeInt
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsUnderscore
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsUpcast
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsVal
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsVoid
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsWhen
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsWhile
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsWhitespaceTrivia
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsWith
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsYield
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean IsYieldBang
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsAbstract()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsAdjacentPrefixOperator()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsAmpersand()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsAmpersandAmpersand()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsAnd()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsAs()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsAsr()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsAssert()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsBar()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsBarBar()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsBarRightBrace()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsBarRightBracket()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsBase()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsBegin()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsBigNumber()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsBinder()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsByteArray()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsChar()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsClass()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsColon()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsColonColon()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsColonEquals()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsColonGreater()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsColonQuestionMark()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsColonQuestionMarkGreater()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsComma()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsCommentTrivia()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsConst()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsConstraint()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsConstructor()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsDecimal()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsDefault()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsDelegate()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsDo()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsDoBang()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsDollar()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsDone()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsDot()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsDotDot()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsDotDotHat()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsDownTo()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsDowncast()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsElif()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsElse()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsEnd()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsEquals()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsException()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsExtern()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsFalse()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsFinally()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsFixed()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsFor()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsFun()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsFunction()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsFunkyOperatorName()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsGlobal()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsGreater()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsGreaterBarRightBracket()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsGreaterRightBracket()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsHash()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsHashElse()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsHashEndIf()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsHashIf()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsHashLight()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsHashLine()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsHighPrecedenceBracketApp()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsHighPrecedenceParenthesisApp()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsHighPrecedenceTypeApp()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsIdentifier()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsIeee32()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsIeee64()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsIf()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsIn()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsInactiveCode()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsInfixAmpersandOperator()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsInfixAsr()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsInfixAtHatOperator()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsInfixBarOperator()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsInfixCompareOperator()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsInfixLand()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsInfixLor()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsInfixLsl()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsInfixLsr()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsInfixLxor()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsInfixMod()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsInfixStarDivideModuloOperator()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsInfixStarStarOperator()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsInherit()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsInline()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsInstance()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsInt16()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsInt32()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsInt32DotDot()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsInt64()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsInt8()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsInterface()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsInternal()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsJoinIn()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsKeywordString()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsLazy()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsLeftArrow()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsLeftBrace()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsLeftBraceBar()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsLeftBracket()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsLeftBracketBar()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsLeftBracketLess()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsLeftParenthesis()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsLeftParenthesisStarRightParenthesis()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsLeftQuote()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsLess()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsLet()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsLineCommentTrivia()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsMatch()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsMatchBang()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsMember()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsMinus()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsModule()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsMutable()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsNamespace()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsNativeInt()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsNew()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsNone()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsNull()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsOf()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsOffsideAssert()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsOffsideBinder()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsOffsideBlockBegin()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsOffsideBlockEnd()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsOffsideBlockSep()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsOffsideDeclEnd()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsOffsideDo()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsOffsideDoBang()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsOffsideElse()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsOffsideEnd()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsOffsideFun()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsOffsideFunction()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsOffsideInterfaceMember()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsOffsideLazy()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsOffsideLet()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsOffsideReset()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsOffsideRightBlockEnd()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsOffsideThen()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsOffsideWith()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsOpen()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsOr()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsOverride()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsPercentOperator()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsPlusMinusOperator()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsPrefixOperator()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsPrivate()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsPublic()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsQuestionMark()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsQuestionMarkQuestionMark()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsQuote()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsRec()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsReserved()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsRightArrow()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsRightBrace()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsRightBracket()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsRightParenthesis()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsRightQuote()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsRightQuoteDot()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsSemicolon()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsSemicolonSemicolon()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsSig()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsStar()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsStatic()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsString()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsStringText()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsStruct()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsThen()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsTo()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsTrue()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsTry()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsType()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsUInt16()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsUInt32()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsUInt64()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsUInt8()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsUNativeInt()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsUnderscore()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsUpcast()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsVal()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsVoid()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsWhen()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsWhile()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsWhitespaceTrivia()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsWith()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsYield()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Boolean get_IsYieldBang()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Abstract
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind AdjacentPrefixOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Ampersand
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind AmpersandAmpersand
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind And
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind As
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Asr
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Assert
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Bar
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind BarBar
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind BarRightBrace
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind BarRightBracket
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Base
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Begin
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind BigNumber
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Binder
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind ByteArray
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Char
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Class
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Colon
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind ColonColon
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind ColonEquals
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind ColonGreater
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind ColonQuestionMark
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind ColonQuestionMarkGreater
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Comma
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind CommentTrivia
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Const
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Constraint
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Constructor
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Decimal
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Default
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Delegate
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Do
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind DoBang
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Dollar
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Done
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Dot
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind DotDot
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind DotDotHat
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind DownTo
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Downcast
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Elif
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Else
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind End
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Equals
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Exception
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Extern
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind False
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Finally
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Fixed
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind For
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Fun
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Function
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind FunkyOperatorName
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Global
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Greater
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind GreaterBarRightBracket
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind GreaterRightBracket
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Hash
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind HashElse
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind HashEndIf
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind HashIf
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind HashLight
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind HashLine
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind HighPrecedenceBracketApp
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind HighPrecedenceParenthesisApp
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind HighPrecedenceTypeApp
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Identifier
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Ieee32
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Ieee64
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind If
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind In
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind InactiveCode
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind InfixAmpersandOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind InfixAsr
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind InfixAtHatOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind InfixBarOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind InfixCompareOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind InfixLand
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind InfixLor
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind InfixLsl
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind InfixLsr
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind InfixLxor
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind InfixMod
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind InfixStarDivideModuloOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind InfixStarStarOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Inherit
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Inline
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Instance
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Int16
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Int32
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Int32DotDot
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Int64
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Int8
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Interface
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Internal
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind JoinIn
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind KeywordString
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Lazy
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind LeftArrow
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind LeftBrace
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind LeftBraceBar
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind LeftBracket
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind LeftBracketBar
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind LeftBracketLess
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind LeftParenthesis
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind LeftParenthesisStarRightParenthesis
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind LeftQuote
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Less
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Let
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind LineCommentTrivia
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Match
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind MatchBang
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Member
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Minus
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Module
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Mutable
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Namespace
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind NativeInt
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind New
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind None
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Null
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Of
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind OffsideAssert
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind OffsideBinder
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind OffsideBlockBegin
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind OffsideBlockEnd
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind OffsideBlockSep
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind OffsideDeclEnd
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind OffsideDo
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind OffsideDoBang
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind OffsideElse
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind OffsideEnd
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind OffsideFun
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind OffsideFunction
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind OffsideInterfaceMember
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind OffsideLazy
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind OffsideLet
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind OffsideReset
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind OffsideRightBlockEnd
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind OffsideThen
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind OffsideWith
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Open
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Or
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Override
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind PercentOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind PlusMinusOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind PrefixOperator
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Private
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Public
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind QuestionMark
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind QuestionMarkQuestionMark
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Quote
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Rec
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Reserved
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind RightArrow
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind RightBrace
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind RightBracket
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind RightParenthesis
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind RightQuote
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind RightQuoteDot
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Semicolon
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind SemicolonSemicolon
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Sig
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Star
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Static
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind String
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind StringText
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Struct
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Then
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind To
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind True
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Try
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Type
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind UInt16
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind UInt32
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind UInt64
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind UInt8
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind UNativeInt
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Underscore
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Upcast
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Val
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Void
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind When
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind While
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind WhitespaceTrivia
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind With
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind Yield
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind YieldBang
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Abstract()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_AdjacentPrefixOperator()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Ampersand()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_AmpersandAmpersand()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_And()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_As()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Asr()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Assert()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Bar()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_BarBar()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_BarRightBrace()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_BarRightBracket()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Base()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Begin()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_BigNumber()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Binder()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_ByteArray()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Char()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Class()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Colon()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_ColonColon()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_ColonEquals()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_ColonGreater()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_ColonQuestionMark()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_ColonQuestionMarkGreater()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Comma()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_CommentTrivia()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Const()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Constraint()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Constructor()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Decimal()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Default()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Delegate()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Do()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_DoBang()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Dollar()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Done()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Dot()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_DotDot()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_DotDotHat()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_DownTo()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Downcast()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Elif()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Else()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_End()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Equals()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Exception()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Extern()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_False()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Finally()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Fixed()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_For()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Fun()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Function()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_FunkyOperatorName()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Global()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Greater()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_GreaterBarRightBracket()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_GreaterRightBracket()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Hash()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_HashElse()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_HashEndIf()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_HashIf()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_HashLight()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_HashLine()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_HighPrecedenceBracketApp()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_HighPrecedenceParenthesisApp()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_HighPrecedenceTypeApp()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Identifier()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Ieee32()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Ieee64()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_If()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_In()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_InactiveCode()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_InfixAmpersandOperator()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_InfixAsr()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_InfixAtHatOperator()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_InfixBarOperator()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_InfixCompareOperator()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_InfixLand()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_InfixLor()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_InfixLsl()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_InfixLsr()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_InfixLxor()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_InfixMod()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_InfixStarDivideModuloOperator()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_InfixStarStarOperator()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Inherit()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Inline()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Instance()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Int16()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Int32()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Int32DotDot()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Int64()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Int8()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Interface()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Internal()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_JoinIn()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_KeywordString()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Lazy()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_LeftArrow()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_LeftBrace()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_LeftBraceBar()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_LeftBracket()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_LeftBracketBar()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_LeftBracketLess()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_LeftParenthesis()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_LeftParenthesisStarRightParenthesis()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_LeftQuote()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Less()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Let()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_LineCommentTrivia()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Match()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_MatchBang()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Member()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Minus()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Module()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Mutable()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Namespace()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_NativeInt()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_New()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_None()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Null()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Of()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_OffsideAssert()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_OffsideBinder()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_OffsideBlockBegin()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_OffsideBlockEnd()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_OffsideBlockSep()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_OffsideDeclEnd()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_OffsideDo()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_OffsideDoBang()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_OffsideElse()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_OffsideEnd()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_OffsideFun()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_OffsideFunction()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_OffsideInterfaceMember()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_OffsideLazy()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_OffsideLet()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_OffsideReset()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_OffsideRightBlockEnd()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_OffsideThen()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_OffsideWith()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Open()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Or()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Override()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_PercentOperator()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_PlusMinusOperator()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_PrefixOperator()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Private()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Public()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_QuestionMark()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_QuestionMarkQuestionMark()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Quote()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Rec()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Reserved()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_RightArrow()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_RightBrace()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_RightBracket()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_RightParenthesis()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_RightQuote()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_RightQuoteDot()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Semicolon()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_SemicolonSemicolon()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Sig()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Star()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Static()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_String()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_StringText()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Struct()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Then()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_To()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_True()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Try()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Type()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_UInt16()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_UInt32()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_UInt64()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_UInt8()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_UNativeInt()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Underscore()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Upcast()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Val()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Void()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_When()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_While()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_WhitespaceTrivia()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_With()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_Yield()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind get_YieldBang()
+FSharp.Compiler.Tokenization.FSharpTokenKind: FSharp.Compiler.Tokenization.FSharpTokenKind+Tags
+FSharp.Compiler.Tokenization.FSharpTokenKind: Int32 CompareTo(FSharp.Compiler.Tokenization.FSharpTokenKind)
+FSharp.Compiler.Tokenization.FSharpTokenKind: Int32 CompareTo(System.Object)
+FSharp.Compiler.Tokenization.FSharpTokenKind: Int32 CompareTo(System.Object, System.Collections.IComparer)
+FSharp.Compiler.Tokenization.FSharpTokenKind: Int32 GetHashCode()
+FSharp.Compiler.Tokenization.FSharpTokenKind: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Tokenization.FSharpTokenKind: Int32 Tag
+FSharp.Compiler.Tokenization.FSharpTokenKind: Int32 get_Tag()
+FSharp.Compiler.Tokenization.FSharpTokenKind: System.String ToString()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 AMP_AMP
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 BAR
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 BAR_BAR
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 BAR_RBRACK
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 BEGIN
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 CLASS
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 COLON
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 COLON_COLON
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 COLON_EQUALS
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 COLON_GREATER
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 COLON_QMARK
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 COLON_QMARK_GREATER
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 COMMA
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 COMMENT
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 DO
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 DOT
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 DOT_DOT
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 DOT_DOT_HAT
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 ELSE
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 EQUALS
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 FUNCTION
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 GREATER
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 GREATER_RBRACK
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 IDENT
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 INFIX_AT_HAT_OP
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 INFIX_BAR_OP
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 INFIX_COMPARE_OP
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 INFIX_STAR_DIV_MOD_OP
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 INT32_DOT_DOT
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 INTERP_STRING_BEGIN_END
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 INTERP_STRING_BEGIN_PART
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 INTERP_STRING_END
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 INTERP_STRING_PART
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 Identifier
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 LARROW
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 LBRACE
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 LBRACK
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 LBRACK_BAR
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 LBRACK_LESS
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 LESS
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 LINE_COMMENT
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 LPAREN
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 MINUS
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 NEW
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 OWITH
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 PERCENT_OP
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 PLUS_MINUS_OP
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 PREFIX_OP
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 QMARK
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 QUOTE
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 RARROW
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 RBRACE
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 RBRACK
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 RPAREN
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 SEMICOLON
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 STAR
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 STRING
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 STRUCT
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 String
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 THEN
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 TRY
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 UNDERSCORE
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 WHITESPACE
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 WITH
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_AMP_AMP()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_BAR()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_BAR_BAR()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_BAR_RBRACK()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_BEGIN()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_CLASS()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_COLON()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_COLON_COLON()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_COLON_EQUALS()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_COLON_GREATER()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_COLON_QMARK()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_COLON_QMARK_GREATER()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_COMMA()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_COMMENT()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_DO()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_DOT()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_DOT_DOT()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_DOT_DOT_HAT()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_ELSE()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_EQUALS()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_FUNCTION()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_GREATER()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_GREATER_RBRACK()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_IDENT()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_INFIX_AT_HAT_OP()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_INFIX_BAR_OP()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_INFIX_COMPARE_OP()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_INFIX_STAR_DIV_MOD_OP()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_INT32_DOT_DOT()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_INTERP_STRING_BEGIN_END()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_INTERP_STRING_BEGIN_PART()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_INTERP_STRING_END()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_INTERP_STRING_PART()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_Identifier()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_LARROW()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_LBRACE()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_LBRACK()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_LBRACK_BAR()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_LBRACK_LESS()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_LESS()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_LINE_COMMENT()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_LPAREN()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_MINUS()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_NEW()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_OWITH()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_PERCENT_OP()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_PLUS_MINUS_OP()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_PREFIX_OP()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_QMARK()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_QUOTE()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_RARROW()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_RBRACE()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_RBRACK()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_RPAREN()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_SEMICOLON()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_STAR()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_STRING()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_STRUCT()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_String()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_THEN()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_TRY()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_UNDERSCORE()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_WHITESPACE()
+FSharp.Compiler.Tokenization.FSharpTokenTag: Int32 get_WITH()
+FSharp.Compiler.Tokenization.FSharpTokenTriggerClass: FSharp.Compiler.Tokenization.FSharpTokenTriggerClass ChoiceSelect
+FSharp.Compiler.Tokenization.FSharpTokenTriggerClass: FSharp.Compiler.Tokenization.FSharpTokenTriggerClass MatchBraces
+FSharp.Compiler.Tokenization.FSharpTokenTriggerClass: FSharp.Compiler.Tokenization.FSharpTokenTriggerClass MemberSelect
+FSharp.Compiler.Tokenization.FSharpTokenTriggerClass: FSharp.Compiler.Tokenization.FSharpTokenTriggerClass MethodTip
+FSharp.Compiler.Tokenization.FSharpTokenTriggerClass: FSharp.Compiler.Tokenization.FSharpTokenTriggerClass None
+FSharp.Compiler.Tokenization.FSharpTokenTriggerClass: FSharp.Compiler.Tokenization.FSharpTokenTriggerClass ParamEnd
+FSharp.Compiler.Tokenization.FSharpTokenTriggerClass: FSharp.Compiler.Tokenization.FSharpTokenTriggerClass ParamNext
+FSharp.Compiler.Tokenization.FSharpTokenTriggerClass: FSharp.Compiler.Tokenization.FSharpTokenTriggerClass ParamStart
+FSharp.Compiler.Tokenization.FSharpTokenTriggerClass: Int32 value__
+FSharp.Compiler.Tokenization.FSharpTokenizerColorState: FSharp.Compiler.Tokenization.FSharpTokenizerColorState CamlOnly
+FSharp.Compiler.Tokenization.FSharpTokenizerColorState: FSharp.Compiler.Tokenization.FSharpTokenizerColorState Comment
+FSharp.Compiler.Tokenization.FSharpTokenizerColorState: FSharp.Compiler.Tokenization.FSharpTokenizerColorState EndLineThenSkip
+FSharp.Compiler.Tokenization.FSharpTokenizerColorState: FSharp.Compiler.Tokenization.FSharpTokenizerColorState EndLineThenToken
+FSharp.Compiler.Tokenization.FSharpTokenizerColorState: FSharp.Compiler.Tokenization.FSharpTokenizerColorState IfDefSkip
+FSharp.Compiler.Tokenization.FSharpTokenizerColorState: FSharp.Compiler.Tokenization.FSharpTokenizerColorState InitialState
+FSharp.Compiler.Tokenization.FSharpTokenizerColorState: FSharp.Compiler.Tokenization.FSharpTokenizerColorState SingleLineComment
+FSharp.Compiler.Tokenization.FSharpTokenizerColorState: FSharp.Compiler.Tokenization.FSharpTokenizerColorState String
+FSharp.Compiler.Tokenization.FSharpTokenizerColorState: FSharp.Compiler.Tokenization.FSharpTokenizerColorState StringInComment
+FSharp.Compiler.Tokenization.FSharpTokenizerColorState: FSharp.Compiler.Tokenization.FSharpTokenizerColorState Token
+FSharp.Compiler.Tokenization.FSharpTokenizerColorState: FSharp.Compiler.Tokenization.FSharpTokenizerColorState TripleQuoteString
+FSharp.Compiler.Tokenization.FSharpTokenizerColorState: FSharp.Compiler.Tokenization.FSharpTokenizerColorState TripleQuoteStringInComment
+FSharp.Compiler.Tokenization.FSharpTokenizerColorState: FSharp.Compiler.Tokenization.FSharpTokenizerColorState VerbatimString
+FSharp.Compiler.Tokenization.FSharpTokenizerColorState: FSharp.Compiler.Tokenization.FSharpTokenizerColorState VerbatimStringInComment
+FSharp.Compiler.Tokenization.FSharpTokenizerColorState: Int32 value__
+FSharp.Compiler.Tokenization.FSharpTokenizerLexState: Boolean Equals(FSharp.Compiler.Tokenization.FSharpTokenizerLexState)
+FSharp.Compiler.Tokenization.FSharpTokenizerLexState: Boolean Equals(System.Object)
+FSharp.Compiler.Tokenization.FSharpTokenizerLexState: FSharp.Compiler.Tokenization.FSharpTokenizerLexState Initial
+FSharp.Compiler.Tokenization.FSharpTokenizerLexState: FSharp.Compiler.Tokenization.FSharpTokenizerLexState get_Initial()
+FSharp.Compiler.Tokenization.FSharpTokenizerLexState: Int32 GetHashCode()
+FSharp.Compiler.Tokenization.FSharpTokenizerLexState: Int64 OtherBits
+FSharp.Compiler.Tokenization.FSharpTokenizerLexState: Int64 PosBits
+FSharp.Compiler.Tokenization.FSharpTokenizerLexState: Int64 get_OtherBits()
+FSharp.Compiler.Tokenization.FSharpTokenizerLexState: Int64 get_PosBits()
+FSharp.Compiler.Tokenization.FSharpTokenizerLexState: System.String ToString()
+FSharp.Compiler.Tokenization.FSharpTokenizerLexState: Void .ctor(Int64, Int64)
+FSharp.Compiler.Xml.PreXmlDoc: Boolean Equals(FSharp.Compiler.Xml.PreXmlDoc)
+FSharp.Compiler.Xml.PreXmlDoc: Boolean Equals(System.Object)
+FSharp.Compiler.Xml.PreXmlDoc: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+FSharp.Compiler.Xml.PreXmlDoc: Boolean IsEmpty
+FSharp.Compiler.Xml.PreXmlDoc: Boolean get_IsEmpty()
+FSharp.Compiler.Xml.PreXmlDoc: FSharp.Compiler.Xml.PreXmlDoc Create(System.String[], FSharp.Compiler.Text.Range)
+FSharp.Compiler.Xml.PreXmlDoc: FSharp.Compiler.Xml.PreXmlDoc Empty
+FSharp.Compiler.Xml.PreXmlDoc: FSharp.Compiler.Xml.PreXmlDoc Merge(FSharp.Compiler.Xml.PreXmlDoc, FSharp.Compiler.Xml.PreXmlDoc)
+FSharp.Compiler.Xml.PreXmlDoc: FSharp.Compiler.Xml.PreXmlDoc get_Empty()
+FSharp.Compiler.Xml.PreXmlDoc: FSharp.Compiler.Xml.XmlDoc ToXmlDoc(Boolean, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[System.String]])
+FSharp.Compiler.Xml.PreXmlDoc: Int32 GetHashCode()
+FSharp.Compiler.Xml.PreXmlDoc: Int32 GetHashCode(System.Collections.IEqualityComparer)
+FSharp.Compiler.Xml.PreXmlDoc: System.String ToString()
+FSharp.Compiler.Xml.XmlDoc: Boolean IsEmpty
+FSharp.Compiler.Xml.XmlDoc: Boolean NonEmpty
+FSharp.Compiler.Xml.XmlDoc: Boolean get_IsEmpty()
+FSharp.Compiler.Xml.XmlDoc: Boolean get_NonEmpty()
+FSharp.Compiler.Xml.XmlDoc: FSharp.Compiler.Text.Range Range
+FSharp.Compiler.Xml.XmlDoc: FSharp.Compiler.Text.Range get_Range()
+FSharp.Compiler.Xml.XmlDoc: FSharp.Compiler.Xml.XmlDoc Empty
+FSharp.Compiler.Xml.XmlDoc: FSharp.Compiler.Xml.XmlDoc Merge(FSharp.Compiler.Xml.XmlDoc, FSharp.Compiler.Xml.XmlDoc)
+FSharp.Compiler.Xml.XmlDoc: FSharp.Compiler.Xml.XmlDoc get_Empty()
+FSharp.Compiler.Xml.XmlDoc: System.String GetXmlText()
+FSharp.Compiler.Xml.XmlDoc: System.String[] GetElaboratedXmlLines()
+FSharp.Compiler.Xml.XmlDoc: System.String[] UnprocessedLines
+FSharp.Compiler.Xml.XmlDoc: System.String[] get_UnprocessedLines()
+FSharp.Compiler.Xml.XmlDoc: Void .ctor(System.String[], FSharp.Compiler.Text.Range)
\ No newline at end of file
diff --git a/tests/FSharp.Compiler.Service.Tests/FSharp.Compiler.Service.Tests.fsproj b/tests/FSharp.Compiler.Service.Tests/FSharp.Compiler.Service.Tests.fsproj
index 279296ec02c..ac99cea52ae 100644
--- a/tests/FSharp.Compiler.Service.Tests/FSharp.Compiler.Service.Tests.fsproj
+++ b/tests/FSharp.Compiler.Service.Tests/FSharp.Compiler.Service.Tests.fsproj
@@ -23,9 +23,7 @@
     <Content Include="expected-help-output.bsl">
       <CopyToOutputDirectory>Never</CopyToOutputDirectory>
     </Content>
-    <Compile Include="..\fsharp\TestHelpers.fs" Link="TestHelpers.fs" />
-    <Compile Include="LibraryTestFx.fs" />
-    <Compile Include="SurfaceArea.netstandard.fs" />
+    <Compile Include="SurfaceArea.fs" Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'"/>
     <Compile Include="..\service\FsUnit.fs">
       <Link>FsUnit.fs</Link>
     </Compile>
@@ -131,6 +129,9 @@
     <Compile Include="..\service\SyntaxTreeTests\LeadingKeywordTests.fs">
       <Link>SyntaxTree\LeadingKeywordTests.fs</Link>
     </Compile>
+    <Compile Include="..\service\SyntaxTreeTests\ValTests.fs">
+      <Link>SyntaxTree\ValTests.fs</Link>
+    </Compile>
     <Compile Include="..\service\FileSystemTests.fs">
       <Link>FileSystemTests.fs</Link>
     </Compile>
diff --git a/tests/FSharp.Compiler.Service.Tests/LibraryTestFx.fs b/tests/FSharp.Compiler.Service.Tests/LibraryTestFx.fs
deleted file mode 100644
index c20e8471597..00000000000
--- a/tests/FSharp.Compiler.Service.Tests/LibraryTestFx.fs
+++ /dev/null
@@ -1,77 +0,0 @@
-// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
-
-module Tests.Service.SurfaceArea.LibraryTestFx
-
-open System
-open System.IO
-open System.Reflection
-open System.Text.RegularExpressions
-
-open FSharp.Compiler.IO
-
-open NUnit.Framework
-
-// Verifies two sequences are equal (same length, equiv elements)
-let VerifySeqsEqual (seq1 : seq<'T>) (seq2 : seq<'T>) =
-    Assert.Equals(seq1, seq2)
-
-let sleep(n : int32) =
-    System.Threading.Thread.Sleep(n)
-
-module SurfaceArea =
-
-    // gets string form of public surface area for FSharp.CompilerService
-    let private getActual () =
-
-        // get local FSharp.CompilerService
-        let path = Path.Combine(Path.GetDirectoryName(typeof<int list>.Assembly.Location), "FSharp.Compiler.Service.dll")
-        let name = AssemblyName.GetAssemblyName path
-        let asm = Assembly.Load(name)
-
-        // public types only
-        let types = asm.ExportedTypes |> Seq.filter (fun ty -> let ti = ty.GetTypeInfo() in ti.IsPublic || ti.IsNestedPublic) |> Array.ofSeq
-
-        // extract canonical string form for every public member of every type
-        let getTypeMemberStrings (t : Type) =
-            // for System.Runtime-based profiles, need to do lots of manual work
-            let getMembers (t : Type) =
-                let ti = t.GetTypeInfo()
-                let cast (info: #MemberInfo) = (t, info :> MemberInfo)
-                seq {
-                    yield! ti.DeclaredEvents |> Seq.filter (fun m -> m.AddMethod.IsPublic) |> Seq.map cast
-                    yield! ti.DeclaredProperties |> Seq.filter (fun m -> m.GetMethod.IsPublic) |> Seq.map cast
-                    yield! ti.DeclaredMethods |> Seq.filter (fun m -> m.IsPublic) |> Seq.map cast
-                    yield! ti.DeclaredFields |> Seq.filter (fun m -> m.IsPublic) |> Seq.map cast
-                    yield! ti.DeclaredConstructors  |> Seq.filter (fun m -> m.IsPublic) |> Seq.map cast
-                    yield! ti.DeclaredNestedTypes   |> Seq.filter (fun ty -> ty.IsNestedPublic) |> Seq.map cast
-                } |> Array.ofSeq
-
-            [| for ty,m in getMembers t do
-                  yield sprintf "%s: %s" (ty.ToString()) (m.ToString())
-               if not t.IsNested then
-                   yield t.ToString()
-            |]
-
-        let actual =
-            types 
-            |> Array.collect getTypeMemberStrings
-            |> Array.sort
-            |> String.concat Environment.NewLine
-        asm, actual
-
-    // verify public surface area matches expected
-    let verify expectedFile actualFile =
-      let normalize text = Regex.Replace(text, "(\\r\\n|\\n|\\r)+", "\r\n").Trim()
-      let _asm, actual = getActual ()
-      let actual = normalize actual
-      let expected = normalize (System.IO.File.ReadAllText expectedFile)
-      match Tests.TestHelpers.assembleDiffMessage actual expected with
-      | None -> ()
-      | Some diff ->
-          FileSystem
-            .OpenFileForWriteShim(actualFile)
-            .WriteAllText(actual)
-
-          failwith
-            $"surface area defined in\n\n{expectedFile}\n\ndoesn't match actual in\n\n{actualFile}\n\nCompare the files and adjust accordingly.
-            {diff}"
\ No newline at end of file
diff --git a/tests/FSharp.Compiler.Service.Tests/SurfaceArea.fs b/tests/FSharp.Compiler.Service.Tests/SurfaceArea.fs
new file mode 100644
index 00000000000..0f88afd1d7f
--- /dev/null
+++ b/tests/FSharp.Compiler.Service.Tests/SurfaceArea.fs
@@ -0,0 +1,38 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+namespace Tests.Service.SurfaceArea
+
+open System.IO
+open System.Reflection
+open NUnit.Framework
+
+type SurfaceAreaTest() =
+    // This relies on a set of baselines to update the baseline set an environment variable before running the tests, then on failure the baselines will be updated
+    // Handled by SurfaceArea.verify
+    //
+    // CMD:
+    //    set TEST_UPDATE_BSL=1
+    // PowerShell:
+    //    $env:TEST_UPDATE_BSL=1
+    // Linux/macOS:
+    //    export TEST_UPDATE_BSL=1
+
+    [<Test>]
+    member _.VerifySurfaceAreaFSharpCompilerService() =
+
+        let platform = "netstandard20"
+
+        let flavor =
+#if DEBUG
+            "debug"
+#else
+            "release"
+#endif
+        let assembly =
+            let path = Path.Combine(Path.GetDirectoryName(typeof<int list>.Assembly.Location), "FSharp.Compiler.Service.dll")
+            Assembly.LoadFrom path
+
+        let baseline = Path.Combine(__SOURCE_DIRECTORY__, $"FSharp.Compiler.Service.SurfaceArea.{platform}.{flavor}.bsl")
+        let outFileName = $"FSharp.Compiler.Service.SurfaceArea.{platform}.{flavor}.out"
+        FSharp.Test.SurfaceArea.verify assembly baseline outFileName
+
diff --git a/tests/FSharp.Compiler.Service.Tests/SurfaceArea.netstandard.fs b/tests/FSharp.Compiler.Service.Tests/SurfaceArea.netstandard.fs
deleted file mode 100644
index d4a78ca1041..00000000000
--- a/tests/FSharp.Compiler.Service.Tests/SurfaceArea.netstandard.fs
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
-
-namespace Tests.Service.SurfaceArea
-
-open Tests.Service.SurfaceArea.LibraryTestFx
-open NUnit.Framework
-
-type SurfaceAreaTest() =
-    [<Test>]
-    member _.VerifyArea() =
-        let expectedFile = System.IO.Path.Combine(__SOURCE_DIRECTORY__,"FSharp.CompilerService.SurfaceArea.netstandard.expected")
-        let actualFile = System.IO.Path.Combine(__SOURCE_DIRECTORY__,"FSharp.CompilerService.SurfaceArea.netstandard.actual")
-        SurfaceArea.verify expectedFile actualFile
diff --git a/tests/FSharp.Compiler.UnitTests/AssemblySigningAttributes.fs b/tests/FSharp.Compiler.UnitTests/AssemblySigningAttributes.fs
index 82da5f0a146..a5a6eb7daee 100644
--- a/tests/FSharp.Compiler.UnitTests/AssemblySigningAttributes.fs
+++ b/tests/FSharp.Compiler.UnitTests/AssemblySigningAttributes.fs
@@ -8,9 +8,7 @@ open FSharp.Test.Compiler
 
 module AssemblySigning =
 
-#if !NETCOREAPP
-    [<Fact>]
-#endif
+    [<FactForDESKTOP>]
     let ``--keycontainer:name DESKTOP`` () =
         FSharp """
 module SignMe
@@ -26,9 +24,7 @@ open System.Reflection
         |> withDiagnosticMessageMatches "The command-line option '--keycontainer' has been deprecated. Use '--keyfile' instead."
         |> ignore
 
-#if NETCOREAPP
-    [<Fact>]
-#endif
+    [<FactForNETCOREAPP>]
     let ``--keycontainer:name NETCOREAPP`` () =
         FSharp """
 module SignMe
@@ -45,9 +41,7 @@ open System.Reflection
         |> ignore
 
     //Expects: warning FS3392: The 'AssemblyKeyNameAttribute' has been deprecated. Use 'AssemblyKeyFileAttribute' instead.
-#if !NETCOREAPP
-    [<Fact>]
-#endif
+    [<FactForDESKTOP>]
     let ``AssemblyKeyNameAttribute DESKTOP`` () =
         FSharp """
 module SignMe
@@ -66,9 +60,7 @@ do ()
              |> ignore
 
     //Expects: warning FS3392: The 'AssemblyKeyNameAttribute' has been deprecated. Use 'AssemblyKeyFileAttribute' instead.
-#if NETCOREAPP
-    [<Fact>]
-#endif
+    [<FactForNETCOREAPP>]
     let ``AssemblyKeyNameAttribute NETCOREAPP`` () =
         FSharp """
 module SignMe
diff --git a/tests/FSharp.Compiler.UnitTests/FsiTests.fs b/tests/FSharp.Compiler.UnitTests/FsiTests.fs
index 36b36a1c49f..73f33523930 100644
--- a/tests/FSharp.Compiler.UnitTests/FsiTests.fs
+++ b/tests/FSharp.Compiler.UnitTests/FsiTests.fs
@@ -14,7 +14,7 @@ type Sentinel () =
 module MyModule =
     let test(x: int) = ()
 
-[<Collection("SingleThreaded")>]
+[<CollectionDefinition("FsiTests", DisableParallelization = true)>]
 module FsiTests =
 
     let createFsiSession (useOneDynamicAssembly: bool) =
@@ -644,37 +644,27 @@ module FsiTests =
         Assert.shouldBe typeof<CustomType2[,]> boundValue.Value.ReflectionType
         boundValue.Value.ReflectionValue.Should().Be(mdArr, "") |> ignore
 
-#if NETCOREAPP
-    [<Fact>]
-    let ``Evaluating simple reference and code succeeds under permutations``() =
-
-        for useSdkRefsFlag in ["/usesdkrefs"; "/usesdkrefs-"] do
-            for multiemitFlag in ["/multiemit"; "/multiemit-"] do
-                let config = FsiEvaluationSession.GetDefaultConfiguration()
-                let argv = [|
-                    typeof<Sentinel>.Assembly.Location
-                    "--noninteractive"
-                    "--targetprofile:netcore"
-                    "--langversion:preview"
-                    multiemitFlag
-                    useSdkRefsFlag
-                    |]
-                let fsi = FsiEvaluationSession.Create(config, argv, TextReader.Null, TextWriter.Null, TextWriter.Null)
-                let assemblyPath = typeof<Sentinel>.Assembly.Location.Replace("\\", "/")
-                let code = $@"
-            #r ""{assemblyPath}""
-            FSharp.Compiler.UnitTests.MyModule.test(3)"
-                let ch, errors = fsi.EvalInteractionNonThrowing(code, CancellationToken.None)
-                errors
-                |> Array.iter (fun e -> printfn "error: %A" e)
-                match ch with
-                | Choice1Of2 v ->
-                    let v =
-                        match v with
-                        | Some v -> sprintf "%A" v.ReflectionValue
-                        | None -> "(none)"
-                    printfn "value: %A" v
-                | Choice2Of2 e ->
-                    printfn "exception: %A" e
-                    raise e
-#endif
+    [<TheoryForNETCOREAPP>]
+    [<InlineData(true)>]
+    [<InlineData(false)>]
+    let ``Evaluating simple reference and code succeeds``(useOneDynamicAssembly:bool) =
+
+        use fsiSession = createFsiSession useOneDynamicAssembly
+        let assemblyPath = typeof<Sentinel>.Assembly.Location.Replace("\\", "/")
+        let res, errors = fsiSession.EvalInteractionNonThrowing($"""
+            #r "{assemblyPath}"
+            FSharp.Compiler.UnitTests.MyModule.test(3)""")
+
+        errors
+        |> Array.iter (fun e -> printfn "error: %A" e)
+
+        match res with
+        | Choice1Of2 v ->
+            let v =
+                match v with
+                | Some v -> sprintf "%A" v.ReflectionValue
+                | None -> "(none)"
+            printfn "value: %A" v
+        | Choice2Of2 e ->
+            printfn "exception: %A" e
+            raise e
\ No newline at end of file
diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.debug.bsl b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.debug.bsl
new file mode 100644
index 00000000000..b0ec5cbb925
--- /dev/null
+++ b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.debug.bsl
@@ -0,0 +1,2508 @@
+! AssemblyReference: System.Runtime.Numerics
+! AssemblyReference: netstandard
+Microsoft.FSharp.Collections.Array2DModule: Int32 Base1[T](T[,])
+Microsoft.FSharp.Collections.Array2DModule: Int32 Base2[T](T[,])
+Microsoft.FSharp.Collections.Array2DModule: Int32 Length1[T](T[,])
+Microsoft.FSharp.Collections.Array2DModule: Int32 Length2[T](T[,])
+Microsoft.FSharp.Collections.Array2DModule: T Get[T](T[,], Int32, Int32)
+Microsoft.FSharp.Collections.Array2DModule: TResult[,] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]]], T[,])
+Microsoft.FSharp.Collections.Array2DModule: TResult[,] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[,])
+Microsoft.FSharp.Collections.Array2DModule: T[,] Copy[T](T[,])
+Microsoft.FSharp.Collections.Array2DModule: T[,] CreateBased[T](Int32, Int32, Int32, Int32, T)
+Microsoft.FSharp.Collections.Array2DModule: T[,] Create[T](Int32, Int32, T)
+Microsoft.FSharp.Collections.Array2DModule: T[,] InitializeBased[T](Int32, Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]])
+Microsoft.FSharp.Collections.Array2DModule: T[,] Initialize[T](Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]])
+Microsoft.FSharp.Collections.Array2DModule: T[,] Rebase[T](T[,])
+Microsoft.FSharp.Collections.Array2DModule: T[,] ZeroCreateBased[T](Int32, Int32, Int32, Int32)
+Microsoft.FSharp.Collections.Array2DModule: T[,] ZeroCreate[T](Int32, Int32)
+Microsoft.FSharp.Collections.Array2DModule: Void CopyTo[T](T[,], Int32, Int32, T[,], Int32, Int32, Int32, Int32)
+Microsoft.FSharp.Collections.Array2DModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]]], T[,])
+Microsoft.FSharp.Collections.Array2DModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[,])
+Microsoft.FSharp.Collections.Array2DModule: Void Set[T](T[,], Int32, Int32, T)
+Microsoft.FSharp.Collections.Array3DModule: Int32 Length1[T](T[,,])
+Microsoft.FSharp.Collections.Array3DModule: Int32 Length2[T](T[,,])
+Microsoft.FSharp.Collections.Array3DModule: Int32 Length3[T](T[,,])
+Microsoft.FSharp.Collections.Array3DModule: T Get[T](T[,,], Int32, Int32, Int32)
+Microsoft.FSharp.Collections.Array3DModule: TResult[,,] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]]]], T[,,])
+Microsoft.FSharp.Collections.Array3DModule: TResult[,,] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[,,])
+Microsoft.FSharp.Collections.Array3DModule: T[,,] Create[T](Int32, Int32, Int32, T)
+Microsoft.FSharp.Collections.Array3DModule: T[,,] Initialize[T](Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]]])
+Microsoft.FSharp.Collections.Array3DModule: T[,,] ZeroCreate[T](Int32, Int32, Int32)
+Microsoft.FSharp.Collections.Array3DModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]]]], T[,,])
+Microsoft.FSharp.Collections.Array3DModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[,,])
+Microsoft.FSharp.Collections.Array3DModule: Void Set[T](T[,,], Int32, Int32, Int32, T)
+Microsoft.FSharp.Collections.Array4DModule: Int32 Length1[T](T[,,,])
+Microsoft.FSharp.Collections.Array4DModule: Int32 Length2[T](T[,,,])
+Microsoft.FSharp.Collections.Array4DModule: Int32 Length3[T](T[,,,])
+Microsoft.FSharp.Collections.Array4DModule: Int32 Length4[T](T[,,,])
+Microsoft.FSharp.Collections.Array4DModule: T Get[T](T[,,,], Int32, Int32, Int32, Int32)
+Microsoft.FSharp.Collections.Array4DModule: T[,,,] Create[T](Int32, Int32, Int32, Int32, T)
+Microsoft.FSharp.Collections.Array4DModule: T[,,,] Initialize[T](Int32, Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]]]])
+Microsoft.FSharp.Collections.Array4DModule: T[,,,] ZeroCreate[T](Int32, Int32, Int32, Int32)
+Microsoft.FSharp.Collections.Array4DModule: Void Set[T](T[,,,], Int32, Int32, Int32, Int32, T)
+Microsoft.FSharp.Collections.ArrayModule+Parallel: System.Tuple`2[T[],T[]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] Collect[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult[]], T[])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], T[])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: T[] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], T[])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[])
+Microsoft.FSharp.Collections.ArrayModule: Boolean Contains[T](T, T[])
+Microsoft.FSharp.Collections.ArrayModule: Boolean Exists2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Boolean ForAll2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Boolean IsEmpty[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: Int32 CompareWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], T[], T[])
+Microsoft.FSharp.Collections.ArrayModule: Int32 FindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Int32 FindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Int32 Length[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Collections.ArrayModule+Parallel
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryExactlyOne[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryHead[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryItem[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryLast[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Collections.Generic.IEnumerable`1[T] ToSeq[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[System.Int32,T][] Indexed[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T,T][] Pairwise[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T1,T2][] AllPairs[T1,T2](T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T1,T2][] Zip[T1,T2](T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T1[],T2[]] Unzip[T1,T2](System.Tuple`2[T1,T2][])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TKey,System.Int32][] CountBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TKey,T[]][] GroupBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TResult[],TState] MapFoldBack[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,System.Tuple`2[TResult,TState]]], T[], TState)
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TResult[],TState] MapFold[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Tuple`2[TResult,TState]]], TState, T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T[],T[]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T[],T[]] SplitAt[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`3[T1,T2,T3][] Zip3[T1,T2,T3](T1[], T2[], T3[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`3[T1[],T2[],T3[]] Unzip3[T1,T2,T3](System.Tuple`3[T1,T2,T3][])
+Microsoft.FSharp.Collections.ArrayModule: T Average$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Average[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T ExactlyOne[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T FindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Find[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Get[T](T[], Int32)
+Microsoft.FSharp.Collections.ArrayModule: T Head[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T Item[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T Last[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T MaxBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Max[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T MinBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Min[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T ReduceBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Reduce[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Sum$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Sum[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult AverageBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult AverageBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult Pick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult SumBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult SumBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] Collect[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult[]], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], T1[], T2[], T3[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] MapIndexed2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]]], T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: TState Fold2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TState]]], TState, T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: TState FoldBack2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], T1[], T2[], TState)
+Microsoft.FSharp.Collections.ArrayModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], T[], TState)
+Microsoft.FSharp.Collections.ArrayModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, T[])
+Microsoft.FSharp.Collections.ArrayModule: TState[] ScanBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], T[], TState)
+Microsoft.FSharp.Collections.ArrayModule: TState[] Scan[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Append[T](T[], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Concat[T](System.Collections.Generic.IEnumerable`1[T[]])
+Microsoft.FSharp.Collections.ArrayModule: T[] Copy[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Create[T](Int32, T)
+Microsoft.FSharp.Collections.ArrayModule: T[] DistinctBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Distinct[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Empty[T]()
+Microsoft.FSharp.Collections.ArrayModule: T[] Except[T](System.Collections.Generic.IEnumerable`1[T], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] GetSubArray[T](T[], Int32, Int32)
+Microsoft.FSharp.Collections.ArrayModule: T[] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T])
+Microsoft.FSharp.Collections.ArrayModule: T[] InsertAt[T](Int32, T, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] InsertManyAt[T](Int32, System.Collections.Generic.IEnumerable`1[T], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] OfList[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ArrayModule: T[] OfSeq[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.ArrayModule: T[] Permute[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.Int32], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] RemoveAt[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] RemoveManyAt[T](Int32, Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Replicate[T](Int32, T)
+Microsoft.FSharp.Collections.ArrayModule: T[] Reverse[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Singleton[T](T)
+Microsoft.FSharp.Collections.ArrayModule: T[] SkipWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Skip[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] SortByDescending[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] SortBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] SortDescending[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] SortWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Sort[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Tail[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] TakeWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Take[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Truncate[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Unfold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[T,TState]]], TState)
+Microsoft.FSharp.Collections.ArrayModule: T[] UpdateAt[T](Int32, T, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Where[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] ZeroCreate[T](Int32)
+Microsoft.FSharp.Collections.ArrayModule: T[][] ChunkBySize[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[][] SplitInto[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[][] Transpose[T](System.Collections.Generic.IEnumerable`1[T[]])
+Microsoft.FSharp.Collections.ArrayModule: T[][] Windowed[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: Void CopyTo[T](T[], Int32, T[], Int32, Int32)
+Microsoft.FSharp.Collections.ArrayModule: Void Fill[T](T[], Int32, Int32, T)
+Microsoft.FSharp.Collections.ArrayModule: Void Iterate2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]], T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: Void IterateIndexed2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]]], T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], T[])
+Microsoft.FSharp.Collections.ArrayModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[])
+Microsoft.FSharp.Collections.ArrayModule: Void Set[T](T[], Int32, T)
+Microsoft.FSharp.Collections.ArrayModule: Void SortInPlaceBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
+Microsoft.FSharp.Collections.ArrayModule: Void SortInPlaceWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], T[])
+Microsoft.FSharp.Collections.ArrayModule: Void SortInPlace[T](T[])
+Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] FromFunction[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]])
+Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] NonStructural$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]])
+Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] NonStructural[T]()
+Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] Structural[T]()
+Microsoft.FSharp.Collections.FSharpList`1+Tags[T]: Int32 Cons
+Microsoft.FSharp.Collections.FSharpList`1+Tags[T]: Int32 Empty
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean Equals(Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean Equals(System.Object)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean IsCons
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean IsEmpty
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean get_IsCons()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean get_IsEmpty()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 CompareTo(Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 GetHashCode()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 GetReverseIndex(Int32, Int32)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 Length
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 Tag
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 get_Length()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 get_Tag()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1+Tags[T]
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Cons(T, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Empty
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] GetSlice(Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Tail
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] TailOrNull
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] get_Empty()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] get_Tail()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] get_TailOrNull()
+Microsoft.FSharp.Collections.FSharpList`1[T]: System.String ToString()
+Microsoft.FSharp.Collections.FSharpList`1[T]: T Head
+Microsoft.FSharp.Collections.FSharpList`1[T]: T HeadOrDefault
+Microsoft.FSharp.Collections.FSharpList`1[T]: T Item [Int32]
+Microsoft.FSharp.Collections.FSharpList`1[T]: T get_Head()
+Microsoft.FSharp.Collections.FSharpList`1[T]: T get_HeadOrDefault()
+Microsoft.FSharp.Collections.FSharpList`1[T]: T get_Item(Int32)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Void .ctor(T, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean ContainsKey(TKey)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean Equals(System.Object)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean IsEmpty
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean TryGetValue(TKey, TValue ByRef)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean get_IsEmpty()
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Int32 Count
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Int32 GetHashCode()
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Int32 get_Count()
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Add(TKey, TValue)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Change(TKey, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpOption`1[TValue],Microsoft.FSharp.Core.FSharpOption`1[TValue]])
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Remove(TKey)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Core.FSharpOption`1[TValue] TryFind(TKey)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TKey] Keys
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TKey] get_Keys()
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TValue] Values
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TValue] get_Values()
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.String ToString()
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: TValue Item [TKey]
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: TValue get_Item(TKey)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Void .ctor(System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,TValue]])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean Contains(T)
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean Equals(System.Object)
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsEmpty
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsProperSubsetOf(Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsProperSupersetOf(Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsSubsetOf(Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsSupersetOf(Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean get_IsEmpty()
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Int32 Count
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Int32 GetHashCode()
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Int32 get_Count()
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] Add(T)
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] Remove(T)
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] op_Addition(Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] op_Subtraction(Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: System.String ToString()
+Microsoft.FSharp.Collections.FSharpSet`1[T]: T MaximumElement
+Microsoft.FSharp.Collections.FSharpSet`1[T]: T MinimumElement
+Microsoft.FSharp.Collections.FSharpSet`1[T]: T get_MaximumElement()
+Microsoft.FSharp.Collections.FSharpSet`1[T]: T get_MinimumElement()
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Void .ctor(System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] FromFunctions[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]])
+Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] LimitedStructural[T](Int32)
+Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] NonStructural$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]])
+Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] NonStructural[T]()
+Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] Reference[T]()
+Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] Structural[T]()
+Microsoft.FSharp.Collections.ListModule: Boolean Contains[T](T, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Boolean Exists2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Boolean ForAll2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Boolean IsEmpty[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Int32 CompareWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], Microsoft.FSharp.Collections.FSharpList`1[T], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Int32 FindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Int32 FindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Int32 Length[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] ChunkBySize[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] SplitInto[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] Transpose[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpList`1[T]])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] Windowed[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[System.Int32,T]] Indexed[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T,T]] Pairwise[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T1,T2]] AllPairs[T1,T2](Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T1,T2]] Zip[T1,T2](Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,Microsoft.FSharp.Collections.FSharpList`1[T]]] GroupBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,System.Int32]] CountBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[T1,T2,T3]] Zip3[T1,T2,T3](Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2], Microsoft.FSharp.Collections.FSharpList`1[T3])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Collect[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Collections.FSharpList`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2], Microsoft.FSharp.Collections.FSharpList`1[T3])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] MapIndexed2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TState] ScanBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Collections.FSharpList`1[T], TState)
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TState] Scan[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Append[T](Microsoft.FSharp.Collections.FSharpList`1[T], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Concat[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpList`1[T]])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] DistinctBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Distinct[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Empty[T]()
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Except[T](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] InsertAt[T](Int32, T, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] InsertManyAt[T](Int32, System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] OfArray[T](T[])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] OfSeq[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Permute[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.Int32], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RemoveAt[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RemoveManyAt[T](Int32, Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Replicate[T](Int32, T)
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Reverse[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Singleton[T](T)
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SkipWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Skip[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortByDescending[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortDescending[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Sort[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Tail[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] TakeWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Take[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Truncate[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Unfold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[T,TState]]], TState)
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] UpdateAt[T](Int32, T, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Where[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryExactlyOne[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryHead[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryItem[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryLast[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: System.Collections.Generic.IEnumerable`1[T] ToSeq[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[T1],Microsoft.FSharp.Collections.FSharpList`1[T2]] Unzip[T1,T2](Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T1,T2]])
+Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[TResult],TState] MapFoldBack[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,System.Tuple`2[TResult,TState]]], Microsoft.FSharp.Collections.FSharpList`1[T], TState)
+Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[TResult],TState] MapFold[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Tuple`2[TResult,TState]]], TState, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[T],Microsoft.FSharp.Collections.FSharpList`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[T],Microsoft.FSharp.Collections.FSharpList`1[T]] SplitAt[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: System.Tuple`3[Microsoft.FSharp.Collections.FSharpList`1[T1],Microsoft.FSharp.Collections.FSharpList`1[T2],Microsoft.FSharp.Collections.FSharpList`1[T3]] Unzip3[T1,T2,T3](Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[T1,T2,T3]])
+Microsoft.FSharp.Collections.ListModule: T Average$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Average[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T ExactlyOne[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T FindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Find[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Get[T](Microsoft.FSharp.Collections.FSharpList`1[T], Int32)
+Microsoft.FSharp.Collections.ListModule: T Head[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Item[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Last[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T MaxBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Max[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T MinBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Min[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T ReduceBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Reduce[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Sum$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Sum[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: TResult AverageBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: TResult AverageBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: TResult Pick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: TResult SumBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: TResult SumBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: TState Fold2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TState]]], TState, Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: TState FoldBack2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2], TState)
+Microsoft.FSharp.Collections.ListModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Collections.FSharpList`1[T], TState)
+Microsoft.FSharp.Collections.ListModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T[] ToArray[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Void Iterate2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Void IterateIndexed2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.MapModule: Boolean ContainsKey[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Boolean Exists[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Boolean ForAll[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Boolean IsEmpty[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Int32 Count[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,T]] ToList[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TResult] Map[TKey,T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Add[TKey,T](TKey, T, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Change[TKey,T](TKey, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpOption`1[T],Microsoft.FSharp.Core.FSharpOption`1[T]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Empty[TKey,T]()
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Filter[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] OfArray[TKey,T](System.Tuple`2[TKey,T][])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] OfList[TKey,T](Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,T]])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] OfSeq[TKey,T](System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,T]])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Remove[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Core.FSharpOption`1[TKey] TryFindKey[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[TKey,T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Collections.Generic.ICollection`1[TKey] Keys[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Collections.Generic.ICollection`1[T] Values[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,T]] ToSeq[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpMap`2[TKey,T],Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]] Partition[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Tuple`2[TKey,T] MaxKeyValue[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Tuple`2[TKey,T] MinKeyValue[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Tuple`2[TKey,T][] ToArray[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: T Find[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: TKey FindKey[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: TResult Pick[TKey,T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: TState FoldBack[TKey,T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T], TState)
+Microsoft.FSharp.Collections.MapModule: TState Fold[TKey,T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]]], TState, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Void Iterate[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.SeqModule: Boolean Contains[T](T, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Boolean Exists2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Boolean ForAll2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Boolean IsEmpty[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Int32 CompareWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Int32 FindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Int32 FindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Int32 Length[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryExactlyOne[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryHead[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryItem[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryLast[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Collections.Generic.IEnumerable`1[T]] Transpose[TCollection,T](System.Collections.Generic.IEnumerable`1[TCollection])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[System.Int32,T]] Indexed[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[T,T]] Pairwise[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[T1,T2]] AllPairs[T1,T2](System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[T1,T2]] Zip[T1,T2](System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,System.Collections.Generic.IEnumerable`1[T]]] GroupBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,System.Int32]] CountBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`3[T1,T2,T3]] Zip3[T1,T2,T3](System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2], System.Collections.Generic.IEnumerable`1[T3])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Collect[T,TCollection,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TCollection], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2], System.Collections.Generic.IEnumerable`1[T3])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] MapIndexed2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TState] ScanBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], System.Collections.Generic.IEnumerable`1[T], TState)
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TState] Scan[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T[]] ChunkBySize[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T[]] SplitInto[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T[]] Windowed[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Append[T](System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Cache[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Cast[T](System.Collections.IEnumerable)
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Concat[TCollection,T](System.Collections.Generic.IEnumerable`1[TCollection])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Delay[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Collections.Generic.IEnumerable`1[T]])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] DistinctBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Distinct[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Empty[T]()
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Except[T](System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] InitializeInfinite[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] InsertAt[T](Int32, T, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] InsertManyAt[T](Int32, System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] OfArray[T](T[])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] OfList[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Permute[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.Int32], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] ReadOnly[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RemoveAt[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RemoveManyAt[T](Int32, Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Replicate[T](Int32, T)
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Reverse[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Singleton[T](T)
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SkipWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Skip[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortByDescending[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortDescending[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Sort[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Tail[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] TakeWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Take[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Truncate[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Unfold[TState,T](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[T,TState]]], TState)
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] UpdateAt[T](Int32, T, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Where[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Tuple`2[System.Collections.Generic.IEnumerable`1[TResult],TState] MapFoldBack[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,System.Tuple`2[TResult,TState]]], System.Collections.Generic.IEnumerable`1[T], TState)
+Microsoft.FSharp.Collections.SeqModule: System.Tuple`2[System.Collections.Generic.IEnumerable`1[TResult],TState] MapFold[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Tuple`2[TResult,TState]]], TState, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Average$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Average[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T ExactlyOne[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T FindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Find[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Get[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Head[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Item[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Last[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T MaxBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Max[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T MinBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Min[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T ReduceBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Reduce[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Sum$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Sum[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: TResult AverageBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: TResult AverageBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: TResult Pick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: TResult SumBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: TResult SumBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: TState Fold2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TState]]], TState, System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: TState FoldBack2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2], TState)
+Microsoft.FSharp.Collections.SeqModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], System.Collections.Generic.IEnumerable`1[T], TState)
+Microsoft.FSharp.Collections.SeqModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T[] ToArray[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Void Iterate2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: Void IterateIndexed2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean Contains[T](T, Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean IsEmpty[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean IsProperSubset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean IsProperSuperset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean IsSubset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean IsSuperset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Int32 Count[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Add[T](T, Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Difference[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Empty[T]()
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] IntersectMany[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpSet`1[T]])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Intersect[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] OfArray[T](T[])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] OfList[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] OfSeq[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Remove[T](T, Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Singleton[T](T)
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] UnionMany[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpSet`1[T]])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Union[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: System.Collections.Generic.IEnumerable`1[T] ToSeq[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpSet`1[T],Microsoft.FSharp.Collections.FSharpSet`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: T MaxElement[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: T MinElement[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Collections.FSharpSet`1[T], TState)
+Microsoft.FSharp.Collections.SetModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: T[] ToArray[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Boolean IsCancellationRequested
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Boolean get_IsCancellationRequested()
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn OnCancellation()
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn OnSuccess(T)
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn Success(Microsoft.FSharp.Control.AsyncActivation`1[T], T)
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Void OnExceptionRaised()
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn Bind[T,TResult](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn CallThenInvoke[T,TResult](Microsoft.FSharp.Control.AsyncActivation`1[T], TResult, Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn Invoke[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Control.AsyncActivation`1[T])
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn TryFinally[T](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn TryWith[T](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]])
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.FSharpAsync`1[T] MakeAsync[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.AsyncActivation`1[T],Microsoft.FSharp.Control.AsyncReturn])
+Microsoft.FSharp.Control.BackgroundTaskBuilder: System.Threading.Tasks.Task`1[T] RunDynamic[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
+Microsoft.FSharp.Control.BackgroundTaskBuilder: System.Threading.Tasks.Task`1[T] Run[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
+Microsoft.FSharp.Control.CommonExtensions: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AsyncWrite(System.IO.Stream, Byte[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.CommonExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Byte[]] AsyncReadBytes(System.IO.Stream, Int32)
+Microsoft.FSharp.Control.CommonExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Int32] AsyncRead(System.IO.Stream, Byte[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.CommonExtensions: System.IDisposable SubscribeToObservable[T](System.IObservable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.CommonExtensions: Void AddToObservable[T](System.IObservable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[System.Tuple`2[T,T]],System.Tuple`2[T,T]] Pairwise[TDel,T](Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult],TResult] Choose[T,TResult,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult],TResult] Map[T,TResult,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult],TResult] Scan[TResult,T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], TResult, Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] Filter[T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] Merge[TDel1,T,TDel2](Microsoft.FSharp.Control.IEvent`2[TDel1,T], Microsoft.FSharp.Control.IEvent`2[TDel2,T])
+Microsoft.FSharp.Control.EventModule: System.Tuple`2[Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult1],TResult1],Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult2],TResult2]] Split[T,TResult1,TResult2,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[TResult1,TResult2]], Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: System.Tuple`2[Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T],Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T]] Partition[T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: Void Add[T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Control.FSharpAsync`1[T]] StartChild[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpChoice`2[T,System.Exception]] Catch[T](Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[T]] Choice[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[T]]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AwaitTask(System.Threading.Tasks.Task)
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Ignore[T](Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Sleep(Int32)
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Sleep(System.TimeSpan)
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] SwitchToContext(System.Threading.SynchronizationContext)
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] SwitchToNewThread()
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] SwitchToThreadPool()
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Boolean] AwaitIAsyncResult(System.IAsyncResult, Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Boolean] AwaitWaitHandle(System.Threading.WaitHandle, Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.IDisposable] OnCancel(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Threading.CancellationToken] CancellationToken
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Threading.CancellationToken] get_CancellationToken()
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Threading.Tasks.Task`1[T]] StartChildAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.Tasks.TaskCreationOptions])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Parallel[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Parallel[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Sequential[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitEvent[TDel,T](Microsoft.FSharp.Control.IEvent`2[TDel,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitTask[T](System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,TArg2,TArg3,T](TArg1, TArg2, TArg3, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`5[TArg1,TArg2,TArg3,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,TArg2,T](TArg1, TArg2, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`4[TArg1,TArg2,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,T](TArg1, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[TArg1,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromContinuations[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit],Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.Unit],Microsoft.FSharp.Core.FSharpFunc`2[System.OperationCanceledException,Microsoft.FSharp.Core.Unit]],Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] TryCancelled[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.OperationCanceledException,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.FSharpAsync: System.Threading.CancellationToken DefaultCancellationToken
+Microsoft.FSharp.Control.FSharpAsync: System.Threading.CancellationToken get_DefaultCancellationToken()
+Microsoft.FSharp.Control.FSharpAsync: System.Threading.Tasks.Task`1[T] StartAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.Tasks.TaskCreationOptions], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsync: System.Threading.Tasks.Task`1[T] StartImmediateAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsync: System.Tuple`3[Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[TArg,System.AsyncCallback,System.Object],System.IAsyncResult],Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T],Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,Microsoft.FSharp.Core.Unit]] AsBeginEnd[TArg,T](Microsoft.FSharp.Core.FSharpFunc`2[TArg,Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.FSharpAsync: T RunSynchronously[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsync: Void CancelDefaultToken()
+Microsoft.FSharp.Control.FSharpAsync: Void Start(Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsync: Void StartImmediate(Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsync: Void StartWithContinuations[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[System.OperationCanceledException,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] For[T](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] While(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Zero()
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Bind[T,TResult](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[TResult]])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Using[T,TResult](T, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[TResult]])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] Combine[T](Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] Delay[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] ReturnFrom[T](Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] Return[T](T)
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] TryFinally[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] TryWith[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply]: Void Reply(TReply)
+Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate] Publish
+Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate] get_Publish()
+Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Void .ctor()
+Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Void Trigger(System.Object[])
+Microsoft.FSharp.Control.FSharpEvent`1[T]: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] Publish
+Microsoft.FSharp.Control.FSharpEvent`1[T]: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] get_Publish()
+Microsoft.FSharp.Control.FSharpEvent`1[T]: Void .ctor()
+Microsoft.FSharp.Control.FSharpEvent`1[T]: Void Trigger(T)
+Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Microsoft.FSharp.Control.IEvent`2[TDelegate,TArgs] Publish
+Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Microsoft.FSharp.Control.IEvent`2[TDelegate,TArgs] get_Publish()
+Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Void .ctor()
+Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Void Trigger(System.Object, TArgs)
+Microsoft.FSharp.Control.FSharpHandler`1[T]: System.IAsyncResult BeginInvoke(System.Object, T, System.AsyncCallback, System.Object)
+Microsoft.FSharp.Control.FSharpHandler`1[T]: Void .ctor(System.Object, IntPtr)
+Microsoft.FSharp.Control.FSharpHandler`1[T]: Void EndInvoke(System.IAsyncResult)
+Microsoft.FSharp.Control.FSharpHandler`1[T]: Void Invoke(System.Object, T)
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 CurrentQueueLength
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 DefaultTimeout
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 get_CurrentQueueLength()
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 get_DefaultTimeout()
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[TMsg]] TryReceive(Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[TReply]] PostAndTryAsyncReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[T]] TryScan[T](Microsoft.FSharp.Core.FSharpFunc`2[TMsg,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[TMsg] Receive(Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[TReply] PostAndAsyncReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[T] Scan[T](Microsoft.FSharp.Core.FSharpFunc`2[TMsg,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpHandler`1[System.Exception] Error
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg] Start(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg],Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Core.FSharpOption`1[TReply] TryPostAndReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: TReply PostAndReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void .ctor(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg],Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void Post(TMsg)
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void Start()
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void add_Error(Microsoft.FSharp.Control.FSharpHandler`1[System.Exception])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void remove_Error(Microsoft.FSharp.Control.FSharpHandler`1[System.Exception])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void set_DefaultTimeout(Int32)
+Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate]: Void AddHandler(TDelegate)
+Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate]: Void RemoveHandler(TDelegate)
+Microsoft.FSharp.Control.LazyExtensions: System.Lazy`1[T] CreateFromValue[T](T)
+Microsoft.FSharp.Control.LazyExtensions: System.Lazy`1[T] Create[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T])
+Microsoft.FSharp.Control.LazyExtensions: T Force[T](System.Lazy`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IDisposable Subscribe[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[System.Tuple`2[T,T]] Pairwise[T](System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[TResult] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[TResult] Scan[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], TResult, System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[T] Merge[T](System.IObservable`1[T], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.Tuple`2[System.IObservable`1[TResult1],System.IObservable`1[TResult2]] Split[T,TResult1,TResult2](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[TResult1,TResult2]], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.Tuple`2[System.IObservable`1[T],System.IObservable`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: Void Add[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], System.IObservable`1[T])
+Microsoft.FSharp.Control.TaskBuilder: System.Threading.Tasks.Task`1[T] RunDynamic[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
+Microsoft.FSharp.Control.TaskBuilder: System.Threading.Tasks.Task`1[T] Run[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit] For[T,TOverall](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit] While[TOverall](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit] Zero[TOverall]()
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] Combine[TOverall,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] Delay[TOverall,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] TryFinally[TOverall,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] TryWith[TOverall,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] Return[T](T)
+Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority: Boolean TaskBuilderBase.BindDynamic.Static[TOverall,TResult1,TResult2](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall]] ByRef, System.Threading.Tasks.Task`1[TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind[TResult1,TOverall,TResult2](Microsoft.FSharp.Control.TaskBuilderBase, System.Threading.Tasks.Task`1[TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom[T](Microsoft.FSharp.Control.TaskBuilderBase, System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Boolean TaskBuilderBase.BindDynamic.Static$W[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike,TAwaiter], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall]] ByRef, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Boolean TaskBuilderBase.BindDynamic.Static[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall]] ByRef, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind$W[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike,TAwaiter], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,System.Boolean], Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] TaskBuilderBase.Using[TResource,TOverall,T](Microsoft.FSharp.Control.TaskBuilderBase, TResource, Microsoft.FSharp.Core.FSharpFunc`2[TResource,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom$W[TTaskLike,TAwaiter,T](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike,TAwaiter], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,T], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,System.Boolean], Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike)
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom[TTaskLike,TAwaiter,T](Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike)
+Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind[TResult1,TOverall,TResult2](Microsoft.FSharp.Control.TaskBuilderBase, Microsoft.FSharp.Control.FSharpAsync`1[TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom[T](Microsoft.FSharp.Control.TaskBuilderBase, Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.BackgroundTaskBuilder backgroundTask
+Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.BackgroundTaskBuilder get_backgroundTask()
+Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.TaskBuilder get_task()
+Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.TaskBuilder task
+Microsoft.FSharp.Control.TaskStateMachineData`1[T]: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1[T] MethodBuilder
+Microsoft.FSharp.Control.TaskStateMachineData`1[T]: T Result
+Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AsyncDownloadFile(System.Net.WebClient, System.Uri, System.String)
+Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Byte[]] AsyncDownloadData(System.Net.WebClient, System.Uri)
+Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Net.WebResponse] AsyncGetResponse(System.Net.WebRequest)
+Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.String] AsyncDownloadString(System.Net.WebClient, System.Uri)
+Microsoft.FSharp.Core.AbstractClassAttribute: Void .ctor()
+Microsoft.FSharp.Core.AllowNullLiteralAttribute: Boolean Value
+Microsoft.FSharp.Core.AllowNullLiteralAttribute: Boolean get_Value()
+Microsoft.FSharp.Core.AllowNullLiteralAttribute: Void .ctor()
+Microsoft.FSharp.Core.AllowNullLiteralAttribute: Void .ctor(Boolean)
+Microsoft.FSharp.Core.AutoOpenAttribute: System.String Path
+Microsoft.FSharp.Core.AutoOpenAttribute: System.String get_Path()
+Microsoft.FSharp.Core.AutoOpenAttribute: Void .ctor()
+Microsoft.FSharp.Core.AutoOpenAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.AutoSerializableAttribute: Boolean Value
+Microsoft.FSharp.Core.AutoSerializableAttribute: Boolean get_Value()
+Microsoft.FSharp.Core.AutoSerializableAttribute: Void .ctor(Boolean)
+Microsoft.FSharp.Core.ByRefKinds: Microsoft.FSharp.Core.ByRefKinds+In
+Microsoft.FSharp.Core.ByRefKinds: Microsoft.FSharp.Core.ByRefKinds+InOut
+Microsoft.FSharp.Core.ByRefKinds: Microsoft.FSharp.Core.ByRefKinds+Out
+Microsoft.FSharp.Core.CLIEventAttribute: Void .ctor()
+Microsoft.FSharp.Core.CLIMutableAttribute: Void .ctor()
+Microsoft.FSharp.Core.ClassAttribute: Void .ctor()
+Microsoft.FSharp.Core.ComparisonConditionalOnAttribute: Void .ctor()
+Microsoft.FSharp.Core.CompilationArgumentCountsAttribute: System.Collections.Generic.IEnumerable`1[System.Int32] Counts
+Microsoft.FSharp.Core.CompilationArgumentCountsAttribute: System.Collections.Generic.IEnumerable`1[System.Int32] get_Counts()
+Microsoft.FSharp.Core.CompilationArgumentCountsAttribute: Void .ctor(Int32[])
+Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 SequenceNumber
+Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 VariantNumber
+Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 get_SequenceNumber()
+Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 get_VariantNumber()
+Microsoft.FSharp.Core.CompilationMappingAttribute: Microsoft.FSharp.Core.SourceConstructFlags SourceConstructFlags
+Microsoft.FSharp.Core.CompilationMappingAttribute: Microsoft.FSharp.Core.SourceConstructFlags get_SourceConstructFlags()
+Microsoft.FSharp.Core.CompilationMappingAttribute: System.String ResourceName
+Microsoft.FSharp.Core.CompilationMappingAttribute: System.String get_ResourceName()
+Microsoft.FSharp.Core.CompilationMappingAttribute: System.Type[] TypeDefinitions
+Microsoft.FSharp.Core.CompilationMappingAttribute: System.Type[] get_TypeDefinitions()
+Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(Microsoft.FSharp.Core.SourceConstructFlags)
+Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(Microsoft.FSharp.Core.SourceConstructFlags, Int32)
+Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(Microsoft.FSharp.Core.SourceConstructFlags, Int32, Int32)
+Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(System.String, System.Type[])
+Microsoft.FSharp.Core.CompilationRepresentationAttribute: Microsoft.FSharp.Core.CompilationRepresentationFlags Flags
+Microsoft.FSharp.Core.CompilationRepresentationAttribute: Microsoft.FSharp.Core.CompilationRepresentationFlags get_Flags()
+Microsoft.FSharp.Core.CompilationRepresentationAttribute: Void .ctor(Microsoft.FSharp.Core.CompilationRepresentationFlags)
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Int32 value__
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags Event
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags Instance
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags ModuleSuffix
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags None
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags Static
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags UseNullAsTrueValue
+Microsoft.FSharp.Core.CompilationSourceNameAttribute: System.String SourceName
+Microsoft.FSharp.Core.CompilationSourceNameAttribute: System.String get_SourceName()
+Microsoft.FSharp.Core.CompilationSourceNameAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.CompiledNameAttribute: System.String CompiledName
+Microsoft.FSharp.Core.CompiledNameAttribute: System.String get_CompiledName()
+Microsoft.FSharp.Core.CompiledNameAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean IsError
+Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean IsHidden
+Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean get_IsError()
+Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean get_IsHidden()
+Microsoft.FSharp.Core.CompilerMessageAttribute: Int32 MessageNumber
+Microsoft.FSharp.Core.CompilerMessageAttribute: Int32 get_MessageNumber()
+Microsoft.FSharp.Core.CompilerMessageAttribute: System.String Message
+Microsoft.FSharp.Core.CompilerMessageAttribute: System.String get_Message()
+Microsoft.FSharp.Core.CompilerMessageAttribute: Void .ctor(System.String, Int32)
+Microsoft.FSharp.Core.CompilerMessageAttribute: Void set_IsError(Boolean)
+Microsoft.FSharp.Core.CompilerMessageAttribute: Void set_IsHidden(Boolean)
+Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object)
+Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: TResult EndInvoke(System.IAsyncResult)
+Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: TResult Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
+Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: Void .ctor(System.Object, IntPtr)
+Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: T[] AddManyAndClose(System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: T[] Close()
+Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: Void Add(T)
+Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: Void AddMany(System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Boolean CheckClose
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Boolean get_CheckClose()
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Int32 GenerateNext(System.Collections.Generic.IEnumerable`1[T] ByRef)
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: System.Collections.Generic.IEnumerator`1[T] GetFreshEnumerator()
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: T LastGenerated
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: T get_LastGenerated()
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Void .ctor()
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Void Close()
+Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace[] GetNestedNamespaces()
+Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.String NamespaceName
+Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.String get_NamespaceName()
+Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.Type ResolveTypeName(System.String)
+Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.Type[] GetTypes()
+Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: Int32 ResumptionPoint
+Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: Int32 get_ResumptionPoint()
+Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: TData Data
+Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: TData get_Data()
+Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: Void set_Data(TData)
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider2: System.Reflection.MethodBase ApplyStaticArgumentsForMethod(System.Reflection.MethodBase, System.String, System.Object[])
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider2: System.Reflection.ParameterInfo[] GetStaticParametersForMethod(System.Reflection.MethodBase)
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Byte[] GetGeneratedAssemblyContents(System.Reflection.Assembly)
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace[] GetNamespaces()
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Microsoft.FSharp.Quotations.FSharpExpr GetInvokerExpression(System.Reflection.MethodBase, Microsoft.FSharp.Quotations.FSharpExpr[])
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: System.EventHandler Invalidate
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: System.Reflection.ParameterInfo[] GetStaticParameters(System.Type)
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: System.Type ApplyStaticArguments(System.Type, System.String[], System.Object[])
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Void add_Invalidate(System.EventHandler)
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Void remove_Invalidate(System.EventHandler)
+Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] AddManyAndClose(System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Close()
+Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Void Add(T)
+Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Void AddMany(System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object)
+Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: Void .ctor(System.Object, IntPtr)
+Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: Void EndInvoke(System.IAsyncResult)
+Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: Void Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
+Microsoft.FSharp.Core.CompilerServices.NoEagerConstraintApplicationAttribute: Void .ctor()
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean CombineDynamic[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean TryFinallyAsyncDynamic[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean TryWithDynamic[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean WhileDynamic[TData](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean YieldDynamic[TData](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] For[T,TData](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] While[TData](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] Yield[TData]()
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] Zero[TData]()
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] Combine[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] Delay[TData,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] TryFinallyAsync[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] TryFinally[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] TryWith[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] Using[TResource,TData,T](TResource, Microsoft.FSharp.Core.FSharpFunc`2[TResource,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: Boolean EndInvoke(System.IAsyncResult)
+Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: Boolean Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
+Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object)
+Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: Void .ctor(System.Object, IntPtr)
+Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData]: Int32 ResumptionPoint
+Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData]: Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData] ResumptionDynamicInfo
+Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData]: TData Data
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData] ResumptionFunc
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData] get_ResumptionFunc()
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: System.Object ResumptionData
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: System.Object get_ResumptionData()
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void .ctor(Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData])
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void MoveNext(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void SetStateMachine(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine)
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void set_ResumptionData(System.Object)
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void set_ResumptionFunc(Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData])
+Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: Boolean EndInvoke(System.IAsyncResult)
+Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: Boolean Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
+Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object)
+Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: Void .ctor(System.Object, IntPtr)
+Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: Microsoft.FSharp.Control.IEvent`2[TDelegate,TArgs] CreateEvent[TDelegate,TArgs](Microsoft.FSharp.Core.FSharpFunc`2[TDelegate,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[TDelegate,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpFunc`2[System.Object,Microsoft.FSharp.Core.FSharpFunc`2[TArgs,Microsoft.FSharp.Core.Unit]],TDelegate])
+Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[TResult] EnumerateFromFunctions[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
+Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[TResult] EnumerateUsing[T,TCollection,TResult](T, Microsoft.FSharp.Core.FSharpFunc`2[T,TCollection])
+Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[T] EnumerateThenFinally[T](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[T] EnumerateWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine, System.AsyncCallback, System.Object)
+Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void .ctor(System.Object, IntPtr)
+Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void EndInvoke(System.IAsyncResult)
+Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine)
+Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Boolean __useResumableCode[T]()
+Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] __resumableEntry()
+Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: T __resumeAt[T](Int32)
+Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: TResult __stateMachine[TData,TResult](Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult])
+Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Void __debugPoint(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: System.String AssemblyName
+Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: System.String get_AssemblyName()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: Void .ctor()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderAttribute: Void .ctor()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean IsHostedExecution
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean IsInvalidationSupported
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean SystemRuntimeContainsType(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean get_IsHostedExecution()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean get_IsInvalidationSupported()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String ResolutionFolder
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String RuntimeAssembly
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String TemporaryFolder
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String get_ResolutionFolder()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String get_RuntimeAssembly()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String get_TemporaryFolder()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String[] ReferencedAssemblies
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String[] get_ReferencedAssemblies()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.Version SystemRuntimeAssemblyVersion
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.Version get_SystemRuntimeAssemblyVersion()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void .ctor(Microsoft.FSharp.Core.FSharpFunc`2[System.String,System.Boolean])
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void .ctor(Microsoft.FSharp.Core.FSharpFunc`2[System.String,System.Boolean], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.String[]])
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_IsHostedExecution(Boolean)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_IsInvalidationSupported(Boolean)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_ReferencedAssemblies(System.String[])
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_ResolutionFolder(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_RuntimeAssembly(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_SystemRuntimeAssemblyVersion(System.Version)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_TemporaryFolder(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 Column
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 Line
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 get_Column()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 get_Line()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: System.String FilePath
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: System.String get_FilePath()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void .ctor()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void set_Column(Int32)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void set_FilePath(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void set_Line(Int32)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderEditorHideMethodsAttribute: Void .ctor()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes: Int32 value__
+Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes: Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes IsErased
+Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes: Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes SuppressRelocate
+Microsoft.FSharp.Core.CompilerServices.TypeProviderXmlDocAttribute: System.String CommentText
+Microsoft.FSharp.Core.CompilerServices.TypeProviderXmlDocAttribute: System.String get_CommentText()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderXmlDocAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.CustomComparisonAttribute: Void .ctor()
+Microsoft.FSharp.Core.CustomEqualityAttribute: Void .ctor()
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean AllowIntoPattern
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean IsLikeGroupJoin
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean IsLikeJoin
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean IsLikeZip
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean MaintainsVariableSpace
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean MaintainsVariableSpaceUsingBind
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_AllowIntoPattern()
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_IsLikeGroupJoin()
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_IsLikeJoin()
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_IsLikeZip()
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_MaintainsVariableSpace()
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_MaintainsVariableSpaceUsingBind()
+Microsoft.FSharp.Core.CustomOperationAttribute: System.String JoinConditionWord
+Microsoft.FSharp.Core.CustomOperationAttribute: System.String Name
+Microsoft.FSharp.Core.CustomOperationAttribute: System.String get_JoinConditionWord()
+Microsoft.FSharp.Core.CustomOperationAttribute: System.String get_Name()
+Microsoft.FSharp.Core.CustomOperationAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_AllowIntoPattern(Boolean)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_IsLikeGroupJoin(Boolean)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_IsLikeJoin(Boolean)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_IsLikeZip(Boolean)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_JoinConditionWord(System.String)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_MaintainsVariableSpace(Boolean)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_MaintainsVariableSpaceUsingBind(Boolean)
+Microsoft.FSharp.Core.DefaultAugmentationAttribute: Boolean Value
+Microsoft.FSharp.Core.DefaultAugmentationAttribute: Boolean get_Value()
+Microsoft.FSharp.Core.DefaultAugmentationAttribute: Void .ctor(Boolean)
+Microsoft.FSharp.Core.DefaultValueAttribute: Boolean Check
+Microsoft.FSharp.Core.DefaultValueAttribute: Boolean get_Check()
+Microsoft.FSharp.Core.DefaultValueAttribute: Void .ctor()
+Microsoft.FSharp.Core.DefaultValueAttribute: Void .ctor(Boolean)
+Microsoft.FSharp.Core.EntryPointAttribute: Void .ctor()
+Microsoft.FSharp.Core.EqualityConditionalOnAttribute: Void .ctor()
+Microsoft.FSharp.Core.ExperimentalAttribute: System.String Message
+Microsoft.FSharp.Core.ExperimentalAttribute: System.String get_Message()
+Microsoft.FSharp.Core.ExperimentalAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: Byte ToByte[T](T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: SByte ToSByte[T](T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Byte ToByte[T](T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Double ToDouble$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Double ToDouble[T](T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Collections.FSharpSet`1[T] CreateSet[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Control.FSharpAsyncBuilder DefaultAsyncBuilder
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Control.FSharpAsyncBuilder get_DefaultAsyncBuilder()
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Linq.QueryBuilder get_query()
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Linq.QueryBuilder query
+Microsoft.FSharp.Core.ExtraTopLevelOperators: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: SByte ToSByte[T](T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Single ToSingle$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Single ToSingle[T](T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: System.Collections.Generic.IDictionary`2[TKey,TValue] CreateDictionary[TKey,TValue](System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,TValue]])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: System.Collections.Generic.IReadOnlyDictionary`2[TKey,TValue] CreateReadOnlyDictionary[TKey,TValue](System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,TValue]])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T LazyPattern[T](System.Lazy`1[T])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatLineToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatLineToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatLine[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToStringThenFail[T,TResult](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToString[T](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,System.String])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormat[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T SpliceExpression[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T SpliceUntypedExpression[T](Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T[,] CreateArray2D[?,T](System.Collections.Generic.IEnumerable`1[?])
+Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]: T1 Item
+Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]: T1 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2]: T2 Item
+Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2]: T2 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`2+Tags[T1,T2]: Int32 Choice1Of2
+Microsoft.FSharp.Core.FSharpChoice`2+Tags[T1,T2]: Int32 Choice2Of2
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`2[T1,T2])
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean IsChoice1Of2
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean IsChoice2Of2
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean get_IsChoice1Of2()
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean get_IsChoice2Of2()
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`2[T1,T2])
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 Tag
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2]
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2+Tags[T1,T2]
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2[T1,T2] NewChoice1Of2(T1)
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2[T1,T2] NewChoice2Of2(T2)
+Microsoft.FSharp.Core.FSharpChoice`3+Choice1Of3[T1,T2,T3]: T1 Item
+Microsoft.FSharp.Core.FSharpChoice`3+Choice1Of3[T1,T2,T3]: T1 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`3+Choice2Of3[T1,T2,T3]: T2 Item
+Microsoft.FSharp.Core.FSharpChoice`3+Choice2Of3[T1,T2,T3]: T2 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`3+Choice3Of3[T1,T2,T3]: T3 Item
+Microsoft.FSharp.Core.FSharpChoice`3+Choice3Of3[T1,T2,T3]: T3 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]: Int32 Choice1Of3
+Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]: Int32 Choice2Of3
+Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]: Int32 Choice3Of3
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3])
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean IsChoice1Of3
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean IsChoice2Of3
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean IsChoice3Of3
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean get_IsChoice1Of3()
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean get_IsChoice2Of3()
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean get_IsChoice3Of3()
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3])
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 Tag
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Choice1Of3[T1,T2,T3]
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Choice2Of3[T1,T2,T3]
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Choice3Of3[T1,T2,T3]
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3] NewChoice1Of3(T1)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3] NewChoice2Of3(T2)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3] NewChoice3Of3(T3)
+Microsoft.FSharp.Core.FSharpChoice`4+Choice1Of4[T1,T2,T3,T4]: T1 Item
+Microsoft.FSharp.Core.FSharpChoice`4+Choice1Of4[T1,T2,T3,T4]: T1 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`4+Choice2Of4[T1,T2,T3,T4]: T2 Item
+Microsoft.FSharp.Core.FSharpChoice`4+Choice2Of4[T1,T2,T3,T4]: T2 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`4+Choice3Of4[T1,T2,T3,T4]: T3 Item
+Microsoft.FSharp.Core.FSharpChoice`4+Choice3Of4[T1,T2,T3,T4]: T3 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`4+Choice4Of4[T1,T2,T3,T4]: T4 Item
+Microsoft.FSharp.Core.FSharpChoice`4+Choice4Of4[T1,T2,T3,T4]: T4 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice1Of4
+Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice2Of4
+Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice3Of4
+Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice4Of4
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4])
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice1Of4
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice2Of4
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice3Of4
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice4Of4
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice1Of4()
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice2Of4()
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice3Of4()
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice4Of4()
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4])
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 Tag
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice1Of4[T1,T2,T3,T4]
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice2Of4[T1,T2,T3,T4]
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice3Of4[T1,T2,T3,T4]
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice4Of4[T1,T2,T3,T4]
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice1Of4(T1)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice2Of4(T2)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice3Of4(T3)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice4Of4(T4)
+Microsoft.FSharp.Core.FSharpChoice`5+Choice1Of5[T1,T2,T3,T4,T5]: T1 Item
+Microsoft.FSharp.Core.FSharpChoice`5+Choice1Of5[T1,T2,T3,T4,T5]: T1 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`5+Choice2Of5[T1,T2,T3,T4,T5]: T2 Item
+Microsoft.FSharp.Core.FSharpChoice`5+Choice2Of5[T1,T2,T3,T4,T5]: T2 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`5+Choice3Of5[T1,T2,T3,T4,T5]: T3 Item
+Microsoft.FSharp.Core.FSharpChoice`5+Choice3Of5[T1,T2,T3,T4,T5]: T3 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`5+Choice4Of5[T1,T2,T3,T4,T5]: T4 Item
+Microsoft.FSharp.Core.FSharpChoice`5+Choice4Of5[T1,T2,T3,T4,T5]: T4 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`5+Choice5Of5[T1,T2,T3,T4,T5]: T5 Item
+Microsoft.FSharp.Core.FSharpChoice`5+Choice5Of5[T1,T2,T3,T4,T5]: T5 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice1Of5
+Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice2Of5
+Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice3Of5
+Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice4Of5
+Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice5Of5
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5])
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice1Of5
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice2Of5
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice3Of5
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice4Of5
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice5Of5
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice1Of5()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice2Of5()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice3Of5()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice4Of5()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice5Of5()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5])
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 Tag
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice1Of5[T1,T2,T3,T4,T5]
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice2Of5[T1,T2,T3,T4,T5]
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice3Of5[T1,T2,T3,T4,T5]
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice4Of5[T1,T2,T3,T4,T5]
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice5Of5[T1,T2,T3,T4,T5]
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice1Of5(T1)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice2Of5(T2)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice3Of5(T3)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice4Of5(T4)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice5Of5(T5)
+Microsoft.FSharp.Core.FSharpChoice`6+Choice1Of6[T1,T2,T3,T4,T5,T6]: T1 Item
+Microsoft.FSharp.Core.FSharpChoice`6+Choice1Of6[T1,T2,T3,T4,T5,T6]: T1 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`6+Choice2Of6[T1,T2,T3,T4,T5,T6]: T2 Item
+Microsoft.FSharp.Core.FSharpChoice`6+Choice2Of6[T1,T2,T3,T4,T5,T6]: T2 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`6+Choice3Of6[T1,T2,T3,T4,T5,T6]: T3 Item
+Microsoft.FSharp.Core.FSharpChoice`6+Choice3Of6[T1,T2,T3,T4,T5,T6]: T3 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`6+Choice4Of6[T1,T2,T3,T4,T5,T6]: T4 Item
+Microsoft.FSharp.Core.FSharpChoice`6+Choice4Of6[T1,T2,T3,T4,T5,T6]: T4 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`6+Choice5Of6[T1,T2,T3,T4,T5,T6]: T5 Item
+Microsoft.FSharp.Core.FSharpChoice`6+Choice5Of6[T1,T2,T3,T4,T5,T6]: T5 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`6+Choice6Of6[T1,T2,T3,T4,T5,T6]: T6 Item
+Microsoft.FSharp.Core.FSharpChoice`6+Choice6Of6[T1,T2,T3,T4,T5,T6]: T6 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice1Of6
+Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice2Of6
+Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice3Of6
+Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice4Of6
+Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice5Of6
+Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice6Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6])
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice1Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice2Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice3Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice4Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice5Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice6Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice1Of6()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice2Of6()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice3Of6()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice4Of6()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice5Of6()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice6Of6()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6])
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 Tag
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice1Of6[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice2Of6[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice3Of6[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice4Of6[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice5Of6[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice6Of6[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice1Of6(T1)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice2Of6(T2)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice3Of6(T3)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice4Of6(T4)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice5Of6(T5)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice6Of6(T6)
+Microsoft.FSharp.Core.FSharpChoice`7+Choice1Of7[T1,T2,T3,T4,T5,T6,T7]: T1 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice1Of7[T1,T2,T3,T4,T5,T6,T7]: T1 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Choice2Of7[T1,T2,T3,T4,T5,T6,T7]: T2 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice2Of7[T1,T2,T3,T4,T5,T6,T7]: T2 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Choice3Of7[T1,T2,T3,T4,T5,T6,T7]: T3 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice3Of7[T1,T2,T3,T4,T5,T6,T7]: T3 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Choice4Of7[T1,T2,T3,T4,T5,T6,T7]: T4 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice4Of7[T1,T2,T3,T4,T5,T6,T7]: T4 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Choice5Of7[T1,T2,T3,T4,T5,T6,T7]: T5 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice5Of7[T1,T2,T3,T4,T5,T6,T7]: T5 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Choice6Of7[T1,T2,T3,T4,T5,T6,T7]: T6 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice6Of7[T1,T2,T3,T4,T5,T6,T7]: T6 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Choice7Of7[T1,T2,T3,T4,T5,T6,T7]: T7 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice7Of7[T1,T2,T3,T4,T5,T6,T7]: T7 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice1Of7
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice2Of7
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice3Of7
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice4Of7
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice5Of7
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice6Of7
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice7Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7])
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice1Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice2Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice3Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice4Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice5Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice6Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice7Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice1Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice2Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice3Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice4Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice5Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice6Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice7Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7])
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 Tag
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice1Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice2Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice3Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice4Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice5Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice6Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice7Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice1Of7(T1)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice2Of7(T2)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice3Of7(T3)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice4Of7(T4)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice5Of7(T5)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice6Of7(T6)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice7Of7(T7)
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] FromConverter(System.Converter`2[T,TResult])
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] op_Implicit(System.Converter`2[T,TResult])
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: System.Converter`2[T,TResult] ToConverter(Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: System.Converter`2[T,TResult] op_Implicit(Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: TResult Invoke(T)
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: V InvokeFast[V](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,V]], T, TResult)
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Void .ctor()
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: W InvokeFast[V,W](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[V,W]]], T, TResult, V)
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: X InvokeFast[V,W,X](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[V,Microsoft.FSharp.Core.FSharpFunc`2[W,X]]]], T, TResult, V, W)
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Y InvokeFast[V,W,X,Y](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[V,Microsoft.FSharp.Core.FSharpFunc`2[W,Microsoft.FSharp.Core.FSharpFunc`2[X,Y]]]]], T, TResult, V, W, X)
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 Major
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 Minor
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 Release
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 get_Major()
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 get_Minor()
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 get_Release()
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Void .ctor(Int32, Int32, Int32)
+Microsoft.FSharp.Core.FSharpOption`1+Tags[T]: Int32 None
+Microsoft.FSharp.Core.FSharpOption`1+Tags[T]: Int32 Some
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean IsNone
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean IsSome
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean get_IsNone(Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean get_IsSome(Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 GetTag(Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1+Tags[T]
+Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] None
+Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] Some(T)
+Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] get_None()
+Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] op_Implicit(T)
+Microsoft.FSharp.Core.FSharpOption`1[T]: System.String ToString()
+Microsoft.FSharp.Core.FSharpOption`1[T]: T Value
+Microsoft.FSharp.Core.FSharpOption`1[T]: T get_Value()
+Microsoft.FSharp.Core.FSharpOption`1[T]: Void .ctor(T)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpRef`1[T])
+Microsoft.FSharp.Core.FSharpRef`1[T]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpRef`1[T])
+Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpRef`1[T]: T Value
+Microsoft.FSharp.Core.FSharpRef`1[T]: T contents
+Microsoft.FSharp.Core.FSharpRef`1[T]: T contents@
+Microsoft.FSharp.Core.FSharpRef`1[T]: T get_Value()
+Microsoft.FSharp.Core.FSharpRef`1[T]: T get_contents()
+Microsoft.FSharp.Core.FSharpRef`1[T]: Void .ctor(T)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Void set_Value(T)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Void set_contents(T)
+Microsoft.FSharp.Core.FSharpResult`2+Tags[T,TError]: Int32 Error
+Microsoft.FSharp.Core.FSharpResult`2+Tags[T,TError]: Int32 Ok
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean Equals(Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean IsError
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean IsOk
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean get_IsError()
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean get_IsOk()
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 Tag
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Microsoft.FSharp.Core.FSharpResult`2+Tags[T,TError]
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Microsoft.FSharp.Core.FSharpResult`2[T,TError] NewError(TError)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Microsoft.FSharp.Core.FSharpResult`2[T,TError] NewOk(T)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: T ResultValue
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: T get_ResultValue()
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: TError ErrorValue
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: TError get_ErrorValue()
+Microsoft.FSharp.Core.FSharpTypeFunc: System.Object Specialize[T]()
+Microsoft.FSharp.Core.FSharpTypeFunc: Void .ctor()
+Microsoft.FSharp.Core.FSharpValueOption`1+Tags[T]: Int32 ValueNone
+Microsoft.FSharp.Core.FSharpValueOption`1+Tags[T]: Int32 ValueSome
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsNone
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsSome
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsValueNone
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsValueSome
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsNone()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsSome()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsValueNone()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsValueSome()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 Tag
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1+Tags[T]
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] NewValueSome(T)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] None
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] Some(T)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] ValueNone
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] get_None()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] get_ValueNone()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] op_Implicit(T)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: System.String ToString()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: T Item
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: T Value
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: T get_Item()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: T get_Value()
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit] FromAction(System.Action)
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T] FromFunc[T](System.Func`1[T])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit] FromAction[T](System.Action`1[T])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit] ToFSharpFunc[T](System.Action`1[T])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] FromFunc[T,TResult](System.Func`2[T,TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] ToFSharpFunc[T,TResult](System.Converter`2[T,TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,Microsoft.FSharp.Core.Unit]]]]] FromAction[T1,T2,T3,T4,T5](System.Action`5[T1,T2,T3,T4,T5])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]]] FromFunc[T1,T2,T3,T4,T5,TResult](System.Func`6[T1,T2,T3,T4,T5,TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]]] FuncFromTupled[T1,T2,T3,T4,T5,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`5[T1,T2,T3,T4,T5],TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.Unit]]]] FromAction[T1,T2,T3,T4](System.Action`4[T1,T2,T3,T4])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]]] FromFunc[T1,T2,T3,T4,TResult](System.Func`5[T1,T2,T3,T4,TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]]] FuncFromTupled[T1,T2,T3,T4,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`4[T1,T2,T3,T4],TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.Unit]]] FromAction[T1,T2,T3](System.Action`3[T1,T2,T3])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]] FromFunc[T1,T2,T3,TResult](System.Func`4[T1,T2,T3,TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]] FuncFromTupled[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[T1,T2,T3],TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]] FromAction[T1,T2](System.Action`2[T1,T2])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]] FromFunc[T1,T2,TResult](System.Func`3[T1,T2,TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]] FuncFromTupled[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[T1,T2],TResult])
+Microsoft.FSharp.Core.GeneralizableValueAttribute: Void .ctor()
+Microsoft.FSharp.Core.InlineIfLambdaAttribute: Void .ctor()
+Microsoft.FSharp.Core.InterfaceAttribute: Void .ctor()
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String AddressOpNotFirstClassString
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String InputArrayEmptyString
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String InputMustBeNonNegativeString
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String InputSequenceEmptyString
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String NoNegateMinValueString
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_AddressOpNotFirstClassString()
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_InputArrayEmptyString()
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_InputMustBeNonNegativeString()
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_InputSequenceEmptyString()
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_NoNegateMinValueString()
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple2[T1,T2](System.Collections.IEqualityComparer, System.Tuple`2[T1,T2], System.Tuple`2[T1,T2])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple3[T1,T2,T3](System.Collections.IEqualityComparer, System.Tuple`3[T1,T2,T3], System.Tuple`3[T1,T2,T3])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple4[T1,T2,T3,T4](System.Collections.IEqualityComparer, System.Tuple`4[T1,T2,T3,T4], System.Tuple`4[T1,T2,T3,T4])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple5[T1,T2,T3,T4,T5](System.Collections.IEqualityComparer, System.Tuple`5[T1,T2,T3,T4,T5], System.Tuple`5[T1,T2,T3,T4,T5])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericEqualityERIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericEqualityIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericEqualityWithComparerIntrinsic[T](System.Collections.IEqualityComparer, T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericGreaterOrEqualIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericGreaterThanIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericLessOrEqualIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericLessThanIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean PhysicalEqualityIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple2[T1,T2](System.Collections.IComparer, System.Tuple`2[T1,T2], System.Tuple`2[T1,T2])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple3[T1,T2,T3](System.Collections.IComparer, System.Tuple`3[T1,T2,T3], System.Tuple`3[T1,T2,T3])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple4[T1,T2,T3,T4](System.Collections.IComparer, System.Tuple`4[T1,T2,T3,T4], System.Tuple`4[T1,T2,T3,T4])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple5[T1,T2,T3,T4,T5](System.Collections.IComparer, System.Tuple`5[T1,T2,T3,T4,T5], System.Tuple`5[T1,T2,T3,T4,T5])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple2[T1,T2](System.Collections.IEqualityComparer, System.Tuple`2[T1,T2])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple3[T1,T2,T3](System.Collections.IEqualityComparer, System.Tuple`3[T1,T2,T3])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple4[T1,T2,T3,T4](System.Collections.IEqualityComparer, System.Tuple`4[T1,T2,T3,T4])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple5[T1,T2,T3,T4,T5](System.Collections.IEqualityComparer, System.Tuple`5[T1,T2,T3,T4,T5])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericComparisonIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericComparisonWithComparerIntrinsic[T](System.Collections.IComparer, T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericHashIntrinsic[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericHashWithComparerIntrinsic[T](System.Collections.IEqualityComparer, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 LimitedGenericHashIntrinsic[T](Int32, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 PhysicalHashIntrinsic[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Boolean TypeTestFast[T](System.Object)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Boolean TypeTestGeneric[T](System.Object)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Char GetString(System.String, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: System.Decimal MakeDecimal(Int32, Int32, Int32, Boolean, Byte)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T CheckThis[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T CreateInstance[T]()
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray2D[T](T[,], Int32, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray3D[T](T[,,], Int32, Int32, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray4D[T](T[,,,], Int32, Int32, Int32, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray[T](T[], Int32)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T UnboxFast[T](System.Object)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T UnboxGeneric[T](System.Object)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void Dispose[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void FailInit()
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void FailStaticInit()
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray2D[T](T[,], Int32, Int32, T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray3D[T](T[,,], Int32, Int32, Int32, T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray4D[T](T[,,,], Int32, Int32, Int32, Int32, T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray[T](T[], Int32, T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean Or(Boolean, Boolean)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean op_Amp(Boolean, Boolean)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean op_BooleanAnd(Boolean, Boolean)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean op_BooleanOr(Boolean, Boolean)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: IntPtr op_IntegerAddressOf[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: T& op_AddressOf[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericEqualityER[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericEqualityWithComparer[T](System.Collections.IEqualityComparer, T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericEquality[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericGreaterOrEqual[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericGreaterThan[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericLessOrEqual[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericLessThan[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean PhysicalEquality[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Byte ByteWithMeasure(Byte)
+Microsoft.FSharp.Core.LanguagePrimitives: Double FloatWithMeasure(Double)
+Microsoft.FSharp.Core.LanguagePrimitives: Int16 Int16WithMeasure(Int16)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericComparisonWithComparer[T](System.Collections.IComparer, T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericComparison[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericHashWithComparer[T](System.Collections.IEqualityComparer, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericHash[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericLimitedHash[T](Int32, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 Int32WithMeasure(Int32)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 ParseInt32(System.String)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 PhysicalHash[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives: Int64 Int64WithMeasure(Int64)
+Microsoft.FSharp.Core.LanguagePrimitives: Int64 ParseInt64(System.String)
+Microsoft.FSharp.Core.LanguagePrimitives: IntPtr IntPtrWithMeasure(IntPtr)
+Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings
+Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+HashCompare
+Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions
+Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators
+Microsoft.FSharp.Core.LanguagePrimitives: SByte SByteWithMeasure(SByte)
+Microsoft.FSharp.Core.LanguagePrimitives: Single Float32WithMeasure(Single)
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IComparer`1[T] FastGenericComparerFromTable[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IComparer`1[T] FastGenericComparer[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IEqualityComparer`1[T] FastGenericEqualityComparerFromTable[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IEqualityComparer`1[T] FastGenericEqualityComparer[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IEqualityComparer`1[T] FastLimitedGenericEqualityComparer[T](Int32)
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IComparer GenericComparer
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IComparer get_GenericComparer()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer GenericEqualityComparer
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer GenericEqualityERComparer
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer get_GenericEqualityComparer()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer get_GenericEqualityERComparer()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Decimal DecimalWithMeasure(System.Decimal)
+Microsoft.FSharp.Core.LanguagePrimitives: T DivideByInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], T, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives: T DivideByIntDynamic[T](T, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives: T DivideByInt[T](T, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives: T EnumToValue[TEnum,T](TEnum)
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericMaximum[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericMinimum[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericOne$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T])
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericOneDynamic[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericOne[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericZero$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T])
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericZeroDynamic[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericZero[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: TEnum EnumOfValue[T,TEnum](T)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult AdditionDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult BitwiseAndDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult BitwiseOrDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedAdditionDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedExplicitDynamic[T,TResult](T)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedMultiplyDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedSubtractionDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedUnaryNegationDynamic[T,TResult](T)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult DivisionDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult EqualityDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult ExclusiveOrDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult ExplicitDynamic[T,TResult](T)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult GreaterThanDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult GreaterThanOrEqualDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult InequalityDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult LeftShiftDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult LessThanDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult LessThanOrEqualDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult LogicalNotDynamic[T,TResult](T)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult ModulusDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult MultiplyDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult RightShiftDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult SubtractionDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult UnaryNegationDynamic[T,TResult](T)
+Microsoft.FSharp.Core.LanguagePrimitives: UInt16 UInt16WithMeasure(UInt16)
+Microsoft.FSharp.Core.LanguagePrimitives: UInt32 ParseUInt32(System.String)
+Microsoft.FSharp.Core.LanguagePrimitives: UInt32 UInt32WithMeasure(UInt32)
+Microsoft.FSharp.Core.LanguagePrimitives: UInt64 ParseUInt64(System.String)
+Microsoft.FSharp.Core.LanguagePrimitives: UInt64 UInt64WithMeasure(UInt64)
+Microsoft.FSharp.Core.LanguagePrimitives: UIntPtr UIntPtrWithMeasure(UIntPtr)
+Microsoft.FSharp.Core.LiteralAttribute: Void .ctor()
+Microsoft.FSharp.Core.MatchFailureException: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.MatchFailureException: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.MatchFailureException: Int32 Data1
+Microsoft.FSharp.Core.MatchFailureException: Int32 Data2
+Microsoft.FSharp.Core.MatchFailureException: Int32 GetHashCode()
+Microsoft.FSharp.Core.MatchFailureException: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.MatchFailureException: Int32 get_Data1()
+Microsoft.FSharp.Core.MatchFailureException: Int32 get_Data2()
+Microsoft.FSharp.Core.MatchFailureException: System.String Data0
+Microsoft.FSharp.Core.MatchFailureException: System.String Message
+Microsoft.FSharp.Core.MatchFailureException: System.String get_Data0()
+Microsoft.FSharp.Core.MatchFailureException: System.String get_Message()
+Microsoft.FSharp.Core.MatchFailureException: Void .ctor()
+Microsoft.FSharp.Core.MatchFailureException: Void .ctor(System.String, Int32, Int32)
+Microsoft.FSharp.Core.MeasureAnnotatedAbbreviationAttribute: Void .ctor()
+Microsoft.FSharp.Core.MeasureAttribute: Void .ctor()
+Microsoft.FSharp.Core.NoComparisonAttribute: Void .ctor()
+Microsoft.FSharp.Core.NoCompilerInliningAttribute: Void .ctor()
+Microsoft.FSharp.Core.NoDynamicInvocationAttribute: Void .ctor()
+Microsoft.FSharp.Core.NoEqualityAttribute: Void .ctor()
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: System.Object FromInt64Dynamic(Int64)
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: System.Object FromStringDynamic(System.String)
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromInt32[T](Int32)
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromInt64[T](Int64)
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromOne[T]()
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromString[T](System.String)
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromZero[T]()
+Microsoft.FSharp.Core.NumericLiterals: Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI
+Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 String.GetReverseIndex(System.String, Int32, Int32)
+Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 [,,,]`1.GetReverseIndex[T](T[,,,], Int32, Int32)
+Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 [,,]`1.GetReverseIndex[T](T[,,], Int32, Int32)
+Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 [,]`1.GetReverseIndex[T](T[,], Int32, Int32)
+Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 []`1.GetReverseIndex[T](T[], Int32, Int32)
+Microsoft.FSharp.Core.Operators+Checked: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T)
+Microsoft.FSharp.Core.Operators+Checked: Byte ToByte[T](T)
+Microsoft.FSharp.Core.Operators+Checked: Char ToChar$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Char], T)
+Microsoft.FSharp.Core.Operators+Checked: Char ToChar[T](T)
+Microsoft.FSharp.Core.Operators+Checked: Int16 ToInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int16], T)
+Microsoft.FSharp.Core.Operators+Checked: Int16 ToInt16[T](T)
+Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T)
+Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T)
+Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt32[T](T)
+Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt[T](T)
+Microsoft.FSharp.Core.Operators+Checked: Int64 ToInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int64], T)
+Microsoft.FSharp.Core.Operators+Checked: Int64 ToInt64[T](T)
+Microsoft.FSharp.Core.Operators+Checked: IntPtr ToIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.IntPtr], T)
+Microsoft.FSharp.Core.Operators+Checked: IntPtr ToIntPtr[T](T)
+Microsoft.FSharp.Core.Operators+Checked: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T)
+Microsoft.FSharp.Core.Operators+Checked: SByte ToSByte[T](T)
+Microsoft.FSharp.Core.Operators+Checked: T op_UnaryNegation$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators+Checked: T op_UnaryNegation[T](T)
+Microsoft.FSharp.Core.Operators+Checked: T3 op_Addition$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators+Checked: T3 op_Addition[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators+Checked: T3 op_Multiply$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators+Checked: T3 op_Multiply[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators+Checked: T3 op_Subtraction$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators+Checked: T3 op_Subtraction[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators+Checked: UInt16 ToUInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt16], T)
+Microsoft.FSharp.Core.Operators+Checked: UInt16 ToUInt16[T](T)
+Microsoft.FSharp.Core.Operators+Checked: UInt32 ToUInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], T)
+Microsoft.FSharp.Core.Operators+Checked: UInt32 ToUInt32[T](T)
+Microsoft.FSharp.Core.Operators+Checked: UInt64 ToUInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt64], T)
+Microsoft.FSharp.Core.Operators+Checked: UInt64 ToUInt64[T](T)
+Microsoft.FSharp.Core.Operators+Checked: UIntPtr ToUIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UIntPtr], T)
+Microsoft.FSharp.Core.Operators+Checked: UIntPtr ToUIntPtr[T](T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Equality$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Equality[T](T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThan$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThanOrEqual$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThanOrEqual[T,TResult](T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThan[T,TResult](T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Inequality$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Inequality[T](T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThan$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThanOrEqual$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThanOrEqual[T,TResult](T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThan[T,TResult](T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Int32 Compare$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Int32 Compare[T](T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Int32 Hash[T](T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Max$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Max[T](T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Min$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Min[T](T, T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Byte PowByte(Byte, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Double PowDouble(Double, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int16 PowInt16(Int16, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int32 PowInt32(Int32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int32 SignDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int64 PowInt64(Int64, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: IntPtr PowIntPtr(IntPtr, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: SByte PowSByte(SByte, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Single PowSingle(Single, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Byte] RangeByte(Byte, Byte, Byte)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Char] RangeChar(Char, Char)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Double] RangeDouble(Double, Double, Double)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Int16] RangeInt16(Int16, Int16, Int16)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Int32] RangeInt32(Int32, Int32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Int64] RangeInt64(Int64, Int64, Int64)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.IntPtr] RangeIntPtr(IntPtr, IntPtr, IntPtr)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.SByte] RangeSByte(SByte, SByte, SByte)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Single] RangeSingle(Single, Single, Single)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UInt16] RangeUInt16(UInt16, UInt16, UInt16)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UInt32] RangeUInt32(UInt32, UInt32, UInt32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UInt64] RangeUInt64(UInt64, UInt64, UInt64)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UIntPtr] RangeUIntPtr(UIntPtr, UIntPtr, UIntPtr)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[T] RangeGeneric[T](T, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[T] RangeStepGeneric[TStep,T](TStep, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TStep,T]], T, TStep, T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Decimal PowDecimal(System.Decimal, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.String GetStringSlice(System.String, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AbsDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AcosDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AsinDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AtanDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T CeilingDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T CosDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T CoshDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T ExpDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T FloorDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T Log10Dynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T LogDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T PowDynamic[T,TResult](T, TResult)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T PowGeneric[T](T, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T RoundDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T SinDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T SinhDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T TanDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T TanhDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T TruncateDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T2 Atan2Dynamic[T1,T2](T1, T1)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T2 SqrtDynamic[T1,T2](T1)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,,] GetArraySlice4D[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice3D[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle1[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle2[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle3[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice2D[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice3DFixedSingle1[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice3DFixedSingle2[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice3DFixedSingle3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble1[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble3[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble5[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble6[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice2DFixed1[T](T[,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice2DFixed2[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice3DFixedDouble1[T](T[,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice3DFixedDouble2[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice3DFixedDouble3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple1[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple3[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple4[T](T[,,,], Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice[T](T[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UInt16 PowUInt16(UInt16, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UInt32 PowUInt32(UInt32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UInt64 PowUInt64(UInt64, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UIntPtr PowUIntPtr(UIntPtr, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice2DFixed1[T](T[,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice2DFixed2[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice2D[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedDouble1[T](T[,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedDouble2[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedDouble3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedSingle1[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedSingle2[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedSingle3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3D[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble1[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble3[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble5[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble6[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle1[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle2[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle3[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple1[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Int32, T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple3[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple4[T](T[,,,], Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4D[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice[T](T[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[])
+Microsoft.FSharp.Core.Operators+Unchecked: Boolean Equals[T](T, T)
+Microsoft.FSharp.Core.Operators+Unchecked: Int32 Compare[T](T, T)
+Microsoft.FSharp.Core.Operators+Unchecked: Int32 Hash[T](T)
+Microsoft.FSharp.Core.Operators+Unchecked: T DefaultOf[T]()
+Microsoft.FSharp.Core.Operators+Unchecked: T Unbox[T](System.Object)
+Microsoft.FSharp.Core.Operators: Boolean IsNull[T](T)
+Microsoft.FSharp.Core.Operators: Boolean Not(Boolean)
+Microsoft.FSharp.Core.Operators: Boolean op_Equality[T](T, T)
+Microsoft.FSharp.Core.Operators: Boolean op_GreaterThanOrEqual[T](T, T)
+Microsoft.FSharp.Core.Operators: Boolean op_GreaterThan[T](T, T)
+Microsoft.FSharp.Core.Operators: Boolean op_Inequality[T](T, T)
+Microsoft.FSharp.Core.Operators: Boolean op_LessThanOrEqual[T](T, T)
+Microsoft.FSharp.Core.Operators: Boolean op_LessThan[T](T, T)
+Microsoft.FSharp.Core.Operators: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T)
+Microsoft.FSharp.Core.Operators: Byte ToByte[T](T)
+Microsoft.FSharp.Core.Operators: Char ToChar$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Char], T)
+Microsoft.FSharp.Core.Operators: Char ToChar[T](T)
+Microsoft.FSharp.Core.Operators: Double Infinity
+Microsoft.FSharp.Core.Operators: Double NaN
+Microsoft.FSharp.Core.Operators: Double ToDouble$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], T)
+Microsoft.FSharp.Core.Operators: Double ToDouble[T](T)
+Microsoft.FSharp.Core.Operators: Double get_Infinity()
+Microsoft.FSharp.Core.Operators: Double get_NaN()
+Microsoft.FSharp.Core.Operators: Int16 ToInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int16], T)
+Microsoft.FSharp.Core.Operators: Int16 ToInt16[T](T)
+Microsoft.FSharp.Core.Operators: Int32 Compare[T](T, T)
+Microsoft.FSharp.Core.Operators: Int32 Hash[T](T)
+Microsoft.FSharp.Core.Operators: Int32 Sign$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T)
+Microsoft.FSharp.Core.Operators: Int32 Sign[T](T)
+Microsoft.FSharp.Core.Operators: Int32 SizeOf[T]()
+Microsoft.FSharp.Core.Operators: Int32 ToInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T)
+Microsoft.FSharp.Core.Operators: Int32 ToInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T)
+Microsoft.FSharp.Core.Operators: Int32 ToInt32[T](T)
+Microsoft.FSharp.Core.Operators: Int32 ToInt[T](T)
+Microsoft.FSharp.Core.Operators: Int32 limitedHash[T](Int32, T)
+Microsoft.FSharp.Core.Operators: Int64 ToInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int64], T)
+Microsoft.FSharp.Core.Operators: Int64 ToInt64[T](T)
+Microsoft.FSharp.Core.Operators: IntPtr ToIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.IntPtr], T)
+Microsoft.FSharp.Core.Operators: IntPtr ToIntPtr[T](T)
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Collections.FSharpList`1[T] op_Append[T](Microsoft.FSharp.Collections.FSharpList`1[T], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpFunc`2[T1,T3] op_ComposeLeft[T2,T3,T1](Microsoft.FSharp.Core.FSharpFunc`2[T2,T3], Microsoft.FSharp.Core.FSharpFunc`2[T1,T2])
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpFunc`2[T1,T3] op_ComposeRight[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,T2], Microsoft.FSharp.Core.FSharpFunc`2[T2,T3])
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpOption`1[System.String] FailurePattern(System.Exception)
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpOption`1[T] TryUnbox[T](System.Object)
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpRef`1[T] Ref[T](T)
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+ArrayExtensions
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+Checked
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+NonStructuralComparison
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+OperatorIntrinsics
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+Unchecked
+Microsoft.FSharp.Core.Operators: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T)
+Microsoft.FSharp.Core.Operators: SByte ToSByte[T](T)
+Microsoft.FSharp.Core.Operators: Single InfinitySingle
+Microsoft.FSharp.Core.Operators: Single NaNSingle
+Microsoft.FSharp.Core.Operators: Single ToSingle$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], T)
+Microsoft.FSharp.Core.Operators: Single ToSingle[T](T)
+Microsoft.FSharp.Core.Operators: Single get_InfinitySingle()
+Microsoft.FSharp.Core.Operators: Single get_NaNSingle()
+Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] CreateSequence[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_Range$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T)
+Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_RangeStep$W[T,TStep](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TStep], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TStep,T]], T, TStep, T)
+Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_RangeStep[T,TStep](T, TStep, T)
+Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_Range[T](T, T)
+Microsoft.FSharp.Core.Operators: System.Decimal ToDecimal$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Decimal], T)
+Microsoft.FSharp.Core.Operators: System.Decimal ToDecimal[T](T)
+Microsoft.FSharp.Core.Operators: System.Exception Failure(System.String)
+Microsoft.FSharp.Core.Operators: System.IO.TextReader ConsoleIn[T]()
+Microsoft.FSharp.Core.Operators: System.IO.TextWriter ConsoleError[T]()
+Microsoft.FSharp.Core.Operators: System.IO.TextWriter ConsoleOut[T]()
+Microsoft.FSharp.Core.Operators: System.Object Box[T](T)
+Microsoft.FSharp.Core.Operators: System.RuntimeMethodHandle MethodHandleOf[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
+Microsoft.FSharp.Core.Operators: System.String NameOf[T](T)
+Microsoft.FSharp.Core.Operators: System.String ToString[T](T)
+Microsoft.FSharp.Core.Operators: System.String op_Concatenate(System.String, System.String)
+Microsoft.FSharp.Core.Operators: System.Tuple`2[TKey,TValue] KeyValuePattern[TKey,TValue](System.Collections.Generic.KeyValuePair`2[TKey,TValue])
+Microsoft.FSharp.Core.Operators: System.Type TypeDefOf[T]()
+Microsoft.FSharp.Core.Operators: System.Type TypeOf[T]()
+Microsoft.FSharp.Core.Operators: T Abs$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Abs[T](T)
+Microsoft.FSharp.Core.Operators: T Acos$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Acos[T](T)
+Microsoft.FSharp.Core.Operators: T Asin$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Asin[T](T)
+Microsoft.FSharp.Core.Operators: T Atan$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Atan[T](T)
+Microsoft.FSharp.Core.Operators: T Ceiling$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Ceiling[T](T)
+Microsoft.FSharp.Core.Operators: T Cos$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Cos[T](T)
+Microsoft.FSharp.Core.Operators: T Cosh$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Cosh[T](T)
+Microsoft.FSharp.Core.Operators: T DefaultArg[T](Microsoft.FSharp.Core.FSharpOption`1[T], T)
+Microsoft.FSharp.Core.Operators: T DefaultValueArg[T](Microsoft.FSharp.Core.FSharpValueOption`1[T], T)
+Microsoft.FSharp.Core.Operators: T Exit[T](Int32)
+Microsoft.FSharp.Core.Operators: T Exp$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Exp[T](T)
+Microsoft.FSharp.Core.Operators: T FailWith[T](System.String)
+Microsoft.FSharp.Core.Operators: T Floor$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Floor[T](T)
+Microsoft.FSharp.Core.Operators: T Identity[T](T)
+Microsoft.FSharp.Core.Operators: T InvalidArg[T](System.String, System.String)
+Microsoft.FSharp.Core.Operators: T InvalidOp[T](System.String)
+Microsoft.FSharp.Core.Operators: T Lock[TLock,T](TLock, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T])
+Microsoft.FSharp.Core.Operators: T Log$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Log10$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Log10[T](T)
+Microsoft.FSharp.Core.Operators: T Log[T](T)
+Microsoft.FSharp.Core.Operators: T Max[T](T, T)
+Microsoft.FSharp.Core.Operators: T Min[T](T, T)
+Microsoft.FSharp.Core.Operators: T NullArg[T](System.String)
+Microsoft.FSharp.Core.Operators: T PowInteger$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, Int32)
+Microsoft.FSharp.Core.Operators: T PowInteger[T](T, Int32)
+Microsoft.FSharp.Core.Operators: T Raise[T](System.Exception)
+Microsoft.FSharp.Core.Operators: T Reraise[T]()
+Microsoft.FSharp.Core.Operators: T Rethrow[T]()
+Microsoft.FSharp.Core.Operators: T Round$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Round[T](T)
+Microsoft.FSharp.Core.Operators: T Sin$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Sin[T](T)
+Microsoft.FSharp.Core.Operators: T Sinh$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Sinh[T](T)
+Microsoft.FSharp.Core.Operators: T Tan$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Tan[T](T)
+Microsoft.FSharp.Core.Operators: T Tanh$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Tanh[T](T)
+Microsoft.FSharp.Core.Operators: T Truncate$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Truncate[T](T)
+Microsoft.FSharp.Core.Operators: T Unbox[T](System.Object)
+Microsoft.FSharp.Core.Operators: T op_BitwiseAnd$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T)
+Microsoft.FSharp.Core.Operators: T op_BitwiseAnd[T](T, T)
+Microsoft.FSharp.Core.Operators: T op_BitwiseOr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T)
+Microsoft.FSharp.Core.Operators: T op_BitwiseOr[T](T, T)
+Microsoft.FSharp.Core.Operators: T op_Dereference[T](Microsoft.FSharp.Core.FSharpRef`1[T])
+Microsoft.FSharp.Core.Operators: T op_ExclusiveOr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T)
+Microsoft.FSharp.Core.Operators: T op_ExclusiveOr[T](T, T)
+Microsoft.FSharp.Core.Operators: T op_Exponentiation$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,T]], T, TResult)
+Microsoft.FSharp.Core.Operators: T op_Exponentiation[T,TResult](T, TResult)
+Microsoft.FSharp.Core.Operators: T op_LeftShift$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], T, Int32)
+Microsoft.FSharp.Core.Operators: T op_LeftShift[T](T, Int32)
+Microsoft.FSharp.Core.Operators: T op_LogicalNot$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T op_LogicalNot[T](T)
+Microsoft.FSharp.Core.Operators: T op_RightShift$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], T, Int32)
+Microsoft.FSharp.Core.Operators: T op_RightShift[T](T, Int32)
+Microsoft.FSharp.Core.Operators: T op_UnaryNegation$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T op_UnaryNegation[T](T)
+Microsoft.FSharp.Core.Operators: T op_UnaryPlus$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T op_UnaryPlus[T](T)
+Microsoft.FSharp.Core.Operators: T1 Fst[T1,T2](System.Tuple`2[T1,T2])
+Microsoft.FSharp.Core.Operators: T2 Atan2$W[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T1,T2]], T1, T1)
+Microsoft.FSharp.Core.Operators: T2 Atan2[T1,T2](T1, T1)
+Microsoft.FSharp.Core.Operators: T2 Snd[T1,T2](System.Tuple`2[T1,T2])
+Microsoft.FSharp.Core.Operators: T3 op_Addition$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Addition[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Division$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Division[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Modulus$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Modulus[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Multiply$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Multiply[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Subtraction$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Subtraction[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators: TResult Sqrt$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T)
+Microsoft.FSharp.Core.Operators: TResult Sqrt[T,TResult](T)
+Microsoft.FSharp.Core.Operators: TResult ToEnum[TResult](Int32)
+Microsoft.FSharp.Core.Operators: TResult Using[T,TResult](T, Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
+Microsoft.FSharp.Core.Operators: TResult op_PipeLeft2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], T1, T2)
+Microsoft.FSharp.Core.Operators: TResult op_PipeLeft3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], T1, T2, T3)
+Microsoft.FSharp.Core.Operators: TResult op_PipeLeft[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T)
+Microsoft.FSharp.Core.Operators: TResult op_PipeRight2[T1,T2,TResult](T1, T2, Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]])
+Microsoft.FSharp.Core.Operators: TResult op_PipeRight3[T1,T2,T3,TResult](T1, T2, T3, Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]])
+Microsoft.FSharp.Core.Operators: TResult op_PipeRight[T1,TResult](T1, Microsoft.FSharp.Core.FSharpFunc`2[T1,TResult])
+Microsoft.FSharp.Core.Operators: UInt16 ToUInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt16], T)
+Microsoft.FSharp.Core.Operators: UInt16 ToUInt16[T](T)
+Microsoft.FSharp.Core.Operators: UInt32 ToUInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], T)
+Microsoft.FSharp.Core.Operators: UInt32 ToUInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], T)
+Microsoft.FSharp.Core.Operators: UInt32 ToUInt32[T](T)
+Microsoft.FSharp.Core.Operators: UInt32 ToUInt[T](T)
+Microsoft.FSharp.Core.Operators: UInt64 ToUInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt64], T)
+Microsoft.FSharp.Core.Operators: UInt64 ToUInt64[T](T)
+Microsoft.FSharp.Core.Operators: UIntPtr ToUIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UIntPtr], T)
+Microsoft.FSharp.Core.Operators: UIntPtr ToUIntPtr[T](T)
+Microsoft.FSharp.Core.Operators: Void Decrement(Microsoft.FSharp.Core.FSharpRef`1[System.Int32])
+Microsoft.FSharp.Core.Operators: Void Ignore[T](T)
+Microsoft.FSharp.Core.Operators: Void Increment(Microsoft.FSharp.Core.FSharpRef`1[System.Int32])
+Microsoft.FSharp.Core.Operators: Void op_ColonEquals[T](Microsoft.FSharp.Core.FSharpRef`1[T], T)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: FSharpFunc`3 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]])
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult] Invoke(T1)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: TResult Invoke(T1, T2)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: Void .ctor()
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: FSharpFunc`4 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]])
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]] Invoke(T1)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: TResult Invoke(T1, T2, T3)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: Void .ctor()
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: FSharpFunc`5 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]]])
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]] Invoke(T1)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: TResult Invoke(T1, T2, T3, T4)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: Void .ctor()
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: FSharpFunc`6 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]]])
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]] Invoke(T1)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: TResult Invoke(T1, T2, T3, T4, T5)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: Void .ctor()
+Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]
+Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]
+Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]
+Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]
+Microsoft.FSharp.Core.OptionModule: Boolean Contains[T](T, Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Boolean IsNone[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Boolean IsSome[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Int32 Count[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], Microsoft.FSharp.Core.FSharpOption`1[T1], Microsoft.FSharp.Core.FSharpOption`1[T2])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], Microsoft.FSharp.Core.FSharpOption`1[T1], Microsoft.FSharp.Core.FSharpOption`1[T2], Microsoft.FSharp.Core.FSharpOption`1[T3])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] Flatten[T](Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpOption`1[T]])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OfNullable[T](System.Nullable`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OfObj[T](T)
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OrElseWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.FSharpOption`1[T]], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OrElse[T](Microsoft.FSharp.Core.FSharpOption`1[T], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: System.Nullable`1[T] ToNullable[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: T DefaultValue[T](T, Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: T DefaultWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: T GetValue[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: T ToObj[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Core.FSharpOption`1[T], TState)
+Microsoft.FSharp.Core.OptionModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: T[] ToArray[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionalArgumentAttribute: Void .ctor()
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Object[] Captures
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Object[] get_Captures()
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.String ToString()
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.String Value
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.String get_Value()
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Type[] CaptureTypes
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Type[] get_CaptureTypes()
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: Void .ctor(System.String)
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: Void .ctor(System.String, System.Object[], System.Type[])
+Microsoft.FSharp.Core.PrintfFormat`5[TPrinter,TState,TResidue,TResult,TTuple]: Void .ctor(System.String)
+Microsoft.FSharp.Core.PrintfFormat`5[TPrinter,TState,TResidue,TResult,TTuple]: Void .ctor(System.String, System.Object[], System.Type[])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatLineToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatLineToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatLine[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[System.String,TResult], Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringBuilderThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], System.Text.StringBuilder, Microsoft.FSharp.Core.PrintfFormat`4[T,System.Text.StringBuilder,Microsoft.FSharp.Core.Unit,TResult])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringBuilder[T](System.Text.StringBuilder, Microsoft.FSharp.Core.PrintfFormat`4[T,System.Text.StringBuilder,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringThenFail[T,TResult](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[System.String,TResult], Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringThen[T](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,System.String])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToTextWriterThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,TResult])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormat[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ProjectionParameterAttribute: Void .ctor()
+Microsoft.FSharp.Core.ReferenceEqualityAttribute: Void .ctor()
+Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Boolean IncludeValue
+Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Boolean get_IncludeValue()
+Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Void .ctor()
+Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Void .ctor(Boolean)
+Microsoft.FSharp.Core.RequireQualifiedAccessAttribute: Void .ctor()
+Microsoft.FSharp.Core.RequiresExplicitTypeArgumentsAttribute: Void .ctor()
+Microsoft.FSharp.Core.ResultModule: Boolean Contains[T,TError](T, Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Boolean Exists[T,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Boolean ForAll[T,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Boolean IsError[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Boolean IsOk[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Int32 Count[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpOption`1[T] ToOption[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpResult`2[T,TResult] MapError[TError,TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[TError,TResult], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpResult`2[TResult,TError] Bind[T,TResult,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpResult`2[TResult,TError]], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpResult`2[TResult,TError] Map[T,TResult,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpValueOption`1[T] ToValueOption[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: T DefaultValue[T,TError](T, Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: T DefaultWith[TError,T](Microsoft.FSharp.Core.FSharpFunc`2[TError,T], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: TState FoldBack[T,TError,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Core.FSharpResult`2[T,TError], TState)
+Microsoft.FSharp.Core.ResultModule: TState Fold[T,TError,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: T[] ToArray[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Void Iterate[T,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.SealedAttribute: Boolean Value
+Microsoft.FSharp.Core.SealedAttribute: Boolean get_Value()
+Microsoft.FSharp.Core.SealedAttribute: Void .ctor()
+Microsoft.FSharp.Core.SealedAttribute: Void .ctor(Boolean)
+Microsoft.FSharp.Core.SourceConstructFlags: Int32 value__
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Closure
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Exception
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Field
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags KindMask
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Module
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags NonPublicRepresentation
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags None
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags ObjectType
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags RecordType
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags SumType
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags UnionCase
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Value
+Microsoft.FSharp.Core.StringModule: Boolean Exists(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Boolean], System.String)
+Microsoft.FSharp.Core.StringModule: Boolean ForAll(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Boolean], System.String)
+Microsoft.FSharp.Core.StringModule: Int32 Length(System.String)
+Microsoft.FSharp.Core.StringModule: System.String Collect(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.String], System.String)
+Microsoft.FSharp.Core.StringModule: System.String Concat(System.String, System.Collections.Generic.IEnumerable`1[System.String])
+Microsoft.FSharp.Core.StringModule: System.String Filter(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Boolean], System.String)
+Microsoft.FSharp.Core.StringModule: System.String Initialize(Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.String])
+Microsoft.FSharp.Core.StringModule: System.String Map(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Char], System.String)
+Microsoft.FSharp.Core.StringModule: System.String MapIndexed(Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Char]], System.String)
+Microsoft.FSharp.Core.StringModule: System.String Replicate(Int32, System.String)
+Microsoft.FSharp.Core.StringModule: Void Iterate(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,Microsoft.FSharp.Core.Unit], System.String)
+Microsoft.FSharp.Core.StringModule: Void IterateIndexed(Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Char,Microsoft.FSharp.Core.Unit]], System.String)
+Microsoft.FSharp.Core.StructAttribute: Void .ctor()
+Microsoft.FSharp.Core.StructuralComparisonAttribute: Void .ctor()
+Microsoft.FSharp.Core.StructuralEqualityAttribute: Void .ctor()
+Microsoft.FSharp.Core.StructuredFormatDisplayAttribute: System.String Value
+Microsoft.FSharp.Core.StructuredFormatDisplayAttribute: System.String get_Value()
+Microsoft.FSharp.Core.StructuredFormatDisplayAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.Unit: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.Unit: Int32 GetHashCode()
+Microsoft.FSharp.Core.UnverifiableAttribute: Void .ctor()
+Microsoft.FSharp.Core.ValueOption: Boolean Contains[T](T, Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Boolean IsNone[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Boolean IsSome[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Int32 Count[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpValueOption`1[TResult]], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], Microsoft.FSharp.Core.FSharpValueOption`1[T1], Microsoft.FSharp.Core.FSharpValueOption`1[T2])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], Microsoft.FSharp.Core.FSharpValueOption`1[T1], Microsoft.FSharp.Core.FSharpValueOption`1[T2], Microsoft.FSharp.Core.FSharpValueOption`1[T3])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] Flatten[T](Microsoft.FSharp.Core.FSharpValueOption`1[Microsoft.FSharp.Core.FSharpValueOption`1[T]])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OfNullable[T](System.Nullable`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OfObj[T](T)
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OrElseWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.FSharpValueOption`1[T]], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OrElse[T](Microsoft.FSharp.Core.FSharpValueOption`1[T], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: System.Nullable`1[T] ToNullable[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: T DefaultValue[T](T, Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: T DefaultWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: T GetValue[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: T ToObj[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Core.FSharpValueOption`1[T], TState)
+Microsoft.FSharp.Core.ValueOption: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: T[] ToArray[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.VolatileFieldAttribute: Void .ctor()
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToByte[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToUInt8$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToUInt8[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Char] ToChar$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Char], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Char] ToChar[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Decimal] ToDecimal$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Decimal], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Decimal] ToDecimal[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToDouble$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToDouble[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToFloat$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToFloat[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int16] ToInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int16], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int16] ToInt16[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt32[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int64] ToInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int64], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int64] ToInt64[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.IntPtr] ToIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.IntPtr], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.IntPtr] ToIntPtr[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToInt8$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToInt8[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToSByte[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToFloat32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToFloat32[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToSingle$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToSingle[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt16] ToUInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt16], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt16] ToUInt16[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt32[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt64] ToUInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt64], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt64] ToUInt64[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UIntPtr] ToUIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UIntPtr], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UIntPtr] ToUIntPtr[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[TResult] ToEnum[TResult](System.Nullable`1[System.Int32])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_EqualsQmark[T](T, System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_GreaterEqualsQmark[T](T, System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_GreaterQmark[T](T, System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_LessEqualsQmark[T](T, System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_LessGreaterQmark[T](T, System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_LessQmark[T](T, System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkEqualsQmark[T](System.Nullable`1[T], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkEquals[T](System.Nullable`1[T], T)
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreaterEqualsQmark[T](System.Nullable`1[T], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreaterEquals[T](System.Nullable`1[T], T)
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreaterQmark[T](System.Nullable`1[T], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreater[T](System.Nullable`1[T], T)
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessEqualsQmark[T](System.Nullable`1[T], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessEquals[T](System.Nullable`1[T], T)
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessGreaterQmark[T](System.Nullable`1[T], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessGreater[T](System.Nullable`1[T], T)
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessQmark[T](System.Nullable`1[T], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLess[T](System.Nullable`1[T], T)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_DivideQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_DivideQmark[T1,T2,T3](T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MinusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MinusQmark[T1,T2,T3](T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MultiplyQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MultiplyQmark[T1,T2,T3](T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PercentQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PercentQmark[T1,T2,T3](T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PlusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PlusQmark[T1,T2,T3](T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivide$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivideQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivideQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivide[T1,T2,T3](System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinus$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinusQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinus[T1,T2,T3](System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiply$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiplyQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiplyQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiply[T1,T2,T3](System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercent$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercentQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercentQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercent[T1,T2,T3](System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlus$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlusQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlus[T1,T2,T3](System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.QueryBuilder: Boolean All[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
+Microsoft.FSharp.Linq.QueryBuilder: Boolean Contains[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], T)
+Microsoft.FSharp.Linq.QueryBuilder: Boolean Exists[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
+Microsoft.FSharp.Linq.QueryBuilder: Int32 Count[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[System.Linq.IGrouping`2[TKey,TValue],Q] GroupValBy[T,TKey,TValue,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[System.Linq.IGrouping`2[TKey,T],Q] GroupBy[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Distinct[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SkipWhile[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Skip[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Int32)
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortByDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortByNullableDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortByNullable[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortBy[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Source[T,Q](System.Linq.IQueryable`1[T])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] TakeWhile[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Take[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Int32)
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenByDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenByNullableDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenByNullable[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenBy[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Where[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] YieldFrom[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Yield[T,Q](T)
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Zero[T,Q]()
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,System.Collections.IEnumerable] Source[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] For[T,Q,TResult,Q2](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Linq.QuerySource`2[TResult,Q2]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] GroupJoin[TOuter,Q,TInner,TKey,TResult](Microsoft.FSharp.Linq.QuerySource`2[TOuter,Q], Microsoft.FSharp.Linq.QuerySource`2[TInner,Q], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TInner,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,Microsoft.FSharp.Core.FSharpFunc`2[System.Collections.Generic.IEnumerable`1[TInner],TResult]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] Join[TOuter,Q,TInner,TKey,TResult](Microsoft.FSharp.Linq.QuerySource`2[TOuter,Q], Microsoft.FSharp.Linq.QuerySource`2[TInner,Q], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TInner,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,Microsoft.FSharp.Core.FSharpFunc`2[TInner,TResult]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] LeftOuterJoin[TOuter,Q,TInner,TKey,TResult](Microsoft.FSharp.Linq.QuerySource`2[TOuter,Q], Microsoft.FSharp.Linq.QuerySource`2[TInner,Q], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TInner,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,Microsoft.FSharp.Core.FSharpFunc`2[System.Collections.Generic.IEnumerable`1[TInner],TResult]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] Select[T,Q,TResult](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Quotations.FSharpExpr`1[T] Quote[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T])
+Microsoft.FSharp.Linq.QueryBuilder: System.Linq.IQueryable`1[T] Run[T](Microsoft.FSharp.Quotations.FSharpExpr`1[Microsoft.FSharp.Linq.QuerySource`2[T,System.Linq.IQueryable]])
+Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] AverageByNullable$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TValue]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
+Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] AverageByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
+Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] MaxByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
+Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] MinByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
+Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] SumByNullable$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
+Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] SumByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
+Microsoft.FSharp.Linq.QueryBuilder: T ExactlyOneOrDefault[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: T ExactlyOne[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: T Find[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
+Microsoft.FSharp.Linq.QueryBuilder: T HeadOrDefault[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: T Head[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: T LastOrDefault[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: T Last[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: T Nth[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Int32)
+Microsoft.FSharp.Linq.QueryBuilder: TValue AverageBy$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TValue]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
+Microsoft.FSharp.Linq.QueryBuilder: TValue AverageBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
+Microsoft.FSharp.Linq.QueryBuilder: TValue MaxBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
+Microsoft.FSharp.Linq.QueryBuilder: TValue MinBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
+Microsoft.FSharp.Linq.QueryBuilder: TValue SumBy$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
+Microsoft.FSharp.Linq.QueryBuilder: TValue SumBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
+Microsoft.FSharp.Linq.QueryBuilder: Void .ctor()
+Microsoft.FSharp.Linq.QueryRunExtensions.HighPriority: System.Collections.Generic.IEnumerable`1[T] RunQueryAsEnumerable[T](Microsoft.FSharp.Linq.QueryBuilder, Microsoft.FSharp.Quotations.FSharpExpr`1[Microsoft.FSharp.Linq.QuerySource`2[T,System.Collections.IEnumerable]])
+Microsoft.FSharp.Linq.QueryRunExtensions.LowPriority: T RunQueryAsValue[T](Microsoft.FSharp.Linq.QueryBuilder, Microsoft.FSharp.Quotations.FSharpExpr`1[T])
+Microsoft.FSharp.Linq.QuerySource`2[T,Q]: System.Collections.Generic.IEnumerable`1[T] Source
+Microsoft.FSharp.Linq.QuerySource`2[T,Q]: System.Collections.Generic.IEnumerable`1[T] get_Source()
+Microsoft.FSharp.Linq.QuerySource`2[T,Q]: Void .ctor(System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`1[T1]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`1[T1]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`1[T1]: Void .ctor(T1)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: Void .ctor(T1, T2)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T3 Item3
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T3 get_Item3()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: Void .ctor(T1, T2, T3)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T3 Item3
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T3 get_Item3()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T4 Item4
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T4 get_Item4()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: Void .ctor(T1, T2, T3, T4)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T3 Item3
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T3 get_Item3()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T4 Item4
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T4 get_Item4()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T5 Item5
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T5 get_Item5()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: Void .ctor(T1, T2, T3, T4, T5)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T3 Item3
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T3 get_Item3()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T4 Item4
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T4 get_Item4()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T5 Item5
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T5 get_Item5()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T6 Item6
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T6 get_Item6()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: Void .ctor(T1, T2, T3, T4, T5, T6)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T3 Item3
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T3 get_Item3()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T4 Item4
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T4 get_Item4()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T5 Item5
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T5 get_Item5()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T6 Item6
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T6 get_Item6()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T7 Item7
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T7 get_Item7()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: Void .ctor(T1, T2, T3, T4, T5, T6, T7)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T3 Item3
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T3 get_Item3()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T4 Item4
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T4 get_Item4()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T5 Item5
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T5 get_Item5()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T6 Item6
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T6 get_Item6()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T7 Item7
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T7 get_Item7()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T8 Item8
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T8 get_Item8()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: Void .ctor(T1, T2, T3, T4, T5, T6, T7, T8)
+Microsoft.FSharp.Linq.RuntimeHelpers.Grouping`2[K,T]: Void .ctor(K, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: Microsoft.FSharp.Quotations.FSharpExpr SubstHelperRaw(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar[], System.Object[])
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: Microsoft.FSharp.Quotations.FSharpExpr`1[T] SubstHelper[T](Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar[], System.Object[])
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Linq.Expressions.Expression QuotationToExpression(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Linq.Expressions.Expression`1[T] ImplicitExpressionConversionHelper[T](T)
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Linq.Expressions.Expression`1[T] QuotationToLambdaExpression[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T])
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Object EvaluateQuotation(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: T MemberInitializationHelper[T](T)
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: T NewAnonymousObjectHelper[T](T)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Boolean IsNullPointer[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr AddPointerInlined[T](IntPtr, Int32)
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr NullPointer[T]()
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr OfILSigPtrInlined[T](T*)
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr OfNativeIntInlined[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr OfVoidPtrInlined[T](Void*)
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr StackAllocate[T](Int32)
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr ToNativeIntInlined[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: T GetPointerInlined[T](IntPtr, Int32)
+Microsoft.FSharp.NativeInterop.NativePtrModule: T ReadPointerInlined[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: T& ToByRefInlined[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: T* ToILSigPtrInlined[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void ClearPointerInlined[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void CopyBlockInlined[T](IntPtr, IntPtr, Int32)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void CopyPointerInlined[T](IntPtr, IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void InitializeBlockInlined[T](IntPtr, Byte, UInt32)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void SetPointerInlined[T](IntPtr, Int32, T)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void WritePointerInlined[T](IntPtr, T)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void* ToVoidPtrInlined[T](IntPtr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],Microsoft.FSharp.Collections.FSharpList`1[System.Type],Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]]] SpecificCallPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] UnitPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] MethodWithReflectedDefinitionPattern(System.Reflection.MethodBase)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] PropertyGetterWithReflectedDefinitionPattern(System.Reflection.PropertyInfo)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] PropertySetterWithReflectedDefinitionPattern(System.Reflection.PropertyInfo)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Boolean] BoolPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Byte] BytePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Char] CharPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Decimal] DecimalPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Double] DoublePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int16] Int16Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] Int32Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int64] Int64Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.SByte] SBytePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Single] SinglePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.String] StringPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpVar]],Microsoft.FSharp.Quotations.FSharpExpr]] LambdasPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]]] ApplicationsPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] AndAlsoPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] OrElsePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.UInt16] UInt16Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.UInt32] UInt32Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.UInt64] UInt64Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.ExprShapeModule: Microsoft.FSharp.Core.FSharpChoice`3[Microsoft.FSharp.Quotations.FSharpVar,System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr],System.Tuple`2[System.Object,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] ShapePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.ExprShapeModule: Microsoft.FSharp.Quotations.FSharpExpr RebuildShapeCombination(System.Object, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Boolean Equals(System.Object)
+Microsoft.FSharp.Quotations.FSharpExpr: Int32 GetHashCode()
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr] CustomAttributes
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr] get_CustomAttributes()
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] TryGetReflectedDefinition(System.Reflection.MethodBase)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr AddressOf(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr AddressSet(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Application(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Applications(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Call(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Call(System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr CallWithWitnesses(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.MethodInfo, System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr], Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr CallWithWitnesses(System.Reflection.MethodInfo, System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr], Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Coerce(Microsoft.FSharp.Quotations.FSharpExpr, System.Type)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr DefaultValue(System.Type)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Deserialize(System.Type, Microsoft.FSharp.Collections.FSharpList`1[System.Type], Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr], Byte[])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Deserialize40(System.Type, System.Type[], System.Type[], Microsoft.FSharp.Quotations.FSharpExpr[], Byte[])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldGet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.FieldInfo)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldGet(System.Reflection.FieldInfo)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldSet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.FieldInfo, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldSet(System.Reflection.FieldInfo, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr ForIntegerRangeLoop(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr IfThenElse(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Lambda(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Let(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr LetRecursive(Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]], Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewArray(System.Type, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewDelegate(System.Type, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpVar], Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewObject(System.Reflection.ConstructorInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewRecord(System.Type, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewStructTuple(System.Reflection.Assembly, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewTuple(Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewUnionCase(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertyGet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.PropertyInfo, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertyGet(System.Reflection.PropertyInfo, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertySet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.PropertyInfo, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertySet(System.Reflection.PropertyInfo, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Quote(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr QuoteRaw(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr QuoteTyped(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Sequential(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Substitute(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr]])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TryFinally(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TryWith(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TupleGet(Microsoft.FSharp.Quotations.FSharpExpr, Int32)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TypeTest(Microsoft.FSharp.Quotations.FSharpExpr, System.Type)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr UnionCaseTest(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Reflection.UnionCaseInfo)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Value(System.Object, System.Type)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr ValueWithName(System.Object, System.Type, System.String)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr ValueWithName[T](T, System.String)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Value[T](T)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Var(Microsoft.FSharp.Quotations.FSharpVar)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr VarSet(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr WhileLoop(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr WithValue(System.Object, System.Type, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr`1[T] Cast[T](Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr`1[T] GlobalVar[T](System.String)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr`1[T] WithValue[T](T, Microsoft.FSharp.Quotations.FSharpExpr`1[T])
+Microsoft.FSharp.Quotations.FSharpExpr: System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Quotations.FSharpVar] GetFreeVars()
+Microsoft.FSharp.Quotations.FSharpExpr: System.String ToString()
+Microsoft.FSharp.Quotations.FSharpExpr: System.String ToString(Boolean)
+Microsoft.FSharp.Quotations.FSharpExpr: System.Type Type
+Microsoft.FSharp.Quotations.FSharpExpr: System.Type get_Type()
+Microsoft.FSharp.Quotations.FSharpExpr: Void RegisterReflectedDefinitions(System.Reflection.Assembly, System.String, Byte[])
+Microsoft.FSharp.Quotations.FSharpExpr: Void RegisterReflectedDefinitions(System.Reflection.Assembly, System.String, Byte[], System.Type[])
+Microsoft.FSharp.Quotations.FSharpExpr`1[T]: Microsoft.FSharp.Quotations.FSharpExpr Raw
+Microsoft.FSharp.Quotations.FSharpExpr`1[T]: Microsoft.FSharp.Quotations.FSharpExpr get_Raw()
+Microsoft.FSharp.Quotations.FSharpVar: Boolean Equals(System.Object)
+Microsoft.FSharp.Quotations.FSharpVar: Boolean IsMutable
+Microsoft.FSharp.Quotations.FSharpVar: Boolean get_IsMutable()
+Microsoft.FSharp.Quotations.FSharpVar: Int32 GetHashCode()
+Microsoft.FSharp.Quotations.FSharpVar: Microsoft.FSharp.Quotations.FSharpVar Global(System.String, System.Type)
+Microsoft.FSharp.Quotations.FSharpVar: System.String Name
+Microsoft.FSharp.Quotations.FSharpVar: System.String ToString()
+Microsoft.FSharp.Quotations.FSharpVar: System.String get_Name()
+Microsoft.FSharp.Quotations.FSharpVar: System.Type Type
+Microsoft.FSharp.Quotations.FSharpVar: System.Type get_Type()
+Microsoft.FSharp.Quotations.FSharpVar: Void .ctor(System.String, System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]] NewStructTuplePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]] NewTuplePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] AddressOfPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] QuotePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] QuoteRawPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] QuoteTypedPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpVar] VarPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]],Microsoft.FSharp.Quotations.FSharpExpr]] LetRecursivePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.FieldInfo]] FieldGetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] AddressSetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] ApplicationPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] SequentialPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] TryFinallyPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] WhileLoopPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Reflection.UnionCaseInfo]] UnionCaseTestPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,System.Int32]] TupleGetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,System.Type]] CoercePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,System.Type]] TypeTestPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]] LambdaPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]] VarSetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Reflection.UnionCaseInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewUnionCasePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Object,System.Type]] ValuePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Reflection.ConstructorInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewObjectPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Type,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewArrayPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Type,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewRecordPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.FieldInfo,Microsoft.FSharp.Quotations.FSharpExpr]] FieldSetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.MethodInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] CallPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.PropertyInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] PropertyGetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] IfThenElsePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] LetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Object,System.Type,Microsoft.FSharp.Quotations.FSharpExpr]] WithValuePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Object,System.Type,System.String]] ValueWithNamePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Type,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpVar],Microsoft.FSharp.Quotations.FSharpExpr]] NewDelegatePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`4[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.PropertyInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr],Microsoft.FSharp.Quotations.FSharpExpr]] PropertySetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`4[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] ForIntegerRangeLoopPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`5[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.MethodInfo,System.Reflection.MethodInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr],Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] CallWithWitnessesPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`5[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]] TryWithPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Type] DefaultValuePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Boolean FSharpType.IsExceptionRepresentation.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Boolean FSharpType.IsRecord.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Boolean FSharpType.IsUnion.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Int32] FSharpValue.PreComputeUnionTagReader.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] FSharpValue.PreComputeRecordReader.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] FSharpValue.PreComputeUnionReader.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] FSharpValue.PreComputeRecordConstructor.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] FSharpValue.PreComputeUnionConstructor.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Reflection.UnionCaseInfo[] FSharpType.GetUnionCases.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object FSharpValue.MakeRecord.Static(System.Type, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object FSharpValue.MakeUnion.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object[] FSharpValue.GetExceptionFields.Static(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object[] FSharpValue.GetRecordFields.Static(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.ConstructorInfo FSharpValue.PreComputeRecordConstructorInfo.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.MemberInfo FSharpValue.PreComputeUnionTagMemberInfo.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.MethodInfo FSharpValue.PreComputeUnionConstructorInfo.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.PropertyInfo[] FSharpType.GetExceptionFields.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.PropertyInfo[] FSharpType.GetRecordFields.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Tuple`2[Microsoft.FSharp.Reflection.UnionCaseInfo,System.Object[]] FSharpValue.GetUnionFields.Static(System.Object, System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpType: Boolean IsExceptionRepresentation(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpType: Boolean IsFunction(System.Type)
+Microsoft.FSharp.Reflection.FSharpType: Boolean IsModule(System.Type)
+Microsoft.FSharp.Reflection.FSharpType: Boolean IsRecord(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpType: Boolean IsTuple(System.Type)
+Microsoft.FSharp.Reflection.FSharpType: Boolean IsUnion(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpType: Microsoft.FSharp.Reflection.UnionCaseInfo[] GetUnionCases(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpType: System.Reflection.PropertyInfo[] GetExceptionFields(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpType: System.Reflection.PropertyInfo[] GetRecordFields(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpType: System.Tuple`2[System.Type,System.Type] GetFunctionElements(System.Type)
+Microsoft.FSharp.Reflection.FSharpType: System.Type MakeFunctionType(System.Type, System.Type)
+Microsoft.FSharp.Reflection.FSharpType: System.Type MakeStructTupleType(System.Reflection.Assembly, System.Type[])
+Microsoft.FSharp.Reflection.FSharpType: System.Type MakeTupleType(System.Reflection.Assembly, System.Type[])
+Microsoft.FSharp.Reflection.FSharpType: System.Type MakeTupleType(System.Type[])
+Microsoft.FSharp.Reflection.FSharpType: System.Type[] GetTupleElements(System.Type)
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Int32] PreComputeUnionTagReader(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] PreComputeRecordReader(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] PreComputeTupleReader(System.Type)
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] PreComputeUnionReader(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object] PreComputeRecordFieldReader(System.Reflection.PropertyInfo)
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] PreComputeRecordConstructor(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] PreComputeTupleConstructor(System.Type)
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] PreComputeUnionConstructor(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Object GetRecordField(System.Object, System.Reflection.PropertyInfo)
+Microsoft.FSharp.Reflection.FSharpValue: System.Object GetTupleField(System.Object, Int32)
+Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeFunction(System.Type, Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object])
+Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeRecord(System.Type, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeTuple(System.Object[], System.Type)
+Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeUnion(Microsoft.FSharp.Reflection.UnionCaseInfo, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Object[] GetExceptionFields(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Object[] GetRecordFields(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Object[] GetTupleFields(System.Object)
+Microsoft.FSharp.Reflection.FSharpValue: System.Reflection.ConstructorInfo PreComputeRecordConstructorInfo(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Reflection.MemberInfo PreComputeUnionTagMemberInfo(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Reflection.MethodInfo PreComputeUnionConstructorInfo(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Tuple`2[Microsoft.FSharp.Reflection.UnionCaseInfo,System.Object[]] GetUnionFields(System.Object, System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Tuple`2[System.Reflection.ConstructorInfo,Microsoft.FSharp.Core.FSharpOption`1[System.Type]] PreComputeTupleConstructorInfo(System.Type)
+Microsoft.FSharp.Reflection.FSharpValue: System.Tuple`2[System.Reflection.PropertyInfo,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Type,System.Int32]]] PreComputeTuplePropertyInfo(System.Type, Int32)
+Microsoft.FSharp.Reflection.UnionCaseInfo: Boolean Equals(System.Object)
+Microsoft.FSharp.Reflection.UnionCaseInfo: Int32 GetHashCode()
+Microsoft.FSharp.Reflection.UnionCaseInfo: Int32 Tag
+Microsoft.FSharp.Reflection.UnionCaseInfo: Int32 get_Tag()
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Collections.Generic.IList`1[System.Reflection.CustomAttributeData] GetCustomAttributesData()
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Object[] GetCustomAttributes()
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Object[] GetCustomAttributes(System.Type)
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Reflection.PropertyInfo[] GetFields()
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.String Name
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.String ToString()
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.String get_Name()
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type DeclaringType
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type get_DeclaringType()
\ No newline at end of file
diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.release.bsl b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.release.bsl
new file mode 100644
index 00000000000..bb1dd5db9d6
--- /dev/null
+++ b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.release.bsl
@@ -0,0 +1,2507 @@
+! AssemblyReference: System.Runtime.Numerics
+! AssemblyReference: netstandard
+Microsoft.FSharp.Collections.Array2DModule: Int32 Base1[T](T[,])
+Microsoft.FSharp.Collections.Array2DModule: Int32 Base2[T](T[,])
+Microsoft.FSharp.Collections.Array2DModule: Int32 Length1[T](T[,])
+Microsoft.FSharp.Collections.Array2DModule: Int32 Length2[T](T[,])
+Microsoft.FSharp.Collections.Array2DModule: T Get[T](T[,], Int32, Int32)
+Microsoft.FSharp.Collections.Array2DModule: TResult[,] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]]], T[,])
+Microsoft.FSharp.Collections.Array2DModule: TResult[,] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[,])
+Microsoft.FSharp.Collections.Array2DModule: T[,] Copy[T](T[,])
+Microsoft.FSharp.Collections.Array2DModule: T[,] CreateBased[T](Int32, Int32, Int32, Int32, T)
+Microsoft.FSharp.Collections.Array2DModule: T[,] Create[T](Int32, Int32, T)
+Microsoft.FSharp.Collections.Array2DModule: T[,] InitializeBased[T](Int32, Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]])
+Microsoft.FSharp.Collections.Array2DModule: T[,] Initialize[T](Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]])
+Microsoft.FSharp.Collections.Array2DModule: T[,] Rebase[T](T[,])
+Microsoft.FSharp.Collections.Array2DModule: T[,] ZeroCreateBased[T](Int32, Int32, Int32, Int32)
+Microsoft.FSharp.Collections.Array2DModule: T[,] ZeroCreate[T](Int32, Int32)
+Microsoft.FSharp.Collections.Array2DModule: Void CopyTo[T](T[,], Int32, Int32, T[,], Int32, Int32, Int32, Int32)
+Microsoft.FSharp.Collections.Array2DModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]]], T[,])
+Microsoft.FSharp.Collections.Array2DModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[,])
+Microsoft.FSharp.Collections.Array2DModule: Void Set[T](T[,], Int32, Int32, T)
+Microsoft.FSharp.Collections.Array3DModule: Int32 Length1[T](T[,,])
+Microsoft.FSharp.Collections.Array3DModule: Int32 Length2[T](T[,,])
+Microsoft.FSharp.Collections.Array3DModule: Int32 Length3[T](T[,,])
+Microsoft.FSharp.Collections.Array3DModule: T Get[T](T[,,], Int32, Int32, Int32)
+Microsoft.FSharp.Collections.Array3DModule: TResult[,,] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]]]], T[,,])
+Microsoft.FSharp.Collections.Array3DModule: TResult[,,] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[,,])
+Microsoft.FSharp.Collections.Array3DModule: T[,,] Create[T](Int32, Int32, Int32, T)
+Microsoft.FSharp.Collections.Array3DModule: T[,,] Initialize[T](Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]]])
+Microsoft.FSharp.Collections.Array3DModule: T[,,] ZeroCreate[T](Int32, Int32, Int32)
+Microsoft.FSharp.Collections.Array3DModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]]]], T[,,])
+Microsoft.FSharp.Collections.Array3DModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[,,])
+Microsoft.FSharp.Collections.Array3DModule: Void Set[T](T[,,], Int32, Int32, Int32, T)
+Microsoft.FSharp.Collections.Array4DModule: Int32 Length1[T](T[,,,])
+Microsoft.FSharp.Collections.Array4DModule: Int32 Length2[T](T[,,,])
+Microsoft.FSharp.Collections.Array4DModule: Int32 Length3[T](T[,,,])
+Microsoft.FSharp.Collections.Array4DModule: Int32 Length4[T](T[,,,])
+Microsoft.FSharp.Collections.Array4DModule: T Get[T](T[,,,], Int32, Int32, Int32, Int32)
+Microsoft.FSharp.Collections.Array4DModule: T[,,,] Create[T](Int32, Int32, Int32, Int32, T)
+Microsoft.FSharp.Collections.Array4DModule: T[,,,] Initialize[T](Int32, Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]]]])
+Microsoft.FSharp.Collections.Array4DModule: T[,,,] ZeroCreate[T](Int32, Int32, Int32, Int32)
+Microsoft.FSharp.Collections.Array4DModule: Void Set[T](T[,,,], Int32, Int32, Int32, Int32, T)
+Microsoft.FSharp.Collections.ArrayModule+Parallel: System.Tuple`2[T[],T[]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] Collect[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult[]], T[])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], T[])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: T[] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], T[])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[])
+Microsoft.FSharp.Collections.ArrayModule: Boolean Contains[T](T, T[])
+Microsoft.FSharp.Collections.ArrayModule: Boolean Exists2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Boolean ForAll2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Boolean IsEmpty[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: Int32 CompareWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], T[], T[])
+Microsoft.FSharp.Collections.ArrayModule: Int32 FindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Int32 FindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Int32 Length[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Collections.ArrayModule+Parallel
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryExactlyOne[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryHead[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryItem[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryLast[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Collections.Generic.IEnumerable`1[T] ToSeq[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[System.Int32,T][] Indexed[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T,T][] Pairwise[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T1,T2][] AllPairs[T1,T2](T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T1,T2][] Zip[T1,T2](T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T1[],T2[]] Unzip[T1,T2](System.Tuple`2[T1,T2][])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TKey,System.Int32][] CountBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TKey,T[]][] GroupBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TResult[],TState] MapFoldBack[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,System.Tuple`2[TResult,TState]]], T[], TState)
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TResult[],TState] MapFold[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Tuple`2[TResult,TState]]], TState, T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T[],T[]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T[],T[]] SplitAt[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`3[T1,T2,T3][] Zip3[T1,T2,T3](T1[], T2[], T3[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`3[T1[],T2[],T3[]] Unzip3[T1,T2,T3](System.Tuple`3[T1,T2,T3][])
+Microsoft.FSharp.Collections.ArrayModule: T Average$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Average[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T ExactlyOne[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T FindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Find[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Get[T](T[], Int32)
+Microsoft.FSharp.Collections.ArrayModule: T Head[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T Item[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T Last[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T MaxBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Max[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T MinBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Min[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T ReduceBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Reduce[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Sum$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Sum[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult AverageBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult AverageBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult Pick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult SumBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult SumBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] Collect[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult[]], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], T1[], T2[], T3[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] MapIndexed2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]]], T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: TState Fold2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TState]]], TState, T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: TState FoldBack2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], T1[], T2[], TState)
+Microsoft.FSharp.Collections.ArrayModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], T[], TState)
+Microsoft.FSharp.Collections.ArrayModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, T[])
+Microsoft.FSharp.Collections.ArrayModule: TState[] ScanBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], T[], TState)
+Microsoft.FSharp.Collections.ArrayModule: TState[] Scan[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Append[T](T[], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Concat[T](System.Collections.Generic.IEnumerable`1[T[]])
+Microsoft.FSharp.Collections.ArrayModule: T[] Copy[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Create[T](Int32, T)
+Microsoft.FSharp.Collections.ArrayModule: T[] DistinctBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Distinct[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Empty[T]()
+Microsoft.FSharp.Collections.ArrayModule: T[] Except[T](System.Collections.Generic.IEnumerable`1[T], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] GetSubArray[T](T[], Int32, Int32)
+Microsoft.FSharp.Collections.ArrayModule: T[] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T])
+Microsoft.FSharp.Collections.ArrayModule: T[] InsertAt[T](Int32, T, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] InsertManyAt[T](Int32, System.Collections.Generic.IEnumerable`1[T], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] OfList[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ArrayModule: T[] OfSeq[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.ArrayModule: T[] Permute[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.Int32], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] RemoveAt[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] RemoveManyAt[T](Int32, Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Replicate[T](Int32, T)
+Microsoft.FSharp.Collections.ArrayModule: T[] Reverse[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Singleton[T](T)
+Microsoft.FSharp.Collections.ArrayModule: T[] SkipWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Skip[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] SortByDescending[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] SortBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] SortDescending[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] SortWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Sort[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Tail[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] TakeWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Take[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Truncate[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Unfold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[T,TState]]], TState)
+Microsoft.FSharp.Collections.ArrayModule: T[] UpdateAt[T](Int32, T, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Where[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] ZeroCreate[T](Int32)
+Microsoft.FSharp.Collections.ArrayModule: T[][] ChunkBySize[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[][] SplitInto[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[][] Transpose[T](System.Collections.Generic.IEnumerable`1[T[]])
+Microsoft.FSharp.Collections.ArrayModule: T[][] Windowed[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: Void CopyTo[T](T[], Int32, T[], Int32, Int32)
+Microsoft.FSharp.Collections.ArrayModule: Void Fill[T](T[], Int32, Int32, T)
+Microsoft.FSharp.Collections.ArrayModule: Void Iterate2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]], T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: Void IterateIndexed2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]]], T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], T[])
+Microsoft.FSharp.Collections.ArrayModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[])
+Microsoft.FSharp.Collections.ArrayModule: Void Set[T](T[], Int32, T)
+Microsoft.FSharp.Collections.ArrayModule: Void SortInPlaceBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
+Microsoft.FSharp.Collections.ArrayModule: Void SortInPlaceWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], T[])
+Microsoft.FSharp.Collections.ArrayModule: Void SortInPlace[T](T[])
+Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] FromFunction[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]])
+Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] NonStructural$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]])
+Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] NonStructural[T]()
+Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] Structural[T]()
+Microsoft.FSharp.Collections.FSharpList`1+Tags[T]: Int32 Cons
+Microsoft.FSharp.Collections.FSharpList`1+Tags[T]: Int32 Empty
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean Equals(Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean Equals(System.Object)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean IsCons
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean IsEmpty
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean get_IsCons()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean get_IsEmpty()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 CompareTo(Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 GetHashCode()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 GetReverseIndex(Int32, Int32)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 Length
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 Tag
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 get_Length()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 get_Tag()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1+Tags[T]
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Cons(T, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Empty
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] GetSlice(Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Tail
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] TailOrNull
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] get_Empty()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] get_Tail()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] get_TailOrNull()
+Microsoft.FSharp.Collections.FSharpList`1[T]: System.String ToString()
+Microsoft.FSharp.Collections.FSharpList`1[T]: T Head
+Microsoft.FSharp.Collections.FSharpList`1[T]: T HeadOrDefault
+Microsoft.FSharp.Collections.FSharpList`1[T]: T Item [Int32]
+Microsoft.FSharp.Collections.FSharpList`1[T]: T get_Head()
+Microsoft.FSharp.Collections.FSharpList`1[T]: T get_HeadOrDefault()
+Microsoft.FSharp.Collections.FSharpList`1[T]: T get_Item(Int32)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Void .ctor(T, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean ContainsKey(TKey)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean Equals(System.Object)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean IsEmpty
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean TryGetValue(TKey, TValue ByRef)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean get_IsEmpty()
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Int32 Count
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Int32 GetHashCode()
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Int32 get_Count()
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Add(TKey, TValue)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Change(TKey, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpOption`1[TValue],Microsoft.FSharp.Core.FSharpOption`1[TValue]])
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Remove(TKey)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Core.FSharpOption`1[TValue] TryFind(TKey)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TKey] Keys
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TKey] get_Keys()
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TValue] Values
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TValue] get_Values()
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.String ToString()
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: TValue Item [TKey]
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: TValue get_Item(TKey)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Void .ctor(System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,TValue]])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean Contains(T)
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean Equals(System.Object)
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsEmpty
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsProperSubsetOf(Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsProperSupersetOf(Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsSubsetOf(Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsSupersetOf(Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean get_IsEmpty()
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Int32 Count
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Int32 GetHashCode()
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Int32 get_Count()
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] Add(T)
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] Remove(T)
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] op_Addition(Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] op_Subtraction(Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: System.String ToString()
+Microsoft.FSharp.Collections.FSharpSet`1[T]: T MaximumElement
+Microsoft.FSharp.Collections.FSharpSet`1[T]: T MinimumElement
+Microsoft.FSharp.Collections.FSharpSet`1[T]: T get_MaximumElement()
+Microsoft.FSharp.Collections.FSharpSet`1[T]: T get_MinimumElement()
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Void .ctor(System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] FromFunctions[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]])
+Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] LimitedStructural[T](Int32)
+Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] NonStructural$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]])
+Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] NonStructural[T]()
+Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] Reference[T]()
+Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] Structural[T]()
+Microsoft.FSharp.Collections.ListModule: Boolean Contains[T](T, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Boolean Exists2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Boolean ForAll2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Boolean IsEmpty[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Int32 CompareWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], Microsoft.FSharp.Collections.FSharpList`1[T], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Int32 FindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Int32 FindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Int32 Length[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] ChunkBySize[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] SplitInto[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] Transpose[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpList`1[T]])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] Windowed[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[System.Int32,T]] Indexed[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T,T]] Pairwise[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T1,T2]] AllPairs[T1,T2](Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T1,T2]] Zip[T1,T2](Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,Microsoft.FSharp.Collections.FSharpList`1[T]]] GroupBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,System.Int32]] CountBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[T1,T2,T3]] Zip3[T1,T2,T3](Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2], Microsoft.FSharp.Collections.FSharpList`1[T3])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Collect[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Collections.FSharpList`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2], Microsoft.FSharp.Collections.FSharpList`1[T3])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] MapIndexed2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TState] ScanBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Collections.FSharpList`1[T], TState)
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TState] Scan[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Append[T](Microsoft.FSharp.Collections.FSharpList`1[T], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Concat[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpList`1[T]])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] DistinctBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Distinct[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Empty[T]()
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Except[T](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] InsertAt[T](Int32, T, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] InsertManyAt[T](Int32, System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] OfArray[T](T[])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] OfSeq[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Permute[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.Int32], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RemoveAt[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RemoveManyAt[T](Int32, Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Replicate[T](Int32, T)
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Reverse[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Singleton[T](T)
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SkipWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Skip[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortByDescending[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortDescending[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Sort[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Tail[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] TakeWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Take[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Truncate[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Unfold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[T,TState]]], TState)
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] UpdateAt[T](Int32, T, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Where[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryExactlyOne[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryHead[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryItem[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryLast[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: System.Collections.Generic.IEnumerable`1[T] ToSeq[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[T1],Microsoft.FSharp.Collections.FSharpList`1[T2]] Unzip[T1,T2](Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T1,T2]])
+Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[TResult],TState] MapFoldBack[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,System.Tuple`2[TResult,TState]]], Microsoft.FSharp.Collections.FSharpList`1[T], TState)
+Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[TResult],TState] MapFold[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Tuple`2[TResult,TState]]], TState, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[T],Microsoft.FSharp.Collections.FSharpList`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[T],Microsoft.FSharp.Collections.FSharpList`1[T]] SplitAt[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: System.Tuple`3[Microsoft.FSharp.Collections.FSharpList`1[T1],Microsoft.FSharp.Collections.FSharpList`1[T2],Microsoft.FSharp.Collections.FSharpList`1[T3]] Unzip3[T1,T2,T3](Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[T1,T2,T3]])
+Microsoft.FSharp.Collections.ListModule: T Average$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Average[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T ExactlyOne[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T FindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Find[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Get[T](Microsoft.FSharp.Collections.FSharpList`1[T], Int32)
+Microsoft.FSharp.Collections.ListModule: T Head[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Item[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Last[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T MaxBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Max[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T MinBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Min[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T ReduceBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Reduce[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Sum$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Sum[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: TResult AverageBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: TResult AverageBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: TResult Pick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: TResult SumBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: TResult SumBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: TState Fold2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TState]]], TState, Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: TState FoldBack2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2], TState)
+Microsoft.FSharp.Collections.ListModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Collections.FSharpList`1[T], TState)
+Microsoft.FSharp.Collections.ListModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T[] ToArray[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Void Iterate2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Void IterateIndexed2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.MapModule: Boolean ContainsKey[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Boolean Exists[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Boolean ForAll[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Boolean IsEmpty[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Int32 Count[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,T]] ToList[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TResult] Map[TKey,T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Add[TKey,T](TKey, T, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Change[TKey,T](TKey, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpOption`1[T],Microsoft.FSharp.Core.FSharpOption`1[T]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Empty[TKey,T]()
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Filter[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] OfArray[TKey,T](System.Tuple`2[TKey,T][])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] OfList[TKey,T](Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,T]])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] OfSeq[TKey,T](System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,T]])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Remove[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Core.FSharpOption`1[TKey] TryFindKey[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[TKey,T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Collections.Generic.ICollection`1[TKey] Keys[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Collections.Generic.ICollection`1[T] Values[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,T]] ToSeq[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpMap`2[TKey,T],Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]] Partition[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Tuple`2[TKey,T] MaxKeyValue[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Tuple`2[TKey,T] MinKeyValue[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Tuple`2[TKey,T][] ToArray[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: T Find[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: TKey FindKey[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: TResult Pick[TKey,T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: TState FoldBack[TKey,T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T], TState)
+Microsoft.FSharp.Collections.MapModule: TState Fold[TKey,T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]]], TState, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Void Iterate[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.SeqModule: Boolean Contains[T](T, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Boolean Exists2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Boolean ForAll2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Boolean IsEmpty[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Int32 CompareWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Int32 FindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Int32 FindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Int32 Length[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryExactlyOne[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryHead[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryItem[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryLast[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Collections.Generic.IEnumerable`1[T]] Transpose[TCollection,T](System.Collections.Generic.IEnumerable`1[TCollection])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[System.Int32,T]] Indexed[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[T,T]] Pairwise[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[T1,T2]] AllPairs[T1,T2](System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[T1,T2]] Zip[T1,T2](System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,System.Collections.Generic.IEnumerable`1[T]]] GroupBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,System.Int32]] CountBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`3[T1,T2,T3]] Zip3[T1,T2,T3](System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2], System.Collections.Generic.IEnumerable`1[T3])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Collect[T,TCollection,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TCollection], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2], System.Collections.Generic.IEnumerable`1[T3])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] MapIndexed2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TState] ScanBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], System.Collections.Generic.IEnumerable`1[T], TState)
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TState] Scan[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T[]] ChunkBySize[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T[]] SplitInto[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T[]] Windowed[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Append[T](System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Cache[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Cast[T](System.Collections.IEnumerable)
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Concat[TCollection,T](System.Collections.Generic.IEnumerable`1[TCollection])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Delay[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Collections.Generic.IEnumerable`1[T]])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] DistinctBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Distinct[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Empty[T]()
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Except[T](System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] InitializeInfinite[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] InsertAt[T](Int32, T, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] InsertManyAt[T](Int32, System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] OfArray[T](T[])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] OfList[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Permute[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.Int32], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] ReadOnly[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RemoveAt[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RemoveManyAt[T](Int32, Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Replicate[T](Int32, T)
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Reverse[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Singleton[T](T)
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SkipWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Skip[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortByDescending[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortDescending[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Sort[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Tail[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] TakeWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Take[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Truncate[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Unfold[TState,T](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[T,TState]]], TState)
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] UpdateAt[T](Int32, T, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Where[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Tuple`2[System.Collections.Generic.IEnumerable`1[TResult],TState] MapFoldBack[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,System.Tuple`2[TResult,TState]]], System.Collections.Generic.IEnumerable`1[T], TState)
+Microsoft.FSharp.Collections.SeqModule: System.Tuple`2[System.Collections.Generic.IEnumerable`1[TResult],TState] MapFold[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Tuple`2[TResult,TState]]], TState, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Average$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Average[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T ExactlyOne[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T FindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Find[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Get[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Head[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Item[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Last[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T MaxBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Max[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T MinBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Min[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T ReduceBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Reduce[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Sum$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Sum[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: TResult AverageBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: TResult AverageBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: TResult Pick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: TResult SumBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: TResult SumBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: TState Fold2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TState]]], TState, System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: TState FoldBack2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2], TState)
+Microsoft.FSharp.Collections.SeqModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], System.Collections.Generic.IEnumerable`1[T], TState)
+Microsoft.FSharp.Collections.SeqModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T[] ToArray[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Void Iterate2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: Void IterateIndexed2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean Contains[T](T, Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean IsEmpty[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean IsProperSubset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean IsProperSuperset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean IsSubset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean IsSuperset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Int32 Count[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Add[T](T, Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Difference[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Empty[T]()
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] IntersectMany[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpSet`1[T]])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Intersect[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] OfArray[T](T[])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] OfList[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] OfSeq[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Remove[T](T, Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Singleton[T](T)
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] UnionMany[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpSet`1[T]])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Union[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: System.Collections.Generic.IEnumerable`1[T] ToSeq[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpSet`1[T],Microsoft.FSharp.Collections.FSharpSet`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: T MaxElement[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: T MinElement[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Collections.FSharpSet`1[T], TState)
+Microsoft.FSharp.Collections.SetModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: T[] ToArray[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Boolean IsCancellationRequested
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Boolean get_IsCancellationRequested()
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn OnCancellation()
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn OnSuccess(T)
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn Success(Microsoft.FSharp.Control.AsyncActivation`1[T], T)
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Void OnExceptionRaised()
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn Bind[T,TResult](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn CallThenInvoke[T,TResult](Microsoft.FSharp.Control.AsyncActivation`1[T], TResult, Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn Invoke[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Control.AsyncActivation`1[T])
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn TryFinally[T](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn TryWith[T](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]])
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.FSharpAsync`1[T] MakeAsync[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.AsyncActivation`1[T],Microsoft.FSharp.Control.AsyncReturn])
+Microsoft.FSharp.Control.BackgroundTaskBuilder: System.Threading.Tasks.Task`1[T] RunDynamic[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
+Microsoft.FSharp.Control.BackgroundTaskBuilder: System.Threading.Tasks.Task`1[T] Run[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
+Microsoft.FSharp.Control.CommonExtensions: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AsyncWrite(System.IO.Stream, Byte[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.CommonExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Byte[]] AsyncReadBytes(System.IO.Stream, Int32)
+Microsoft.FSharp.Control.CommonExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Int32] AsyncRead(System.IO.Stream, Byte[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.CommonExtensions: System.IDisposable SubscribeToObservable[T](System.IObservable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.CommonExtensions: Void AddToObservable[T](System.IObservable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[System.Tuple`2[T,T]],System.Tuple`2[T,T]] Pairwise[TDel,T](Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult],TResult] Choose[T,TResult,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult],TResult] Map[T,TResult,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult],TResult] Scan[TResult,T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], TResult, Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] Filter[T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] Merge[TDel1,T,TDel2](Microsoft.FSharp.Control.IEvent`2[TDel1,T], Microsoft.FSharp.Control.IEvent`2[TDel2,T])
+Microsoft.FSharp.Control.EventModule: System.Tuple`2[Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult1],TResult1],Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult2],TResult2]] Split[T,TResult1,TResult2,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[TResult1,TResult2]], Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: System.Tuple`2[Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T],Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T]] Partition[T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: Void Add[T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Control.FSharpAsync`1[T]] StartChild[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpChoice`2[T,System.Exception]] Catch[T](Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[T]] Choice[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[T]]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AwaitTask(System.Threading.Tasks.Task)
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Ignore[T](Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Sleep(Int32)
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Sleep(System.TimeSpan)
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] SwitchToContext(System.Threading.SynchronizationContext)
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] SwitchToNewThread()
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] SwitchToThreadPool()
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Boolean] AwaitIAsyncResult(System.IAsyncResult, Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Boolean] AwaitWaitHandle(System.Threading.WaitHandle, Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.IDisposable] OnCancel(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Threading.CancellationToken] CancellationToken
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Threading.CancellationToken] get_CancellationToken()
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Threading.Tasks.Task`1[T]] StartChildAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.Tasks.TaskCreationOptions])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Parallel[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Parallel[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Sequential[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitEvent[TDel,T](Microsoft.FSharp.Control.IEvent`2[TDel,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitTask[T](System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,TArg2,TArg3,T](TArg1, TArg2, TArg3, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`5[TArg1,TArg2,TArg3,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,TArg2,T](TArg1, TArg2, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`4[TArg1,TArg2,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,T](TArg1, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[TArg1,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromContinuations[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit],Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.Unit],Microsoft.FSharp.Core.FSharpFunc`2[System.OperationCanceledException,Microsoft.FSharp.Core.Unit]],Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] TryCancelled[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.OperationCanceledException,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.FSharpAsync: System.Threading.CancellationToken DefaultCancellationToken
+Microsoft.FSharp.Control.FSharpAsync: System.Threading.CancellationToken get_DefaultCancellationToken()
+Microsoft.FSharp.Control.FSharpAsync: System.Threading.Tasks.Task`1[T] StartAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.Tasks.TaskCreationOptions], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsync: System.Threading.Tasks.Task`1[T] StartImmediateAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsync: System.Tuple`3[Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[TArg,System.AsyncCallback,System.Object],System.IAsyncResult],Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T],Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,Microsoft.FSharp.Core.Unit]] AsBeginEnd[TArg,T](Microsoft.FSharp.Core.FSharpFunc`2[TArg,Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.FSharpAsync: T RunSynchronously[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsync: Void CancelDefaultToken()
+Microsoft.FSharp.Control.FSharpAsync: Void Start(Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsync: Void StartImmediate(Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsync: Void StartWithContinuations[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[System.OperationCanceledException,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] For[T](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] While(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Zero()
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Bind[T,TResult](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[TResult]])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Using[T,TResult](T, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[TResult]])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] Combine[T](Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] Delay[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] ReturnFrom[T](Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] Return[T](T)
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] TryFinally[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] TryWith[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply]: Void Reply(TReply)
+Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate] Publish
+Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate] get_Publish()
+Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Void .ctor()
+Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Void Trigger(System.Object[])
+Microsoft.FSharp.Control.FSharpEvent`1[T]: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] Publish
+Microsoft.FSharp.Control.FSharpEvent`1[T]: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] get_Publish()
+Microsoft.FSharp.Control.FSharpEvent`1[T]: Void .ctor()
+Microsoft.FSharp.Control.FSharpEvent`1[T]: Void Trigger(T)
+Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Microsoft.FSharp.Control.IEvent`2[TDelegate,TArgs] Publish
+Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Microsoft.FSharp.Control.IEvent`2[TDelegate,TArgs] get_Publish()
+Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Void .ctor()
+Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Void Trigger(System.Object, TArgs)
+Microsoft.FSharp.Control.FSharpHandler`1[T]: System.IAsyncResult BeginInvoke(System.Object, T, System.AsyncCallback, System.Object)
+Microsoft.FSharp.Control.FSharpHandler`1[T]: Void .ctor(System.Object, IntPtr)
+Microsoft.FSharp.Control.FSharpHandler`1[T]: Void EndInvoke(System.IAsyncResult)
+Microsoft.FSharp.Control.FSharpHandler`1[T]: Void Invoke(System.Object, T)
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 CurrentQueueLength
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 DefaultTimeout
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 get_CurrentQueueLength()
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 get_DefaultTimeout()
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[TMsg]] TryReceive(Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[TReply]] PostAndTryAsyncReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[T]] TryScan[T](Microsoft.FSharp.Core.FSharpFunc`2[TMsg,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[TMsg] Receive(Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[TReply] PostAndAsyncReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[T] Scan[T](Microsoft.FSharp.Core.FSharpFunc`2[TMsg,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpHandler`1[System.Exception] Error
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg] Start(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg],Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Core.FSharpOption`1[TReply] TryPostAndReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: TReply PostAndReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void .ctor(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg],Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void Post(TMsg)
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void Start()
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void add_Error(Microsoft.FSharp.Control.FSharpHandler`1[System.Exception])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void remove_Error(Microsoft.FSharp.Control.FSharpHandler`1[System.Exception])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void set_DefaultTimeout(Int32)
+Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate]: Void AddHandler(TDelegate)
+Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate]: Void RemoveHandler(TDelegate)
+Microsoft.FSharp.Control.LazyExtensions: System.Lazy`1[T] CreateFromValue[T](T)
+Microsoft.FSharp.Control.LazyExtensions: System.Lazy`1[T] Create[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T])
+Microsoft.FSharp.Control.LazyExtensions: T Force[T](System.Lazy`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IDisposable Subscribe[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[System.Tuple`2[T,T]] Pairwise[T](System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[TResult] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[TResult] Scan[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], TResult, System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[T] Merge[T](System.IObservable`1[T], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.Tuple`2[System.IObservable`1[TResult1],System.IObservable`1[TResult2]] Split[T,TResult1,TResult2](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[TResult1,TResult2]], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.Tuple`2[System.IObservable`1[T],System.IObservable`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: Void Add[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], System.IObservable`1[T])
+Microsoft.FSharp.Control.TaskBuilder: System.Threading.Tasks.Task`1[T] RunDynamic[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
+Microsoft.FSharp.Control.TaskBuilder: System.Threading.Tasks.Task`1[T] Run[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit] For[T,TOverall](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit] While[TOverall](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit] Zero[TOverall]()
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] Combine[TOverall,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] Delay[TOverall,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] TryFinally[TOverall,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] TryWith[TOverall,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] Return[T](T)
+Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority: Boolean TaskBuilderBase.BindDynamic.Static[TOverall,TResult1,TResult2](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall]] ByRef, System.Threading.Tasks.Task`1[TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind[TResult1,TOverall,TResult2](Microsoft.FSharp.Control.TaskBuilderBase, System.Threading.Tasks.Task`1[TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom[T](Microsoft.FSharp.Control.TaskBuilderBase, System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Boolean TaskBuilderBase.BindDynamic.Static$W[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike,TAwaiter], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall]] ByRef, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Boolean TaskBuilderBase.BindDynamic.Static[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall]] ByRef, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind$W[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike,TAwaiter], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,System.Boolean], Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] TaskBuilderBase.Using[TResource,TOverall,T](Microsoft.FSharp.Control.TaskBuilderBase, TResource, Microsoft.FSharp.Core.FSharpFunc`2[TResource,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom$W[TTaskLike,TAwaiter,T](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike,TAwaiter], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,T], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,System.Boolean], Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike)
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom[TTaskLike,TAwaiter,T](Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike)
+Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind[TResult1,TOverall,TResult2](Microsoft.FSharp.Control.TaskBuilderBase, Microsoft.FSharp.Control.FSharpAsync`1[TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom[T](Microsoft.FSharp.Control.TaskBuilderBase, Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.BackgroundTaskBuilder backgroundTask
+Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.BackgroundTaskBuilder get_backgroundTask()
+Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.TaskBuilder get_task()
+Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.TaskBuilder task
+Microsoft.FSharp.Control.TaskStateMachineData`1[T]: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1[T] MethodBuilder
+Microsoft.FSharp.Control.TaskStateMachineData`1[T]: T Result
+Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AsyncDownloadFile(System.Net.WebClient, System.Uri, System.String)
+Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Byte[]] AsyncDownloadData(System.Net.WebClient, System.Uri)
+Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Net.WebResponse] AsyncGetResponse(System.Net.WebRequest)
+Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.String] AsyncDownloadString(System.Net.WebClient, System.Uri)
+Microsoft.FSharp.Core.AbstractClassAttribute: Void .ctor()
+Microsoft.FSharp.Core.AllowNullLiteralAttribute: Boolean Value
+Microsoft.FSharp.Core.AllowNullLiteralAttribute: Boolean get_Value()
+Microsoft.FSharp.Core.AllowNullLiteralAttribute: Void .ctor()
+Microsoft.FSharp.Core.AllowNullLiteralAttribute: Void .ctor(Boolean)
+Microsoft.FSharp.Core.AutoOpenAttribute: System.String Path
+Microsoft.FSharp.Core.AutoOpenAttribute: System.String get_Path()
+Microsoft.FSharp.Core.AutoOpenAttribute: Void .ctor()
+Microsoft.FSharp.Core.AutoOpenAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.AutoSerializableAttribute: Boolean Value
+Microsoft.FSharp.Core.AutoSerializableAttribute: Boolean get_Value()
+Microsoft.FSharp.Core.AutoSerializableAttribute: Void .ctor(Boolean)
+Microsoft.FSharp.Core.ByRefKinds: Microsoft.FSharp.Core.ByRefKinds+In
+Microsoft.FSharp.Core.ByRefKinds: Microsoft.FSharp.Core.ByRefKinds+InOut
+Microsoft.FSharp.Core.ByRefKinds: Microsoft.FSharp.Core.ByRefKinds+Out
+Microsoft.FSharp.Core.CLIEventAttribute: Void .ctor()
+Microsoft.FSharp.Core.CLIMutableAttribute: Void .ctor()
+Microsoft.FSharp.Core.ClassAttribute: Void .ctor()
+Microsoft.FSharp.Core.ComparisonConditionalOnAttribute: Void .ctor()
+Microsoft.FSharp.Core.CompilationArgumentCountsAttribute: System.Collections.Generic.IEnumerable`1[System.Int32] Counts
+Microsoft.FSharp.Core.CompilationArgumentCountsAttribute: System.Collections.Generic.IEnumerable`1[System.Int32] get_Counts()
+Microsoft.FSharp.Core.CompilationArgumentCountsAttribute: Void .ctor(Int32[])
+Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 SequenceNumber
+Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 VariantNumber
+Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 get_SequenceNumber()
+Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 get_VariantNumber()
+Microsoft.FSharp.Core.CompilationMappingAttribute: Microsoft.FSharp.Core.SourceConstructFlags SourceConstructFlags
+Microsoft.FSharp.Core.CompilationMappingAttribute: Microsoft.FSharp.Core.SourceConstructFlags get_SourceConstructFlags()
+Microsoft.FSharp.Core.CompilationMappingAttribute: System.String ResourceName
+Microsoft.FSharp.Core.CompilationMappingAttribute: System.String get_ResourceName()
+Microsoft.FSharp.Core.CompilationMappingAttribute: System.Type[] TypeDefinitions
+Microsoft.FSharp.Core.CompilationMappingAttribute: System.Type[] get_TypeDefinitions()
+Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(Microsoft.FSharp.Core.SourceConstructFlags)
+Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(Microsoft.FSharp.Core.SourceConstructFlags, Int32)
+Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(Microsoft.FSharp.Core.SourceConstructFlags, Int32, Int32)
+Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(System.String, System.Type[])
+Microsoft.FSharp.Core.CompilationRepresentationAttribute: Microsoft.FSharp.Core.CompilationRepresentationFlags Flags
+Microsoft.FSharp.Core.CompilationRepresentationAttribute: Microsoft.FSharp.Core.CompilationRepresentationFlags get_Flags()
+Microsoft.FSharp.Core.CompilationRepresentationAttribute: Void .ctor(Microsoft.FSharp.Core.CompilationRepresentationFlags)
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Int32 value__
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags Event
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags Instance
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags ModuleSuffix
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags None
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags Static
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags UseNullAsTrueValue
+Microsoft.FSharp.Core.CompilationSourceNameAttribute: System.String SourceName
+Microsoft.FSharp.Core.CompilationSourceNameAttribute: System.String get_SourceName()
+Microsoft.FSharp.Core.CompilationSourceNameAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.CompiledNameAttribute: System.String CompiledName
+Microsoft.FSharp.Core.CompiledNameAttribute: System.String get_CompiledName()
+Microsoft.FSharp.Core.CompiledNameAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean IsError
+Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean IsHidden
+Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean get_IsError()
+Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean get_IsHidden()
+Microsoft.FSharp.Core.CompilerMessageAttribute: Int32 MessageNumber
+Microsoft.FSharp.Core.CompilerMessageAttribute: Int32 get_MessageNumber()
+Microsoft.FSharp.Core.CompilerMessageAttribute: System.String Message
+Microsoft.FSharp.Core.CompilerMessageAttribute: System.String get_Message()
+Microsoft.FSharp.Core.CompilerMessageAttribute: Void .ctor(System.String, Int32)
+Microsoft.FSharp.Core.CompilerMessageAttribute: Void set_IsError(Boolean)
+Microsoft.FSharp.Core.CompilerMessageAttribute: Void set_IsHidden(Boolean)
+Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object)
+Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: TResult EndInvoke(System.IAsyncResult)
+Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: TResult Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
+Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: Void .ctor(System.Object, IntPtr)
+Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: T[] AddManyAndClose(System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: T[] Close()
+Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: Void Add(T)
+Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: Void AddMany(System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Boolean CheckClose
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Boolean get_CheckClose()
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Int32 GenerateNext(System.Collections.Generic.IEnumerable`1[T] ByRef)
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: System.Collections.Generic.IEnumerator`1[T] GetFreshEnumerator()
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: T LastGenerated
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: T get_LastGenerated()
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Void .ctor()
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Void Close()
+Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace[] GetNestedNamespaces()
+Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.String NamespaceName
+Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.String get_NamespaceName()
+Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.Type ResolveTypeName(System.String)
+Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.Type[] GetTypes()
+Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: Int32 ResumptionPoint
+Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: Int32 get_ResumptionPoint()
+Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: TData Data
+Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: TData get_Data()
+Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: Void set_Data(TData)
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider2: System.Reflection.MethodBase ApplyStaticArgumentsForMethod(System.Reflection.MethodBase, System.String, System.Object[])
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider2: System.Reflection.ParameterInfo[] GetStaticParametersForMethod(System.Reflection.MethodBase)
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Byte[] GetGeneratedAssemblyContents(System.Reflection.Assembly)
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace[] GetNamespaces()
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Microsoft.FSharp.Quotations.FSharpExpr GetInvokerExpression(System.Reflection.MethodBase, Microsoft.FSharp.Quotations.FSharpExpr[])
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: System.EventHandler Invalidate
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: System.Reflection.ParameterInfo[] GetStaticParameters(System.Type)
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: System.Type ApplyStaticArguments(System.Type, System.String[], System.Object[])
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Void add_Invalidate(System.EventHandler)
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Void remove_Invalidate(System.EventHandler)
+Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] AddManyAndClose(System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Close()
+Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Void Add(T)
+Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Void AddMany(System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object)
+Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: Void .ctor(System.Object, IntPtr)
+Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: Void EndInvoke(System.IAsyncResult)
+Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: Void Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
+Microsoft.FSharp.Core.CompilerServices.NoEagerConstraintApplicationAttribute: Void .ctor()
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean CombineDynamic[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean TryFinallyAsyncDynamic[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean TryWithDynamic[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean WhileDynamic[TData](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean YieldDynamic[TData](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] For[T,TData](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] While[TData](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] Yield[TData]()
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] Zero[TData]()
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] Combine[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] Delay[TData,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] TryFinallyAsync[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] TryFinally[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] TryWith[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] Using[TResource,TData,T](TResource, Microsoft.FSharp.Core.FSharpFunc`2[TResource,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: Boolean EndInvoke(System.IAsyncResult)
+Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: Boolean Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
+Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object)
+Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: Void .ctor(System.Object, IntPtr)
+Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData]: Int32 ResumptionPoint
+Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData]: Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData] ResumptionDynamicInfo
+Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData]: TData Data
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData] ResumptionFunc
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData] get_ResumptionFunc()
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: System.Object ResumptionData
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: System.Object get_ResumptionData()
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void .ctor(Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData])
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void MoveNext(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void SetStateMachine(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine)
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void set_ResumptionData(System.Object)
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void set_ResumptionFunc(Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData])
+Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: Boolean EndInvoke(System.IAsyncResult)
+Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: Boolean Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
+Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object)
+Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: Void .ctor(System.Object, IntPtr)
+Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: Microsoft.FSharp.Control.IEvent`2[TDelegate,TArgs] CreateEvent[TDelegate,TArgs](Microsoft.FSharp.Core.FSharpFunc`2[TDelegate,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[TDelegate,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpFunc`2[System.Object,Microsoft.FSharp.Core.FSharpFunc`2[TArgs,Microsoft.FSharp.Core.Unit]],TDelegate])
+Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[TResult] EnumerateFromFunctions[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
+Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[TResult] EnumerateUsing[T,TCollection,TResult](T, Microsoft.FSharp.Core.FSharpFunc`2[T,TCollection])
+Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[T] EnumerateThenFinally[T](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[T] EnumerateWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine, System.AsyncCallback, System.Object)
+Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void .ctor(System.Object, IntPtr)
+Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void EndInvoke(System.IAsyncResult)
+Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine)
+Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Boolean __useResumableCode[T]()
+Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] __resumableEntry()
+Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: T __resumeAt[T](Int32)
+Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: TResult __stateMachine[TData,TResult](Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult])
+Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Void __debugPoint(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: System.String AssemblyName
+Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: System.String get_AssemblyName()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: Void .ctor()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderAttribute: Void .ctor()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean IsHostedExecution
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean IsInvalidationSupported
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean SystemRuntimeContainsType(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean get_IsHostedExecution()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean get_IsInvalidationSupported()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String ResolutionFolder
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String RuntimeAssembly
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String TemporaryFolder
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String get_ResolutionFolder()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String get_RuntimeAssembly()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String get_TemporaryFolder()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String[] ReferencedAssemblies
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String[] get_ReferencedAssemblies()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.Version SystemRuntimeAssemblyVersion
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.Version get_SystemRuntimeAssemblyVersion()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void .ctor(Microsoft.FSharp.Core.FSharpFunc`2[System.String,System.Boolean])
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void .ctor(Microsoft.FSharp.Core.FSharpFunc`2[System.String,System.Boolean], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.String[]])
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_IsHostedExecution(Boolean)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_IsInvalidationSupported(Boolean)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_ReferencedAssemblies(System.String[])
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_ResolutionFolder(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_RuntimeAssembly(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_SystemRuntimeAssemblyVersion(System.Version)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_TemporaryFolder(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 Column
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 Line
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 get_Column()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 get_Line()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: System.String FilePath
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: System.String get_FilePath()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void .ctor()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void set_Column(Int32)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void set_FilePath(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void set_Line(Int32)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderEditorHideMethodsAttribute: Void .ctor()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes: Int32 value__
+Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes: Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes IsErased
+Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes: Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes SuppressRelocate
+Microsoft.FSharp.Core.CompilerServices.TypeProviderXmlDocAttribute: System.String CommentText
+Microsoft.FSharp.Core.CompilerServices.TypeProviderXmlDocAttribute: System.String get_CommentText()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderXmlDocAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.CustomComparisonAttribute: Void .ctor()
+Microsoft.FSharp.Core.CustomEqualityAttribute: Void .ctor()
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean AllowIntoPattern
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean IsLikeGroupJoin
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean IsLikeJoin
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean IsLikeZip
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean MaintainsVariableSpace
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean MaintainsVariableSpaceUsingBind
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_AllowIntoPattern()
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_IsLikeGroupJoin()
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_IsLikeJoin()
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_IsLikeZip()
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_MaintainsVariableSpace()
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_MaintainsVariableSpaceUsingBind()
+Microsoft.FSharp.Core.CustomOperationAttribute: System.String JoinConditionWord
+Microsoft.FSharp.Core.CustomOperationAttribute: System.String Name
+Microsoft.FSharp.Core.CustomOperationAttribute: System.String get_JoinConditionWord()
+Microsoft.FSharp.Core.CustomOperationAttribute: System.String get_Name()
+Microsoft.FSharp.Core.CustomOperationAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_AllowIntoPattern(Boolean)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_IsLikeGroupJoin(Boolean)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_IsLikeJoin(Boolean)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_IsLikeZip(Boolean)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_JoinConditionWord(System.String)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_MaintainsVariableSpace(Boolean)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_MaintainsVariableSpaceUsingBind(Boolean)
+Microsoft.FSharp.Core.DefaultAugmentationAttribute: Boolean Value
+Microsoft.FSharp.Core.DefaultAugmentationAttribute: Boolean get_Value()
+Microsoft.FSharp.Core.DefaultAugmentationAttribute: Void .ctor(Boolean)
+Microsoft.FSharp.Core.DefaultValueAttribute: Boolean Check
+Microsoft.FSharp.Core.DefaultValueAttribute: Boolean get_Check()
+Microsoft.FSharp.Core.DefaultValueAttribute: Void .ctor()
+Microsoft.FSharp.Core.DefaultValueAttribute: Void .ctor(Boolean)
+Microsoft.FSharp.Core.EntryPointAttribute: Void .ctor()
+Microsoft.FSharp.Core.EqualityConditionalOnAttribute: Void .ctor()
+Microsoft.FSharp.Core.ExperimentalAttribute: System.String Message
+Microsoft.FSharp.Core.ExperimentalAttribute: System.String get_Message()
+Microsoft.FSharp.Core.ExperimentalAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: Byte ToByte[T](T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: SByte ToSByte[T](T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Byte ToByte[T](T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Double ToDouble$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Double ToDouble[T](T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Collections.FSharpSet`1[T] CreateSet[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Control.FSharpAsyncBuilder DefaultAsyncBuilder
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Control.FSharpAsyncBuilder get_DefaultAsyncBuilder()
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Linq.QueryBuilder get_query()
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Linq.QueryBuilder query
+Microsoft.FSharp.Core.ExtraTopLevelOperators: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: SByte ToSByte[T](T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Single ToSingle$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Single ToSingle[T](T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: System.Collections.Generic.IDictionary`2[TKey,TValue] CreateDictionary[TKey,TValue](System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,TValue]])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: System.Collections.Generic.IReadOnlyDictionary`2[TKey,TValue] CreateReadOnlyDictionary[TKey,TValue](System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,TValue]])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T LazyPattern[T](System.Lazy`1[T])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatLineToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatLineToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatLine[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToStringThenFail[T,TResult](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToString[T](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,System.String])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormat[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T SpliceExpression[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T SpliceUntypedExpression[T](Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T[,] CreateArray2D[?,T](System.Collections.Generic.IEnumerable`1[?])
+Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]: T1 Item
+Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]: T1 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2]: T2 Item
+Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2]: T2 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`2+Tags[T1,T2]: Int32 Choice1Of2
+Microsoft.FSharp.Core.FSharpChoice`2+Tags[T1,T2]: Int32 Choice2Of2
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`2[T1,T2])
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean IsChoice1Of2
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean IsChoice2Of2
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean get_IsChoice1Of2()
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean get_IsChoice2Of2()
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`2[T1,T2])
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 Tag
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2]
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2+Tags[T1,T2]
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2[T1,T2] NewChoice1Of2(T1)
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2[T1,T2] NewChoice2Of2(T2)
+Microsoft.FSharp.Core.FSharpChoice`3+Choice1Of3[T1,T2,T3]: T1 Item
+Microsoft.FSharp.Core.FSharpChoice`3+Choice1Of3[T1,T2,T3]: T1 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`3+Choice2Of3[T1,T2,T3]: T2 Item
+Microsoft.FSharp.Core.FSharpChoice`3+Choice2Of3[T1,T2,T3]: T2 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`3+Choice3Of3[T1,T2,T3]: T3 Item
+Microsoft.FSharp.Core.FSharpChoice`3+Choice3Of3[T1,T2,T3]: T3 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]: Int32 Choice1Of3
+Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]: Int32 Choice2Of3
+Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]: Int32 Choice3Of3
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3])
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean IsChoice1Of3
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean IsChoice2Of3
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean IsChoice3Of3
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean get_IsChoice1Of3()
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean get_IsChoice2Of3()
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean get_IsChoice3Of3()
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3])
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 Tag
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Choice1Of3[T1,T2,T3]
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Choice2Of3[T1,T2,T3]
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Choice3Of3[T1,T2,T3]
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3] NewChoice1Of3(T1)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3] NewChoice2Of3(T2)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3] NewChoice3Of3(T3)
+Microsoft.FSharp.Core.FSharpChoice`4+Choice1Of4[T1,T2,T3,T4]: T1 Item
+Microsoft.FSharp.Core.FSharpChoice`4+Choice1Of4[T1,T2,T3,T4]: T1 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`4+Choice2Of4[T1,T2,T3,T4]: T2 Item
+Microsoft.FSharp.Core.FSharpChoice`4+Choice2Of4[T1,T2,T3,T4]: T2 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`4+Choice3Of4[T1,T2,T3,T4]: T3 Item
+Microsoft.FSharp.Core.FSharpChoice`4+Choice3Of4[T1,T2,T3,T4]: T3 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`4+Choice4Of4[T1,T2,T3,T4]: T4 Item
+Microsoft.FSharp.Core.FSharpChoice`4+Choice4Of4[T1,T2,T3,T4]: T4 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice1Of4
+Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice2Of4
+Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice3Of4
+Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice4Of4
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4])
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice1Of4
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice2Of4
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice3Of4
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice4Of4
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice1Of4()
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice2Of4()
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice3Of4()
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice4Of4()
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4])
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 Tag
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice1Of4[T1,T2,T3,T4]
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice2Of4[T1,T2,T3,T4]
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice3Of4[T1,T2,T3,T4]
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice4Of4[T1,T2,T3,T4]
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice1Of4(T1)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice2Of4(T2)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice3Of4(T3)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice4Of4(T4)
+Microsoft.FSharp.Core.FSharpChoice`5+Choice1Of5[T1,T2,T3,T4,T5]: T1 Item
+Microsoft.FSharp.Core.FSharpChoice`5+Choice1Of5[T1,T2,T3,T4,T5]: T1 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`5+Choice2Of5[T1,T2,T3,T4,T5]: T2 Item
+Microsoft.FSharp.Core.FSharpChoice`5+Choice2Of5[T1,T2,T3,T4,T5]: T2 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`5+Choice3Of5[T1,T2,T3,T4,T5]: T3 Item
+Microsoft.FSharp.Core.FSharpChoice`5+Choice3Of5[T1,T2,T3,T4,T5]: T3 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`5+Choice4Of5[T1,T2,T3,T4,T5]: T4 Item
+Microsoft.FSharp.Core.FSharpChoice`5+Choice4Of5[T1,T2,T3,T4,T5]: T4 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`5+Choice5Of5[T1,T2,T3,T4,T5]: T5 Item
+Microsoft.FSharp.Core.FSharpChoice`5+Choice5Of5[T1,T2,T3,T4,T5]: T5 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice1Of5
+Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice2Of5
+Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice3Of5
+Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice4Of5
+Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice5Of5
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5])
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice1Of5
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice2Of5
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice3Of5
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice4Of5
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice5Of5
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice1Of5()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice2Of5()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice3Of5()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice4Of5()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice5Of5()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5])
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 Tag
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice1Of5[T1,T2,T3,T4,T5]
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice2Of5[T1,T2,T3,T4,T5]
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice3Of5[T1,T2,T3,T4,T5]
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice4Of5[T1,T2,T3,T4,T5]
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice5Of5[T1,T2,T3,T4,T5]
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice1Of5(T1)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice2Of5(T2)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice3Of5(T3)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice4Of5(T4)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice5Of5(T5)
+Microsoft.FSharp.Core.FSharpChoice`6+Choice1Of6[T1,T2,T3,T4,T5,T6]: T1 Item
+Microsoft.FSharp.Core.FSharpChoice`6+Choice1Of6[T1,T2,T3,T4,T5,T6]: T1 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`6+Choice2Of6[T1,T2,T3,T4,T5,T6]: T2 Item
+Microsoft.FSharp.Core.FSharpChoice`6+Choice2Of6[T1,T2,T3,T4,T5,T6]: T2 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`6+Choice3Of6[T1,T2,T3,T4,T5,T6]: T3 Item
+Microsoft.FSharp.Core.FSharpChoice`6+Choice3Of6[T1,T2,T3,T4,T5,T6]: T3 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`6+Choice4Of6[T1,T2,T3,T4,T5,T6]: T4 Item
+Microsoft.FSharp.Core.FSharpChoice`6+Choice4Of6[T1,T2,T3,T4,T5,T6]: T4 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`6+Choice5Of6[T1,T2,T3,T4,T5,T6]: T5 Item
+Microsoft.FSharp.Core.FSharpChoice`6+Choice5Of6[T1,T2,T3,T4,T5,T6]: T5 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`6+Choice6Of6[T1,T2,T3,T4,T5,T6]: T6 Item
+Microsoft.FSharp.Core.FSharpChoice`6+Choice6Of6[T1,T2,T3,T4,T5,T6]: T6 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice1Of6
+Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice2Of6
+Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice3Of6
+Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice4Of6
+Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice5Of6
+Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice6Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6])
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice1Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice2Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice3Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice4Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice5Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice6Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice1Of6()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice2Of6()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice3Of6()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice4Of6()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice5Of6()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice6Of6()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6])
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 Tag
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice1Of6[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice2Of6[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice3Of6[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice4Of6[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice5Of6[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice6Of6[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice1Of6(T1)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice2Of6(T2)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice3Of6(T3)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice4Of6(T4)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice5Of6(T5)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice6Of6(T6)
+Microsoft.FSharp.Core.FSharpChoice`7+Choice1Of7[T1,T2,T3,T4,T5,T6,T7]: T1 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice1Of7[T1,T2,T3,T4,T5,T6,T7]: T1 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Choice2Of7[T1,T2,T3,T4,T5,T6,T7]: T2 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice2Of7[T1,T2,T3,T4,T5,T6,T7]: T2 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Choice3Of7[T1,T2,T3,T4,T5,T6,T7]: T3 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice3Of7[T1,T2,T3,T4,T5,T6,T7]: T3 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Choice4Of7[T1,T2,T3,T4,T5,T6,T7]: T4 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice4Of7[T1,T2,T3,T4,T5,T6,T7]: T4 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Choice5Of7[T1,T2,T3,T4,T5,T6,T7]: T5 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice5Of7[T1,T2,T3,T4,T5,T6,T7]: T5 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Choice6Of7[T1,T2,T3,T4,T5,T6,T7]: T6 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice6Of7[T1,T2,T3,T4,T5,T6,T7]: T6 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Choice7Of7[T1,T2,T3,T4,T5,T6,T7]: T7 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice7Of7[T1,T2,T3,T4,T5,T6,T7]: T7 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice1Of7
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice2Of7
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice3Of7
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice4Of7
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice5Of7
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice6Of7
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice7Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7])
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice1Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice2Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice3Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice4Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice5Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice6Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice7Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice1Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice2Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice3Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice4Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice5Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice6Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice7Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7])
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 Tag
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice1Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice2Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice3Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice4Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice5Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice6Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice7Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice1Of7(T1)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice2Of7(T2)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice3Of7(T3)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice4Of7(T4)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice5Of7(T5)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice6Of7(T6)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice7Of7(T7)
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] FromConverter(System.Converter`2[T,TResult])
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] op_Implicit(System.Converter`2[T,TResult])
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: System.Converter`2[T,TResult] ToConverter(Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: System.Converter`2[T,TResult] op_Implicit(Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: TResult Invoke(T)
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: V InvokeFast[V](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,V]], T, TResult)
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Void .ctor()
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: W InvokeFast[V,W](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[V,W]]], T, TResult, V)
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: X InvokeFast[V,W,X](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[V,Microsoft.FSharp.Core.FSharpFunc`2[W,X]]]], T, TResult, V, W)
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Y InvokeFast[V,W,X,Y](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[V,Microsoft.FSharp.Core.FSharpFunc`2[W,Microsoft.FSharp.Core.FSharpFunc`2[X,Y]]]]], T, TResult, V, W, X)
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 Major
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 Minor
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 Release
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 get_Major()
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 get_Minor()
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 get_Release()
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Void .ctor(Int32, Int32, Int32)
+Microsoft.FSharp.Core.FSharpOption`1+Tags[T]: Int32 None
+Microsoft.FSharp.Core.FSharpOption`1+Tags[T]: Int32 Some
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean IsNone
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean IsSome
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean get_IsNone(Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean get_IsSome(Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 GetTag(Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1+Tags[T]
+Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] None
+Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] Some(T)
+Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] get_None()
+Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] op_Implicit(T)
+Microsoft.FSharp.Core.FSharpOption`1[T]: System.String ToString()
+Microsoft.FSharp.Core.FSharpOption`1[T]: T Value
+Microsoft.FSharp.Core.FSharpOption`1[T]: T get_Value()
+Microsoft.FSharp.Core.FSharpOption`1[T]: Void .ctor(T)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpRef`1[T])
+Microsoft.FSharp.Core.FSharpRef`1[T]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpRef`1[T])
+Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpRef`1[T]: T Value
+Microsoft.FSharp.Core.FSharpRef`1[T]: T contents
+Microsoft.FSharp.Core.FSharpRef`1[T]: T contents@
+Microsoft.FSharp.Core.FSharpRef`1[T]: T get_Value()
+Microsoft.FSharp.Core.FSharpRef`1[T]: T get_contents()
+Microsoft.FSharp.Core.FSharpRef`1[T]: Void .ctor(T)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Void set_Value(T)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Void set_contents(T)
+Microsoft.FSharp.Core.FSharpResult`2+Tags[T,TError]: Int32 Error
+Microsoft.FSharp.Core.FSharpResult`2+Tags[T,TError]: Int32 Ok
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean Equals(Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean IsError
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean IsOk
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean get_IsError()
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean get_IsOk()
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 Tag
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Microsoft.FSharp.Core.FSharpResult`2+Tags[T,TError]
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Microsoft.FSharp.Core.FSharpResult`2[T,TError] NewError(TError)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Microsoft.FSharp.Core.FSharpResult`2[T,TError] NewOk(T)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: T ResultValue
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: T get_ResultValue()
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: TError ErrorValue
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: TError get_ErrorValue()
+Microsoft.FSharp.Core.FSharpTypeFunc: System.Object Specialize[T]()
+Microsoft.FSharp.Core.FSharpTypeFunc: Void .ctor()
+Microsoft.FSharp.Core.FSharpValueOption`1+Tags[T]: Int32 ValueNone
+Microsoft.FSharp.Core.FSharpValueOption`1+Tags[T]: Int32 ValueSome
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsNone
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsSome
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsValueNone
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsValueSome
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsNone()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsSome()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsValueNone()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsValueSome()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 Tag
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1+Tags[T]
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] NewValueSome(T)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] None
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] Some(T)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] ValueNone
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] get_None()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] get_ValueNone()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] op_Implicit(T)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: System.String ToString()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: T Item
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: T Value
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: T get_Item()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: T get_Value()
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit] FromAction(System.Action)
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T] FromFunc[T](System.Func`1[T])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit] FromAction[T](System.Action`1[T])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit] ToFSharpFunc[T](System.Action`1[T])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] FromFunc[T,TResult](System.Func`2[T,TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] ToFSharpFunc[T,TResult](System.Converter`2[T,TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,Microsoft.FSharp.Core.Unit]]]]] FromAction[T1,T2,T3,T4,T5](System.Action`5[T1,T2,T3,T4,T5])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]]] FromFunc[T1,T2,T3,T4,T5,TResult](System.Func`6[T1,T2,T3,T4,T5,TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]]] FuncFromTupled[T1,T2,T3,T4,T5,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`5[T1,T2,T3,T4,T5],TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.Unit]]]] FromAction[T1,T2,T3,T4](System.Action`4[T1,T2,T3,T4])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]]] FromFunc[T1,T2,T3,T4,TResult](System.Func`5[T1,T2,T3,T4,TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]]] FuncFromTupled[T1,T2,T3,T4,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`4[T1,T2,T3,T4],TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.Unit]]] FromAction[T1,T2,T3](System.Action`3[T1,T2,T3])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]] FromFunc[T1,T2,T3,TResult](System.Func`4[T1,T2,T3,TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]] FuncFromTupled[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[T1,T2,T3],TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]] FromAction[T1,T2](System.Action`2[T1,T2])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]] FromFunc[T1,T2,TResult](System.Func`3[T1,T2,TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]] FuncFromTupled[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[T1,T2],TResult])
+Microsoft.FSharp.Core.GeneralizableValueAttribute: Void .ctor()
+Microsoft.FSharp.Core.InlineIfLambdaAttribute: Void .ctor()
+Microsoft.FSharp.Core.InterfaceAttribute: Void .ctor()
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String AddressOpNotFirstClassString
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String InputArrayEmptyString
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String InputMustBeNonNegativeString
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String InputSequenceEmptyString
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String NoNegateMinValueString
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_AddressOpNotFirstClassString()
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_InputArrayEmptyString()
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_InputMustBeNonNegativeString()
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_InputSequenceEmptyString()
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_NoNegateMinValueString()
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple2[T1,T2](System.Collections.IEqualityComparer, System.Tuple`2[T1,T2], System.Tuple`2[T1,T2])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple3[T1,T2,T3](System.Collections.IEqualityComparer, System.Tuple`3[T1,T2,T3], System.Tuple`3[T1,T2,T3])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple4[T1,T2,T3,T4](System.Collections.IEqualityComparer, System.Tuple`4[T1,T2,T3,T4], System.Tuple`4[T1,T2,T3,T4])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple5[T1,T2,T3,T4,T5](System.Collections.IEqualityComparer, System.Tuple`5[T1,T2,T3,T4,T5], System.Tuple`5[T1,T2,T3,T4,T5])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericEqualityERIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericEqualityIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericEqualityWithComparerIntrinsic[T](System.Collections.IEqualityComparer, T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericGreaterOrEqualIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericGreaterThanIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericLessOrEqualIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericLessThanIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean PhysicalEqualityIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple2[T1,T2](System.Collections.IComparer, System.Tuple`2[T1,T2], System.Tuple`2[T1,T2])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple3[T1,T2,T3](System.Collections.IComparer, System.Tuple`3[T1,T2,T3], System.Tuple`3[T1,T2,T3])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple4[T1,T2,T3,T4](System.Collections.IComparer, System.Tuple`4[T1,T2,T3,T4], System.Tuple`4[T1,T2,T3,T4])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple5[T1,T2,T3,T4,T5](System.Collections.IComparer, System.Tuple`5[T1,T2,T3,T4,T5], System.Tuple`5[T1,T2,T3,T4,T5])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple2[T1,T2](System.Collections.IEqualityComparer, System.Tuple`2[T1,T2])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple3[T1,T2,T3](System.Collections.IEqualityComparer, System.Tuple`3[T1,T2,T3])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple4[T1,T2,T3,T4](System.Collections.IEqualityComparer, System.Tuple`4[T1,T2,T3,T4])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple5[T1,T2,T3,T4,T5](System.Collections.IEqualityComparer, System.Tuple`5[T1,T2,T3,T4,T5])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericComparisonIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericComparisonWithComparerIntrinsic[T](System.Collections.IComparer, T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericHashIntrinsic[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericHashWithComparerIntrinsic[T](System.Collections.IEqualityComparer, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 LimitedGenericHashIntrinsic[T](Int32, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 PhysicalHashIntrinsic[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Boolean TypeTestFast[T](System.Object)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Boolean TypeTestGeneric[T](System.Object)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Char GetString(System.String, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: System.Decimal MakeDecimal(Int32, Int32, Int32, Boolean, Byte)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T CheckThis[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T CreateInstance[T]()
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray2D[T](T[,], Int32, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray3D[T](T[,,], Int32, Int32, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray4D[T](T[,,,], Int32, Int32, Int32, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray[T](T[], Int32)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T UnboxFast[T](System.Object)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T UnboxGeneric[T](System.Object)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void Dispose[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void FailInit()
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void FailStaticInit()
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray2D[T](T[,], Int32, Int32, T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray3D[T](T[,,], Int32, Int32, Int32, T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray4D[T](T[,,,], Int32, Int32, Int32, Int32, T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray[T](T[], Int32, T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean Or(Boolean, Boolean)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean op_Amp(Boolean, Boolean)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean op_BooleanAnd(Boolean, Boolean)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean op_BooleanOr(Boolean, Boolean)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: IntPtr op_IntegerAddressOf[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: T& op_AddressOf[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericEqualityER[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericEqualityWithComparer[T](System.Collections.IEqualityComparer, T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericEquality[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericGreaterOrEqual[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericGreaterThan[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericLessOrEqual[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericLessThan[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean PhysicalEquality[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Byte ByteWithMeasure(Byte)
+Microsoft.FSharp.Core.LanguagePrimitives: Double FloatWithMeasure(Double)
+Microsoft.FSharp.Core.LanguagePrimitives: Int16 Int16WithMeasure(Int16)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericComparisonWithComparer[T](System.Collections.IComparer, T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericComparison[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericHashWithComparer[T](System.Collections.IEqualityComparer, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericHash[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericLimitedHash[T](Int32, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 Int32WithMeasure(Int32)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 ParseInt32(System.String)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 PhysicalHash[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives: Int64 Int64WithMeasure(Int64)
+Microsoft.FSharp.Core.LanguagePrimitives: Int64 ParseInt64(System.String)
+Microsoft.FSharp.Core.LanguagePrimitives: IntPtr IntPtrWithMeasure(IntPtr)
+Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings
+Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+HashCompare
+Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions
+Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators
+Microsoft.FSharp.Core.LanguagePrimitives: SByte SByteWithMeasure(SByte)
+Microsoft.FSharp.Core.LanguagePrimitives: Single Float32WithMeasure(Single)
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IComparer`1[T] FastGenericComparerFromTable[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IComparer`1[T] FastGenericComparer[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IEqualityComparer`1[T] FastGenericEqualityComparerFromTable[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IEqualityComparer`1[T] FastGenericEqualityComparer[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IEqualityComparer`1[T] FastLimitedGenericEqualityComparer[T](Int32)
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IComparer GenericComparer
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IComparer get_GenericComparer()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer GenericEqualityComparer
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer GenericEqualityERComparer
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer get_GenericEqualityComparer()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer get_GenericEqualityERComparer()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Decimal DecimalWithMeasure(System.Decimal)
+Microsoft.FSharp.Core.LanguagePrimitives: T DivideByInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], T, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives: T DivideByIntDynamic[T](T, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives: T DivideByInt[T](T, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives: T EnumToValue[TEnum,T](TEnum)
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericMaximum[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericMinimum[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericOne$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T])
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericOneDynamic[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericOne[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericZero$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T])
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericZeroDynamic[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericZero[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: TEnum EnumOfValue[T,TEnum](T)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult AdditionDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult BitwiseAndDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult BitwiseOrDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedAdditionDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedExplicitDynamic[T,TResult](T)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedMultiplyDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedSubtractionDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedUnaryNegationDynamic[T,TResult](T)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult DivisionDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult EqualityDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult ExclusiveOrDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult ExplicitDynamic[T,TResult](T)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult GreaterThanDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult GreaterThanOrEqualDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult InequalityDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult LeftShiftDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult LessThanDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult LessThanOrEqualDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult LogicalNotDynamic[T,TResult](T)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult ModulusDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult MultiplyDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult RightShiftDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult SubtractionDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult UnaryNegationDynamic[T,TResult](T)
+Microsoft.FSharp.Core.LanguagePrimitives: UInt16 UInt16WithMeasure(UInt16)
+Microsoft.FSharp.Core.LanguagePrimitives: UInt32 ParseUInt32(System.String)
+Microsoft.FSharp.Core.LanguagePrimitives: UInt32 UInt32WithMeasure(UInt32)
+Microsoft.FSharp.Core.LanguagePrimitives: UInt64 ParseUInt64(System.String)
+Microsoft.FSharp.Core.LanguagePrimitives: UInt64 UInt64WithMeasure(UInt64)
+Microsoft.FSharp.Core.LanguagePrimitives: UIntPtr UIntPtrWithMeasure(UIntPtr)
+Microsoft.FSharp.Core.LiteralAttribute: Void .ctor()
+Microsoft.FSharp.Core.MatchFailureException: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.MatchFailureException: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.MatchFailureException: Int32 Data1
+Microsoft.FSharp.Core.MatchFailureException: Int32 Data2
+Microsoft.FSharp.Core.MatchFailureException: Int32 GetHashCode()
+Microsoft.FSharp.Core.MatchFailureException: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.MatchFailureException: Int32 get_Data1()
+Microsoft.FSharp.Core.MatchFailureException: Int32 get_Data2()
+Microsoft.FSharp.Core.MatchFailureException: System.String Data0
+Microsoft.FSharp.Core.MatchFailureException: System.String Message
+Microsoft.FSharp.Core.MatchFailureException: System.String get_Data0()
+Microsoft.FSharp.Core.MatchFailureException: System.String get_Message()
+Microsoft.FSharp.Core.MatchFailureException: Void .ctor()
+Microsoft.FSharp.Core.MatchFailureException: Void .ctor(System.String, Int32, Int32)
+Microsoft.FSharp.Core.MeasureAnnotatedAbbreviationAttribute: Void .ctor()
+Microsoft.FSharp.Core.MeasureAttribute: Void .ctor()
+Microsoft.FSharp.Core.NoComparisonAttribute: Void .ctor()
+Microsoft.FSharp.Core.NoCompilerInliningAttribute: Void .ctor()
+Microsoft.FSharp.Core.NoDynamicInvocationAttribute: Void .ctor()
+Microsoft.FSharp.Core.NoEqualityAttribute: Void .ctor()
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: System.Object FromInt64Dynamic(Int64)
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: System.Object FromStringDynamic(System.String)
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromInt32[T](Int32)
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromInt64[T](Int64)
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromOne[T]()
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromString[T](System.String)
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromZero[T]()
+Microsoft.FSharp.Core.NumericLiterals: Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI
+Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 String.GetReverseIndex(System.String, Int32, Int32)
+Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 [,,,]`1.GetReverseIndex[T](T[,,,], Int32, Int32)
+Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 [,,]`1.GetReverseIndex[T](T[,,], Int32, Int32)
+Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 [,]`1.GetReverseIndex[T](T[,], Int32, Int32)
+Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 []`1.GetReverseIndex[T](T[], Int32, Int32)
+Microsoft.FSharp.Core.Operators+Checked: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T)
+Microsoft.FSharp.Core.Operators+Checked: Byte ToByte[T](T)
+Microsoft.FSharp.Core.Operators+Checked: Char ToChar$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Char], T)
+Microsoft.FSharp.Core.Operators+Checked: Char ToChar[T](T)
+Microsoft.FSharp.Core.Operators+Checked: Int16 ToInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int16], T)
+Microsoft.FSharp.Core.Operators+Checked: Int16 ToInt16[T](T)
+Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T)
+Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T)
+Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt32[T](T)
+Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt[T](T)
+Microsoft.FSharp.Core.Operators+Checked: Int64 ToInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int64], T)
+Microsoft.FSharp.Core.Operators+Checked: Int64 ToInt64[T](T)
+Microsoft.FSharp.Core.Operators+Checked: IntPtr ToIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.IntPtr], T)
+Microsoft.FSharp.Core.Operators+Checked: IntPtr ToIntPtr[T](T)
+Microsoft.FSharp.Core.Operators+Checked: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T)
+Microsoft.FSharp.Core.Operators+Checked: SByte ToSByte[T](T)
+Microsoft.FSharp.Core.Operators+Checked: T op_UnaryNegation$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators+Checked: T op_UnaryNegation[T](T)
+Microsoft.FSharp.Core.Operators+Checked: T3 op_Addition$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators+Checked: T3 op_Addition[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators+Checked: T3 op_Multiply$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators+Checked: T3 op_Multiply[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators+Checked: T3 op_Subtraction$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators+Checked: T3 op_Subtraction[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators+Checked: UInt16 ToUInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt16], T)
+Microsoft.FSharp.Core.Operators+Checked: UInt16 ToUInt16[T](T)
+Microsoft.FSharp.Core.Operators+Checked: UInt32 ToUInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], T)
+Microsoft.FSharp.Core.Operators+Checked: UInt32 ToUInt32[T](T)
+Microsoft.FSharp.Core.Operators+Checked: UInt64 ToUInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt64], T)
+Microsoft.FSharp.Core.Operators+Checked: UInt64 ToUInt64[T](T)
+Microsoft.FSharp.Core.Operators+Checked: UIntPtr ToUIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UIntPtr], T)
+Microsoft.FSharp.Core.Operators+Checked: UIntPtr ToUIntPtr[T](T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Equality$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Equality[T](T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThan$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThanOrEqual$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThanOrEqual[T,TResult](T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThan[T,TResult](T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Inequality$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Inequality[T](T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThan$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThanOrEqual$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThanOrEqual[T,TResult](T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThan[T,TResult](T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Int32 Compare$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Int32 Compare[T](T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Int32 Hash[T](T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Max$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Max[T](T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Min$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Min[T](T, T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Byte PowByte(Byte, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Double PowDouble(Double, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int16 PowInt16(Int16, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int32 PowInt32(Int32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int32 SignDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int64 PowInt64(Int64, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: IntPtr PowIntPtr(IntPtr, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: SByte PowSByte(SByte, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Single PowSingle(Single, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Byte] RangeByte(Byte, Byte, Byte)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Char] RangeChar(Char, Char)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Double] RangeDouble(Double, Double, Double)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Int16] RangeInt16(Int16, Int16, Int16)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Int32] RangeInt32(Int32, Int32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Int64] RangeInt64(Int64, Int64, Int64)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.IntPtr] RangeIntPtr(IntPtr, IntPtr, IntPtr)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.SByte] RangeSByte(SByte, SByte, SByte)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Single] RangeSingle(Single, Single, Single)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UInt16] RangeUInt16(UInt16, UInt16, UInt16)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UInt32] RangeUInt32(UInt32, UInt32, UInt32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UInt64] RangeUInt64(UInt64, UInt64, UInt64)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UIntPtr] RangeUIntPtr(UIntPtr, UIntPtr, UIntPtr)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[T] RangeGeneric[T](T, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[T] RangeStepGeneric[TStep,T](TStep, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TStep,T]], T, TStep, T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Decimal PowDecimal(System.Decimal, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.String GetStringSlice(System.String, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AbsDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AcosDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AsinDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AtanDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T CeilingDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T CosDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T CoshDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T ExpDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T FloorDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T Log10Dynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T LogDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T PowDynamic[T,TResult](T, TResult)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T PowGeneric[T](T, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T RoundDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T SinDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T SinhDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T TanDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T TanhDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T TruncateDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T2 Atan2Dynamic[T1,T2](T1, T1)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T2 SqrtDynamic[T1,T2](T1)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,,] GetArraySlice4D[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice3D[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle1[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle2[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle3[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice2D[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice3DFixedSingle1[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice3DFixedSingle2[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice3DFixedSingle3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble1[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble3[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble5[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble6[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice2DFixed1[T](T[,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice2DFixed2[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice3DFixedDouble1[T](T[,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice3DFixedDouble2[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice3DFixedDouble3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple1[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple3[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple4[T](T[,,,], Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice[T](T[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UInt16 PowUInt16(UInt16, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UInt32 PowUInt32(UInt32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UInt64 PowUInt64(UInt64, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UIntPtr PowUIntPtr(UIntPtr, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice2DFixed1[T](T[,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice2DFixed2[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice2D[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedDouble1[T](T[,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedDouble2[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedDouble3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedSingle1[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedSingle2[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedSingle3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3D[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble1[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble3[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble5[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble6[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle1[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle2[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle3[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple1[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Int32, T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple3[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple4[T](T[,,,], Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4D[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice[T](T[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[])
+Microsoft.FSharp.Core.Operators+Unchecked: Boolean Equals[T](T, T)
+Microsoft.FSharp.Core.Operators+Unchecked: Int32 Compare[T](T, T)
+Microsoft.FSharp.Core.Operators+Unchecked: Int32 Hash[T](T)
+Microsoft.FSharp.Core.Operators+Unchecked: T DefaultOf[T]()
+Microsoft.FSharp.Core.Operators+Unchecked: T Unbox[T](System.Object)
+Microsoft.FSharp.Core.Operators: Boolean IsNull[T](T)
+Microsoft.FSharp.Core.Operators: Boolean Not(Boolean)
+Microsoft.FSharp.Core.Operators: Boolean op_Equality[T](T, T)
+Microsoft.FSharp.Core.Operators: Boolean op_GreaterThanOrEqual[T](T, T)
+Microsoft.FSharp.Core.Operators: Boolean op_GreaterThan[T](T, T)
+Microsoft.FSharp.Core.Operators: Boolean op_Inequality[T](T, T)
+Microsoft.FSharp.Core.Operators: Boolean op_LessThanOrEqual[T](T, T)
+Microsoft.FSharp.Core.Operators: Boolean op_LessThan[T](T, T)
+Microsoft.FSharp.Core.Operators: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T)
+Microsoft.FSharp.Core.Operators: Byte ToByte[T](T)
+Microsoft.FSharp.Core.Operators: Char ToChar$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Char], T)
+Microsoft.FSharp.Core.Operators: Char ToChar[T](T)
+Microsoft.FSharp.Core.Operators: Double Infinity
+Microsoft.FSharp.Core.Operators: Double NaN
+Microsoft.FSharp.Core.Operators: Double ToDouble$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], T)
+Microsoft.FSharp.Core.Operators: Double ToDouble[T](T)
+Microsoft.FSharp.Core.Operators: Double get_Infinity()
+Microsoft.FSharp.Core.Operators: Double get_NaN()
+Microsoft.FSharp.Core.Operators: Int16 ToInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int16], T)
+Microsoft.FSharp.Core.Operators: Int16 ToInt16[T](T)
+Microsoft.FSharp.Core.Operators: Int32 Compare[T](T, T)
+Microsoft.FSharp.Core.Operators: Int32 Hash[T](T)
+Microsoft.FSharp.Core.Operators: Int32 Sign$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T)
+Microsoft.FSharp.Core.Operators: Int32 Sign[T](T)
+Microsoft.FSharp.Core.Operators: Int32 SizeOf[T]()
+Microsoft.FSharp.Core.Operators: Int32 ToInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T)
+Microsoft.FSharp.Core.Operators: Int32 ToInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T)
+Microsoft.FSharp.Core.Operators: Int32 ToInt32[T](T)
+Microsoft.FSharp.Core.Operators: Int32 ToInt[T](T)
+Microsoft.FSharp.Core.Operators: Int32 limitedHash[T](Int32, T)
+Microsoft.FSharp.Core.Operators: Int64 ToInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int64], T)
+Microsoft.FSharp.Core.Operators: Int64 ToInt64[T](T)
+Microsoft.FSharp.Core.Operators: IntPtr ToIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.IntPtr], T)
+Microsoft.FSharp.Core.Operators: IntPtr ToIntPtr[T](T)
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Collections.FSharpList`1[T] op_Append[T](Microsoft.FSharp.Collections.FSharpList`1[T], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpFunc`2[T1,T3] op_ComposeLeft[T2,T3,T1](Microsoft.FSharp.Core.FSharpFunc`2[T2,T3], Microsoft.FSharp.Core.FSharpFunc`2[T1,T2])
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpFunc`2[T1,T3] op_ComposeRight[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,T2], Microsoft.FSharp.Core.FSharpFunc`2[T2,T3])
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpOption`1[System.String] FailurePattern(System.Exception)
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpOption`1[T] TryUnbox[T](System.Object)
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpRef`1[T] Ref[T](T)
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+ArrayExtensions
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+Checked
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+NonStructuralComparison
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+OperatorIntrinsics
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+Unchecked
+Microsoft.FSharp.Core.Operators: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T)
+Microsoft.FSharp.Core.Operators: SByte ToSByte[T](T)
+Microsoft.FSharp.Core.Operators: Single InfinitySingle
+Microsoft.FSharp.Core.Operators: Single NaNSingle
+Microsoft.FSharp.Core.Operators: Single ToSingle$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], T)
+Microsoft.FSharp.Core.Operators: Single ToSingle[T](T)
+Microsoft.FSharp.Core.Operators: Single get_InfinitySingle()
+Microsoft.FSharp.Core.Operators: Single get_NaNSingle()
+Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] CreateSequence[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_Range$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T)
+Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_RangeStep$W[T,TStep](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TStep], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TStep,T]], T, TStep, T)
+Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_RangeStep[T,TStep](T, TStep, T)
+Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_Range[T](T, T)
+Microsoft.FSharp.Core.Operators: System.Decimal ToDecimal$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Decimal], T)
+Microsoft.FSharp.Core.Operators: System.Decimal ToDecimal[T](T)
+Microsoft.FSharp.Core.Operators: System.Exception Failure(System.String)
+Microsoft.FSharp.Core.Operators: System.IO.TextReader ConsoleIn[T]()
+Microsoft.FSharp.Core.Operators: System.IO.TextWriter ConsoleError[T]()
+Microsoft.FSharp.Core.Operators: System.IO.TextWriter ConsoleOut[T]()
+Microsoft.FSharp.Core.Operators: System.Object Box[T](T)
+Microsoft.FSharp.Core.Operators: System.String NameOf[T](T)
+Microsoft.FSharp.Core.Operators: System.String ToString[T](T)
+Microsoft.FSharp.Core.Operators: System.String op_Concatenate(System.String, System.String)
+Microsoft.FSharp.Core.Operators: System.Tuple`2[TKey,TValue] KeyValuePattern[TKey,TValue](System.Collections.Generic.KeyValuePair`2[TKey,TValue])
+Microsoft.FSharp.Core.Operators: System.Type TypeDefOf[T]()
+Microsoft.FSharp.Core.Operators: System.Type TypeOf[T]()
+Microsoft.FSharp.Core.Operators: T Abs$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Abs[T](T)
+Microsoft.FSharp.Core.Operators: T Acos$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Acos[T](T)
+Microsoft.FSharp.Core.Operators: T Asin$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Asin[T](T)
+Microsoft.FSharp.Core.Operators: T Atan$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Atan[T](T)
+Microsoft.FSharp.Core.Operators: T Ceiling$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Ceiling[T](T)
+Microsoft.FSharp.Core.Operators: T Cos$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Cos[T](T)
+Microsoft.FSharp.Core.Operators: T Cosh$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Cosh[T](T)
+Microsoft.FSharp.Core.Operators: T DefaultArg[T](Microsoft.FSharp.Core.FSharpOption`1[T], T)
+Microsoft.FSharp.Core.Operators: T DefaultValueArg[T](Microsoft.FSharp.Core.FSharpValueOption`1[T], T)
+Microsoft.FSharp.Core.Operators: T Exit[T](Int32)
+Microsoft.FSharp.Core.Operators: T Exp$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Exp[T](T)
+Microsoft.FSharp.Core.Operators: T FailWith[T](System.String)
+Microsoft.FSharp.Core.Operators: T Floor$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Floor[T](T)
+Microsoft.FSharp.Core.Operators: T Identity[T](T)
+Microsoft.FSharp.Core.Operators: T InvalidArg[T](System.String, System.String)
+Microsoft.FSharp.Core.Operators: T InvalidOp[T](System.String)
+Microsoft.FSharp.Core.Operators: T Lock[TLock,T](TLock, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T])
+Microsoft.FSharp.Core.Operators: T Log$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Log10$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Log10[T](T)
+Microsoft.FSharp.Core.Operators: T Log[T](T)
+Microsoft.FSharp.Core.Operators: T Max[T](T, T)
+Microsoft.FSharp.Core.Operators: T Min[T](T, T)
+Microsoft.FSharp.Core.Operators: T NullArg[T](System.String)
+Microsoft.FSharp.Core.Operators: T PowInteger$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, Int32)
+Microsoft.FSharp.Core.Operators: T PowInteger[T](T, Int32)
+Microsoft.FSharp.Core.Operators: T Raise[T](System.Exception)
+Microsoft.FSharp.Core.Operators: T Reraise[T]()
+Microsoft.FSharp.Core.Operators: T Rethrow[T]()
+Microsoft.FSharp.Core.Operators: T Round$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Round[T](T)
+Microsoft.FSharp.Core.Operators: T Sin$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Sin[T](T)
+Microsoft.FSharp.Core.Operators: T Sinh$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Sinh[T](T)
+Microsoft.FSharp.Core.Operators: T Tan$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Tan[T](T)
+Microsoft.FSharp.Core.Operators: T Tanh$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Tanh[T](T)
+Microsoft.FSharp.Core.Operators: T Truncate$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Truncate[T](T)
+Microsoft.FSharp.Core.Operators: T Unbox[T](System.Object)
+Microsoft.FSharp.Core.Operators: T op_BitwiseAnd$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T)
+Microsoft.FSharp.Core.Operators: T op_BitwiseAnd[T](T, T)
+Microsoft.FSharp.Core.Operators: T op_BitwiseOr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T)
+Microsoft.FSharp.Core.Operators: T op_BitwiseOr[T](T, T)
+Microsoft.FSharp.Core.Operators: T op_Dereference[T](Microsoft.FSharp.Core.FSharpRef`1[T])
+Microsoft.FSharp.Core.Operators: T op_ExclusiveOr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T)
+Microsoft.FSharp.Core.Operators: T op_ExclusiveOr[T](T, T)
+Microsoft.FSharp.Core.Operators: T op_Exponentiation$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,T]], T, TResult)
+Microsoft.FSharp.Core.Operators: T op_Exponentiation[T,TResult](T, TResult)
+Microsoft.FSharp.Core.Operators: T op_LeftShift$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], T, Int32)
+Microsoft.FSharp.Core.Operators: T op_LeftShift[T](T, Int32)
+Microsoft.FSharp.Core.Operators: T op_LogicalNot$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T op_LogicalNot[T](T)
+Microsoft.FSharp.Core.Operators: T op_RightShift$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], T, Int32)
+Microsoft.FSharp.Core.Operators: T op_RightShift[T](T, Int32)
+Microsoft.FSharp.Core.Operators: T op_UnaryNegation$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T op_UnaryNegation[T](T)
+Microsoft.FSharp.Core.Operators: T op_UnaryPlus$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T op_UnaryPlus[T](T)
+Microsoft.FSharp.Core.Operators: T1 Fst[T1,T2](System.Tuple`2[T1,T2])
+Microsoft.FSharp.Core.Operators: T2 Atan2$W[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T1,T2]], T1, T1)
+Microsoft.FSharp.Core.Operators: T2 Atan2[T1,T2](T1, T1)
+Microsoft.FSharp.Core.Operators: T2 Snd[T1,T2](System.Tuple`2[T1,T2])
+Microsoft.FSharp.Core.Operators: T3 op_Addition$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Addition[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Division$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Division[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Modulus$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Modulus[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Multiply$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Multiply[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Subtraction$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Subtraction[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators: TResult Sqrt$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T)
+Microsoft.FSharp.Core.Operators: TResult Sqrt[T,TResult](T)
+Microsoft.FSharp.Core.Operators: TResult ToEnum[TResult](Int32)
+Microsoft.FSharp.Core.Operators: TResult Using[T,TResult](T, Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
+Microsoft.FSharp.Core.Operators: TResult op_PipeLeft2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], T1, T2)
+Microsoft.FSharp.Core.Operators: TResult op_PipeLeft3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], T1, T2, T3)
+Microsoft.FSharp.Core.Operators: TResult op_PipeLeft[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T)
+Microsoft.FSharp.Core.Operators: TResult op_PipeRight2[T1,T2,TResult](T1, T2, Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]])
+Microsoft.FSharp.Core.Operators: TResult op_PipeRight3[T1,T2,T3,TResult](T1, T2, T3, Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]])
+Microsoft.FSharp.Core.Operators: TResult op_PipeRight[T1,TResult](T1, Microsoft.FSharp.Core.FSharpFunc`2[T1,TResult])
+Microsoft.FSharp.Core.Operators: UInt16 ToUInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt16], T)
+Microsoft.FSharp.Core.Operators: UInt16 ToUInt16[T](T)
+Microsoft.FSharp.Core.Operators: UInt32 ToUInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], T)
+Microsoft.FSharp.Core.Operators: UInt32 ToUInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], T)
+Microsoft.FSharp.Core.Operators: UInt32 ToUInt32[T](T)
+Microsoft.FSharp.Core.Operators: UInt32 ToUInt[T](T)
+Microsoft.FSharp.Core.Operators: UInt64 ToUInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt64], T)
+Microsoft.FSharp.Core.Operators: UInt64 ToUInt64[T](T)
+Microsoft.FSharp.Core.Operators: UIntPtr ToUIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UIntPtr], T)
+Microsoft.FSharp.Core.Operators: UIntPtr ToUIntPtr[T](T)
+Microsoft.FSharp.Core.Operators: Void Decrement(Microsoft.FSharp.Core.FSharpRef`1[System.Int32])
+Microsoft.FSharp.Core.Operators: Void Ignore[T](T)
+Microsoft.FSharp.Core.Operators: Void Increment(Microsoft.FSharp.Core.FSharpRef`1[System.Int32])
+Microsoft.FSharp.Core.Operators: Void op_ColonEquals[T](Microsoft.FSharp.Core.FSharpRef`1[T], T)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: FSharpFunc`3 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]])
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult] Invoke(T1)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: TResult Invoke(T1, T2)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: Void .ctor()
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: FSharpFunc`4 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]])
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]] Invoke(T1)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: TResult Invoke(T1, T2, T3)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: Void .ctor()
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: FSharpFunc`5 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]]])
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]] Invoke(T1)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: TResult Invoke(T1, T2, T3, T4)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: Void .ctor()
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: FSharpFunc`6 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]]])
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]] Invoke(T1)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: TResult Invoke(T1, T2, T3, T4, T5)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: Void .ctor()
+Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]
+Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]
+Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]
+Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]
+Microsoft.FSharp.Core.OptionModule: Boolean Contains[T](T, Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Boolean IsNone[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Boolean IsSome[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Int32 Count[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], Microsoft.FSharp.Core.FSharpOption`1[T1], Microsoft.FSharp.Core.FSharpOption`1[T2])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], Microsoft.FSharp.Core.FSharpOption`1[T1], Microsoft.FSharp.Core.FSharpOption`1[T2], Microsoft.FSharp.Core.FSharpOption`1[T3])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] Flatten[T](Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpOption`1[T]])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OfNullable[T](System.Nullable`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OfObj[T](T)
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OrElseWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.FSharpOption`1[T]], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OrElse[T](Microsoft.FSharp.Core.FSharpOption`1[T], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: System.Nullable`1[T] ToNullable[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: T DefaultValue[T](T, Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: T DefaultWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: T GetValue[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: T ToObj[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Core.FSharpOption`1[T], TState)
+Microsoft.FSharp.Core.OptionModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: T[] ToArray[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionalArgumentAttribute: Void .ctor()
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Object[] Captures
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Object[] get_Captures()
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.String ToString()
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.String Value
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.String get_Value()
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Type[] CaptureTypes
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Type[] get_CaptureTypes()
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: Void .ctor(System.String)
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: Void .ctor(System.String, System.Object[], System.Type[])
+Microsoft.FSharp.Core.PrintfFormat`5[TPrinter,TState,TResidue,TResult,TTuple]: Void .ctor(System.String)
+Microsoft.FSharp.Core.PrintfFormat`5[TPrinter,TState,TResidue,TResult,TTuple]: Void .ctor(System.String, System.Object[], System.Type[])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatLineToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatLineToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatLine[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[System.String,TResult], Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringBuilderThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], System.Text.StringBuilder, Microsoft.FSharp.Core.PrintfFormat`4[T,System.Text.StringBuilder,Microsoft.FSharp.Core.Unit,TResult])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringBuilder[T](System.Text.StringBuilder, Microsoft.FSharp.Core.PrintfFormat`4[T,System.Text.StringBuilder,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringThenFail[T,TResult](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[System.String,TResult], Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringThen[T](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,System.String])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToTextWriterThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,TResult])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormat[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ProjectionParameterAttribute: Void .ctor()
+Microsoft.FSharp.Core.ReferenceEqualityAttribute: Void .ctor()
+Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Boolean IncludeValue
+Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Boolean get_IncludeValue()
+Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Void .ctor()
+Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Void .ctor(Boolean)
+Microsoft.FSharp.Core.RequireQualifiedAccessAttribute: Void .ctor()
+Microsoft.FSharp.Core.RequiresExplicitTypeArgumentsAttribute: Void .ctor()
+Microsoft.FSharp.Core.ResultModule: Boolean Contains[T,TError](T, Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Boolean Exists[T,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Boolean ForAll[T,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Boolean IsError[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Boolean IsOk[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Int32 Count[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpOption`1[T] ToOption[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpResult`2[T,TResult] MapError[TError,TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[TError,TResult], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpResult`2[TResult,TError] Bind[T,TResult,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpResult`2[TResult,TError]], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpResult`2[TResult,TError] Map[T,TResult,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpValueOption`1[T] ToValueOption[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: T DefaultValue[T,TError](T, Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: T DefaultWith[TError,T](Microsoft.FSharp.Core.FSharpFunc`2[TError,T], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: TState FoldBack[T,TError,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Core.FSharpResult`2[T,TError], TState)
+Microsoft.FSharp.Core.ResultModule: TState Fold[T,TError,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: T[] ToArray[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Void Iterate[T,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.SealedAttribute: Boolean Value
+Microsoft.FSharp.Core.SealedAttribute: Boolean get_Value()
+Microsoft.FSharp.Core.SealedAttribute: Void .ctor()
+Microsoft.FSharp.Core.SealedAttribute: Void .ctor(Boolean)
+Microsoft.FSharp.Core.SourceConstructFlags: Int32 value__
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Closure
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Exception
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Field
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags KindMask
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Module
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags NonPublicRepresentation
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags None
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags ObjectType
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags RecordType
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags SumType
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags UnionCase
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Value
+Microsoft.FSharp.Core.StringModule: Boolean Exists(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Boolean], System.String)
+Microsoft.FSharp.Core.StringModule: Boolean ForAll(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Boolean], System.String)
+Microsoft.FSharp.Core.StringModule: Int32 Length(System.String)
+Microsoft.FSharp.Core.StringModule: System.String Collect(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.String], System.String)
+Microsoft.FSharp.Core.StringModule: System.String Concat(System.String, System.Collections.Generic.IEnumerable`1[System.String])
+Microsoft.FSharp.Core.StringModule: System.String Filter(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Boolean], System.String)
+Microsoft.FSharp.Core.StringModule: System.String Initialize(Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.String])
+Microsoft.FSharp.Core.StringModule: System.String Map(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Char], System.String)
+Microsoft.FSharp.Core.StringModule: System.String MapIndexed(Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Char]], System.String)
+Microsoft.FSharp.Core.StringModule: System.String Replicate(Int32, System.String)
+Microsoft.FSharp.Core.StringModule: Void Iterate(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,Microsoft.FSharp.Core.Unit], System.String)
+Microsoft.FSharp.Core.StringModule: Void IterateIndexed(Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Char,Microsoft.FSharp.Core.Unit]], System.String)
+Microsoft.FSharp.Core.StructAttribute: Void .ctor()
+Microsoft.FSharp.Core.StructuralComparisonAttribute: Void .ctor()
+Microsoft.FSharp.Core.StructuralEqualityAttribute: Void .ctor()
+Microsoft.FSharp.Core.StructuredFormatDisplayAttribute: System.String Value
+Microsoft.FSharp.Core.StructuredFormatDisplayAttribute: System.String get_Value()
+Microsoft.FSharp.Core.StructuredFormatDisplayAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.Unit: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.Unit: Int32 GetHashCode()
+Microsoft.FSharp.Core.UnverifiableAttribute: Void .ctor()
+Microsoft.FSharp.Core.ValueOption: Boolean Contains[T](T, Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Boolean IsNone[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Boolean IsSome[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Int32 Count[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpValueOption`1[TResult]], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], Microsoft.FSharp.Core.FSharpValueOption`1[T1], Microsoft.FSharp.Core.FSharpValueOption`1[T2])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], Microsoft.FSharp.Core.FSharpValueOption`1[T1], Microsoft.FSharp.Core.FSharpValueOption`1[T2], Microsoft.FSharp.Core.FSharpValueOption`1[T3])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] Flatten[T](Microsoft.FSharp.Core.FSharpValueOption`1[Microsoft.FSharp.Core.FSharpValueOption`1[T]])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OfNullable[T](System.Nullable`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OfObj[T](T)
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OrElseWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.FSharpValueOption`1[T]], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OrElse[T](Microsoft.FSharp.Core.FSharpValueOption`1[T], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: System.Nullable`1[T] ToNullable[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: T DefaultValue[T](T, Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: T DefaultWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: T GetValue[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: T ToObj[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Core.FSharpValueOption`1[T], TState)
+Microsoft.FSharp.Core.ValueOption: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: T[] ToArray[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.VolatileFieldAttribute: Void .ctor()
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToByte[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToUInt8$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToUInt8[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Char] ToChar$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Char], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Char] ToChar[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Decimal] ToDecimal$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Decimal], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Decimal] ToDecimal[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToDouble$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToDouble[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToFloat$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToFloat[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int16] ToInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int16], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int16] ToInt16[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt32[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int64] ToInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int64], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int64] ToInt64[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.IntPtr] ToIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.IntPtr], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.IntPtr] ToIntPtr[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToInt8$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToInt8[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToSByte[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToFloat32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToFloat32[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToSingle$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToSingle[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt16] ToUInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt16], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt16] ToUInt16[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt32[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt64] ToUInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt64], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt64] ToUInt64[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UIntPtr] ToUIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UIntPtr], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UIntPtr] ToUIntPtr[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[TResult] ToEnum[TResult](System.Nullable`1[System.Int32])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_EqualsQmark[T](T, System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_GreaterEqualsQmark[T](T, System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_GreaterQmark[T](T, System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_LessEqualsQmark[T](T, System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_LessGreaterQmark[T](T, System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_LessQmark[T](T, System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkEqualsQmark[T](System.Nullable`1[T], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkEquals[T](System.Nullable`1[T], T)
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreaterEqualsQmark[T](System.Nullable`1[T], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreaterEquals[T](System.Nullable`1[T], T)
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreaterQmark[T](System.Nullable`1[T], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreater[T](System.Nullable`1[T], T)
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessEqualsQmark[T](System.Nullable`1[T], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessEquals[T](System.Nullable`1[T], T)
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessGreaterQmark[T](System.Nullable`1[T], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessGreater[T](System.Nullable`1[T], T)
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessQmark[T](System.Nullable`1[T], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLess[T](System.Nullable`1[T], T)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_DivideQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_DivideQmark[T1,T2,T3](T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MinusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MinusQmark[T1,T2,T3](T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MultiplyQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MultiplyQmark[T1,T2,T3](T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PercentQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PercentQmark[T1,T2,T3](T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PlusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PlusQmark[T1,T2,T3](T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivide$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivideQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivideQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivide[T1,T2,T3](System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinus$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinusQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinus[T1,T2,T3](System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiply$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiplyQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiplyQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiply[T1,T2,T3](System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercent$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercentQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercentQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercent[T1,T2,T3](System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlus$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlusQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlus[T1,T2,T3](System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.QueryBuilder: Boolean All[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
+Microsoft.FSharp.Linq.QueryBuilder: Boolean Contains[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], T)
+Microsoft.FSharp.Linq.QueryBuilder: Boolean Exists[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
+Microsoft.FSharp.Linq.QueryBuilder: Int32 Count[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[System.Linq.IGrouping`2[TKey,TValue],Q] GroupValBy[T,TKey,TValue,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[System.Linq.IGrouping`2[TKey,T],Q] GroupBy[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Distinct[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SkipWhile[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Skip[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Int32)
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortByDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortByNullableDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortByNullable[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortBy[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Source[T,Q](System.Linq.IQueryable`1[T])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] TakeWhile[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Take[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Int32)
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenByDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenByNullableDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenByNullable[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenBy[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Where[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] YieldFrom[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Yield[T,Q](T)
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Zero[T,Q]()
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,System.Collections.IEnumerable] Source[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] For[T,Q,TResult,Q2](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Linq.QuerySource`2[TResult,Q2]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] GroupJoin[TOuter,Q,TInner,TKey,TResult](Microsoft.FSharp.Linq.QuerySource`2[TOuter,Q], Microsoft.FSharp.Linq.QuerySource`2[TInner,Q], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TInner,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,Microsoft.FSharp.Core.FSharpFunc`2[System.Collections.Generic.IEnumerable`1[TInner],TResult]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] Join[TOuter,Q,TInner,TKey,TResult](Microsoft.FSharp.Linq.QuerySource`2[TOuter,Q], Microsoft.FSharp.Linq.QuerySource`2[TInner,Q], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TInner,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,Microsoft.FSharp.Core.FSharpFunc`2[TInner,TResult]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] LeftOuterJoin[TOuter,Q,TInner,TKey,TResult](Microsoft.FSharp.Linq.QuerySource`2[TOuter,Q], Microsoft.FSharp.Linq.QuerySource`2[TInner,Q], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TInner,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,Microsoft.FSharp.Core.FSharpFunc`2[System.Collections.Generic.IEnumerable`1[TInner],TResult]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] Select[T,Q,TResult](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Quotations.FSharpExpr`1[T] Quote[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T])
+Microsoft.FSharp.Linq.QueryBuilder: System.Linq.IQueryable`1[T] Run[T](Microsoft.FSharp.Quotations.FSharpExpr`1[Microsoft.FSharp.Linq.QuerySource`2[T,System.Linq.IQueryable]])
+Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] AverageByNullable$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TValue]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
+Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] AverageByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
+Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] MaxByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
+Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] MinByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
+Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] SumByNullable$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
+Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] SumByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
+Microsoft.FSharp.Linq.QueryBuilder: T ExactlyOneOrDefault[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: T ExactlyOne[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: T Find[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
+Microsoft.FSharp.Linq.QueryBuilder: T HeadOrDefault[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: T Head[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: T LastOrDefault[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: T Last[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: T Nth[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Int32)
+Microsoft.FSharp.Linq.QueryBuilder: TValue AverageBy$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TValue]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
+Microsoft.FSharp.Linq.QueryBuilder: TValue AverageBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
+Microsoft.FSharp.Linq.QueryBuilder: TValue MaxBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
+Microsoft.FSharp.Linq.QueryBuilder: TValue MinBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
+Microsoft.FSharp.Linq.QueryBuilder: TValue SumBy$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
+Microsoft.FSharp.Linq.QueryBuilder: TValue SumBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
+Microsoft.FSharp.Linq.QueryBuilder: Void .ctor()
+Microsoft.FSharp.Linq.QueryRunExtensions.HighPriority: System.Collections.Generic.IEnumerable`1[T] RunQueryAsEnumerable[T](Microsoft.FSharp.Linq.QueryBuilder, Microsoft.FSharp.Quotations.FSharpExpr`1[Microsoft.FSharp.Linq.QuerySource`2[T,System.Collections.IEnumerable]])
+Microsoft.FSharp.Linq.QueryRunExtensions.LowPriority: T RunQueryAsValue[T](Microsoft.FSharp.Linq.QueryBuilder, Microsoft.FSharp.Quotations.FSharpExpr`1[T])
+Microsoft.FSharp.Linq.QuerySource`2[T,Q]: System.Collections.Generic.IEnumerable`1[T] Source
+Microsoft.FSharp.Linq.QuerySource`2[T,Q]: System.Collections.Generic.IEnumerable`1[T] get_Source()
+Microsoft.FSharp.Linq.QuerySource`2[T,Q]: Void .ctor(System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`1[T1]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`1[T1]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`1[T1]: Void .ctor(T1)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: Void .ctor(T1, T2)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T3 Item3
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T3 get_Item3()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: Void .ctor(T1, T2, T3)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T3 Item3
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T3 get_Item3()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T4 Item4
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T4 get_Item4()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: Void .ctor(T1, T2, T3, T4)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T3 Item3
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T3 get_Item3()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T4 Item4
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T4 get_Item4()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T5 Item5
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T5 get_Item5()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: Void .ctor(T1, T2, T3, T4, T5)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T3 Item3
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T3 get_Item3()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T4 Item4
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T4 get_Item4()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T5 Item5
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T5 get_Item5()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T6 Item6
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T6 get_Item6()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: Void .ctor(T1, T2, T3, T4, T5, T6)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T3 Item3
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T3 get_Item3()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T4 Item4
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T4 get_Item4()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T5 Item5
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T5 get_Item5()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T6 Item6
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T6 get_Item6()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T7 Item7
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T7 get_Item7()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: Void .ctor(T1, T2, T3, T4, T5, T6, T7)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T3 Item3
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T3 get_Item3()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T4 Item4
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T4 get_Item4()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T5 Item5
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T5 get_Item5()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T6 Item6
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T6 get_Item6()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T7 Item7
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T7 get_Item7()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T8 Item8
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T8 get_Item8()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: Void .ctor(T1, T2, T3, T4, T5, T6, T7, T8)
+Microsoft.FSharp.Linq.RuntimeHelpers.Grouping`2[K,T]: Void .ctor(K, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: Microsoft.FSharp.Quotations.FSharpExpr SubstHelperRaw(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar[], System.Object[])
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: Microsoft.FSharp.Quotations.FSharpExpr`1[T] SubstHelper[T](Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar[], System.Object[])
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Linq.Expressions.Expression QuotationToExpression(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Linq.Expressions.Expression`1[T] ImplicitExpressionConversionHelper[T](T)
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Linq.Expressions.Expression`1[T] QuotationToLambdaExpression[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T])
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Object EvaluateQuotation(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: T MemberInitializationHelper[T](T)
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: T NewAnonymousObjectHelper[T](T)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Boolean IsNullPointer[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr AddPointerInlined[T](IntPtr, Int32)
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr NullPointer[T]()
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr OfILSigPtrInlined[T](T*)
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr OfNativeIntInlined[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr OfVoidPtrInlined[T](Void*)
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr StackAllocate[T](Int32)
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr ToNativeIntInlined[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: T GetPointerInlined[T](IntPtr, Int32)
+Microsoft.FSharp.NativeInterop.NativePtrModule: T ReadPointerInlined[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: T& ToByRefInlined[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: T* ToILSigPtrInlined[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void ClearPointerInlined[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void CopyBlockInlined[T](IntPtr, IntPtr, Int32)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void CopyPointerInlined[T](IntPtr, IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void InitializeBlockInlined[T](IntPtr, Byte, UInt32)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void SetPointerInlined[T](IntPtr, Int32, T)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void WritePointerInlined[T](IntPtr, T)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void* ToVoidPtrInlined[T](IntPtr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],Microsoft.FSharp.Collections.FSharpList`1[System.Type],Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]]] SpecificCallPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] UnitPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] MethodWithReflectedDefinitionPattern(System.Reflection.MethodBase)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] PropertyGetterWithReflectedDefinitionPattern(System.Reflection.PropertyInfo)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] PropertySetterWithReflectedDefinitionPattern(System.Reflection.PropertyInfo)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Boolean] BoolPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Byte] BytePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Char] CharPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Decimal] DecimalPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Double] DoublePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int16] Int16Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] Int32Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int64] Int64Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.SByte] SBytePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Single] SinglePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.String] StringPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpVar]],Microsoft.FSharp.Quotations.FSharpExpr]] LambdasPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]]] ApplicationsPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] AndAlsoPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] OrElsePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.UInt16] UInt16Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.UInt32] UInt32Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.UInt64] UInt64Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.ExprShapeModule: Microsoft.FSharp.Core.FSharpChoice`3[Microsoft.FSharp.Quotations.FSharpVar,System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr],System.Tuple`2[System.Object,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] ShapePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.ExprShapeModule: Microsoft.FSharp.Quotations.FSharpExpr RebuildShapeCombination(System.Object, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Boolean Equals(System.Object)
+Microsoft.FSharp.Quotations.FSharpExpr: Int32 GetHashCode()
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr] CustomAttributes
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr] get_CustomAttributes()
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] TryGetReflectedDefinition(System.Reflection.MethodBase)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr AddressOf(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr AddressSet(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Application(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Applications(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Call(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Call(System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr CallWithWitnesses(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.MethodInfo, System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr], Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr CallWithWitnesses(System.Reflection.MethodInfo, System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr], Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Coerce(Microsoft.FSharp.Quotations.FSharpExpr, System.Type)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr DefaultValue(System.Type)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Deserialize(System.Type, Microsoft.FSharp.Collections.FSharpList`1[System.Type], Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr], Byte[])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Deserialize40(System.Type, System.Type[], System.Type[], Microsoft.FSharp.Quotations.FSharpExpr[], Byte[])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldGet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.FieldInfo)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldGet(System.Reflection.FieldInfo)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldSet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.FieldInfo, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldSet(System.Reflection.FieldInfo, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr ForIntegerRangeLoop(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr IfThenElse(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Lambda(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Let(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr LetRecursive(Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]], Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewArray(System.Type, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewDelegate(System.Type, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpVar], Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewObject(System.Reflection.ConstructorInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewRecord(System.Type, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewStructTuple(System.Reflection.Assembly, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewTuple(Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewUnionCase(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertyGet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.PropertyInfo, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertyGet(System.Reflection.PropertyInfo, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertySet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.PropertyInfo, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertySet(System.Reflection.PropertyInfo, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Quote(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr QuoteRaw(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr QuoteTyped(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Sequential(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Substitute(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr]])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TryFinally(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TryWith(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TupleGet(Microsoft.FSharp.Quotations.FSharpExpr, Int32)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TypeTest(Microsoft.FSharp.Quotations.FSharpExpr, System.Type)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr UnionCaseTest(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Reflection.UnionCaseInfo)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Value(System.Object, System.Type)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr ValueWithName(System.Object, System.Type, System.String)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr ValueWithName[T](T, System.String)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Value[T](T)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Var(Microsoft.FSharp.Quotations.FSharpVar)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr VarSet(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr WhileLoop(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr WithValue(System.Object, System.Type, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr`1[T] Cast[T](Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr`1[T] GlobalVar[T](System.String)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr`1[T] WithValue[T](T, Microsoft.FSharp.Quotations.FSharpExpr`1[T])
+Microsoft.FSharp.Quotations.FSharpExpr: System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Quotations.FSharpVar] GetFreeVars()
+Microsoft.FSharp.Quotations.FSharpExpr: System.String ToString()
+Microsoft.FSharp.Quotations.FSharpExpr: System.String ToString(Boolean)
+Microsoft.FSharp.Quotations.FSharpExpr: System.Type Type
+Microsoft.FSharp.Quotations.FSharpExpr: System.Type get_Type()
+Microsoft.FSharp.Quotations.FSharpExpr: Void RegisterReflectedDefinitions(System.Reflection.Assembly, System.String, Byte[])
+Microsoft.FSharp.Quotations.FSharpExpr: Void RegisterReflectedDefinitions(System.Reflection.Assembly, System.String, Byte[], System.Type[])
+Microsoft.FSharp.Quotations.FSharpExpr`1[T]: Microsoft.FSharp.Quotations.FSharpExpr Raw
+Microsoft.FSharp.Quotations.FSharpExpr`1[T]: Microsoft.FSharp.Quotations.FSharpExpr get_Raw()
+Microsoft.FSharp.Quotations.FSharpVar: Boolean Equals(System.Object)
+Microsoft.FSharp.Quotations.FSharpVar: Boolean IsMutable
+Microsoft.FSharp.Quotations.FSharpVar: Boolean get_IsMutable()
+Microsoft.FSharp.Quotations.FSharpVar: Int32 GetHashCode()
+Microsoft.FSharp.Quotations.FSharpVar: Microsoft.FSharp.Quotations.FSharpVar Global(System.String, System.Type)
+Microsoft.FSharp.Quotations.FSharpVar: System.String Name
+Microsoft.FSharp.Quotations.FSharpVar: System.String ToString()
+Microsoft.FSharp.Quotations.FSharpVar: System.String get_Name()
+Microsoft.FSharp.Quotations.FSharpVar: System.Type Type
+Microsoft.FSharp.Quotations.FSharpVar: System.Type get_Type()
+Microsoft.FSharp.Quotations.FSharpVar: Void .ctor(System.String, System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]] NewStructTuplePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]] NewTuplePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] AddressOfPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] QuotePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] QuoteRawPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] QuoteTypedPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpVar] VarPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]],Microsoft.FSharp.Quotations.FSharpExpr]] LetRecursivePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.FieldInfo]] FieldGetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] AddressSetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] ApplicationPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] SequentialPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] TryFinallyPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] WhileLoopPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Reflection.UnionCaseInfo]] UnionCaseTestPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,System.Int32]] TupleGetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,System.Type]] CoercePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,System.Type]] TypeTestPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]] LambdaPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]] VarSetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Reflection.UnionCaseInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewUnionCasePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Object,System.Type]] ValuePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Reflection.ConstructorInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewObjectPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Type,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewArrayPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Type,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewRecordPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.FieldInfo,Microsoft.FSharp.Quotations.FSharpExpr]] FieldSetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.MethodInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] CallPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.PropertyInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] PropertyGetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] IfThenElsePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] LetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Object,System.Type,Microsoft.FSharp.Quotations.FSharpExpr]] WithValuePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Object,System.Type,System.String]] ValueWithNamePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Type,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpVar],Microsoft.FSharp.Quotations.FSharpExpr]] NewDelegatePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`4[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.PropertyInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr],Microsoft.FSharp.Quotations.FSharpExpr]] PropertySetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`4[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] ForIntegerRangeLoopPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`5[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.MethodInfo,System.Reflection.MethodInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr],Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] CallWithWitnessesPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`5[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]] TryWithPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Type] DefaultValuePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Boolean FSharpType.IsExceptionRepresentation.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Boolean FSharpType.IsRecord.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Boolean FSharpType.IsUnion.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Int32] FSharpValue.PreComputeUnionTagReader.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] FSharpValue.PreComputeRecordReader.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] FSharpValue.PreComputeUnionReader.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] FSharpValue.PreComputeRecordConstructor.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] FSharpValue.PreComputeUnionConstructor.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Reflection.UnionCaseInfo[] FSharpType.GetUnionCases.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object FSharpValue.MakeRecord.Static(System.Type, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object FSharpValue.MakeUnion.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object[] FSharpValue.GetExceptionFields.Static(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object[] FSharpValue.GetRecordFields.Static(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.ConstructorInfo FSharpValue.PreComputeRecordConstructorInfo.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.MemberInfo FSharpValue.PreComputeUnionTagMemberInfo.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.MethodInfo FSharpValue.PreComputeUnionConstructorInfo.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.PropertyInfo[] FSharpType.GetExceptionFields.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.PropertyInfo[] FSharpType.GetRecordFields.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Tuple`2[Microsoft.FSharp.Reflection.UnionCaseInfo,System.Object[]] FSharpValue.GetUnionFields.Static(System.Object, System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpType: Boolean IsExceptionRepresentation(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpType: Boolean IsFunction(System.Type)
+Microsoft.FSharp.Reflection.FSharpType: Boolean IsModule(System.Type)
+Microsoft.FSharp.Reflection.FSharpType: Boolean IsRecord(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpType: Boolean IsTuple(System.Type)
+Microsoft.FSharp.Reflection.FSharpType: Boolean IsUnion(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpType: Microsoft.FSharp.Reflection.UnionCaseInfo[] GetUnionCases(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpType: System.Reflection.PropertyInfo[] GetExceptionFields(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpType: System.Reflection.PropertyInfo[] GetRecordFields(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpType: System.Tuple`2[System.Type,System.Type] GetFunctionElements(System.Type)
+Microsoft.FSharp.Reflection.FSharpType: System.Type MakeFunctionType(System.Type, System.Type)
+Microsoft.FSharp.Reflection.FSharpType: System.Type MakeStructTupleType(System.Reflection.Assembly, System.Type[])
+Microsoft.FSharp.Reflection.FSharpType: System.Type MakeTupleType(System.Reflection.Assembly, System.Type[])
+Microsoft.FSharp.Reflection.FSharpType: System.Type MakeTupleType(System.Type[])
+Microsoft.FSharp.Reflection.FSharpType: System.Type[] GetTupleElements(System.Type)
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Int32] PreComputeUnionTagReader(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] PreComputeRecordReader(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] PreComputeTupleReader(System.Type)
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] PreComputeUnionReader(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object] PreComputeRecordFieldReader(System.Reflection.PropertyInfo)
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] PreComputeRecordConstructor(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] PreComputeTupleConstructor(System.Type)
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] PreComputeUnionConstructor(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Object GetRecordField(System.Object, System.Reflection.PropertyInfo)
+Microsoft.FSharp.Reflection.FSharpValue: System.Object GetTupleField(System.Object, Int32)
+Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeFunction(System.Type, Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object])
+Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeRecord(System.Type, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeTuple(System.Object[], System.Type)
+Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeUnion(Microsoft.FSharp.Reflection.UnionCaseInfo, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Object[] GetExceptionFields(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Object[] GetRecordFields(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Object[] GetTupleFields(System.Object)
+Microsoft.FSharp.Reflection.FSharpValue: System.Reflection.ConstructorInfo PreComputeRecordConstructorInfo(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Reflection.MemberInfo PreComputeUnionTagMemberInfo(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Reflection.MethodInfo PreComputeUnionConstructorInfo(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Tuple`2[Microsoft.FSharp.Reflection.UnionCaseInfo,System.Object[]] GetUnionFields(System.Object, System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Tuple`2[System.Reflection.ConstructorInfo,Microsoft.FSharp.Core.FSharpOption`1[System.Type]] PreComputeTupleConstructorInfo(System.Type)
+Microsoft.FSharp.Reflection.FSharpValue: System.Tuple`2[System.Reflection.PropertyInfo,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Type,System.Int32]]] PreComputeTuplePropertyInfo(System.Type, Int32)
+Microsoft.FSharp.Reflection.UnionCaseInfo: Boolean Equals(System.Object)
+Microsoft.FSharp.Reflection.UnionCaseInfo: Int32 GetHashCode()
+Microsoft.FSharp.Reflection.UnionCaseInfo: Int32 Tag
+Microsoft.FSharp.Reflection.UnionCaseInfo: Int32 get_Tag()
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Collections.Generic.IList`1[System.Reflection.CustomAttributeData] GetCustomAttributesData()
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Object[] GetCustomAttributes()
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Object[] GetCustomAttributes(System.Type)
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Reflection.PropertyInfo[] GetFields()
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.String Name
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.String ToString()
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.String get_Name()
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type DeclaringType
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type get_DeclaringType()
\ No newline at end of file
diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.debug.bsl b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.debug.bsl
new file mode 100644
index 00000000000..028a4fee29b
--- /dev/null
+++ b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.debug.bsl
@@ -0,0 +1,2509 @@
+! AssemblyReference: System.Runtime.Numerics
+! AssemblyReference: netstandard
+Microsoft.FSharp.Collections.Array2DModule: Int32 Base1[T](T[,])
+Microsoft.FSharp.Collections.Array2DModule: Int32 Base2[T](T[,])
+Microsoft.FSharp.Collections.Array2DModule: Int32 Length1[T](T[,])
+Microsoft.FSharp.Collections.Array2DModule: Int32 Length2[T](T[,])
+Microsoft.FSharp.Collections.Array2DModule: T Get[T](T[,], Int32, Int32)
+Microsoft.FSharp.Collections.Array2DModule: TResult[,] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]]], T[,])
+Microsoft.FSharp.Collections.Array2DModule: TResult[,] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[,])
+Microsoft.FSharp.Collections.Array2DModule: T[,] Copy[T](T[,])
+Microsoft.FSharp.Collections.Array2DModule: T[,] CreateBased[T](Int32, Int32, Int32, Int32, T)
+Microsoft.FSharp.Collections.Array2DModule: T[,] Create[T](Int32, Int32, T)
+Microsoft.FSharp.Collections.Array2DModule: T[,] InitializeBased[T](Int32, Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]])
+Microsoft.FSharp.Collections.Array2DModule: T[,] Initialize[T](Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]])
+Microsoft.FSharp.Collections.Array2DModule: T[,] Rebase[T](T[,])
+Microsoft.FSharp.Collections.Array2DModule: T[,] ZeroCreateBased[T](Int32, Int32, Int32, Int32)
+Microsoft.FSharp.Collections.Array2DModule: T[,] ZeroCreate[T](Int32, Int32)
+Microsoft.FSharp.Collections.Array2DModule: Void CopyTo[T](T[,], Int32, Int32, T[,], Int32, Int32, Int32, Int32)
+Microsoft.FSharp.Collections.Array2DModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]]], T[,])
+Microsoft.FSharp.Collections.Array2DModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[,])
+Microsoft.FSharp.Collections.Array2DModule: Void Set[T](T[,], Int32, Int32, T)
+Microsoft.FSharp.Collections.Array3DModule: Int32 Length1[T](T[,,])
+Microsoft.FSharp.Collections.Array3DModule: Int32 Length2[T](T[,,])
+Microsoft.FSharp.Collections.Array3DModule: Int32 Length3[T](T[,,])
+Microsoft.FSharp.Collections.Array3DModule: T Get[T](T[,,], Int32, Int32, Int32)
+Microsoft.FSharp.Collections.Array3DModule: TResult[,,] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]]]], T[,,])
+Microsoft.FSharp.Collections.Array3DModule: TResult[,,] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[,,])
+Microsoft.FSharp.Collections.Array3DModule: T[,,] Create[T](Int32, Int32, Int32, T)
+Microsoft.FSharp.Collections.Array3DModule: T[,,] Initialize[T](Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]]])
+Microsoft.FSharp.Collections.Array3DModule: T[,,] ZeroCreate[T](Int32, Int32, Int32)
+Microsoft.FSharp.Collections.Array3DModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]]]], T[,,])
+Microsoft.FSharp.Collections.Array3DModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[,,])
+Microsoft.FSharp.Collections.Array3DModule: Void Set[T](T[,,], Int32, Int32, Int32, T)
+Microsoft.FSharp.Collections.Array4DModule: Int32 Length1[T](T[,,,])
+Microsoft.FSharp.Collections.Array4DModule: Int32 Length2[T](T[,,,])
+Microsoft.FSharp.Collections.Array4DModule: Int32 Length3[T](T[,,,])
+Microsoft.FSharp.Collections.Array4DModule: Int32 Length4[T](T[,,,])
+Microsoft.FSharp.Collections.Array4DModule: T Get[T](T[,,,], Int32, Int32, Int32, Int32)
+Microsoft.FSharp.Collections.Array4DModule: T[,,,] Create[T](Int32, Int32, Int32, Int32, T)
+Microsoft.FSharp.Collections.Array4DModule: T[,,,] Initialize[T](Int32, Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]]]])
+Microsoft.FSharp.Collections.Array4DModule: T[,,,] ZeroCreate[T](Int32, Int32, Int32, Int32)
+Microsoft.FSharp.Collections.Array4DModule: Void Set[T](T[,,,], Int32, Int32, Int32, Int32, T)
+Microsoft.FSharp.Collections.ArrayModule+Parallel: System.Tuple`2[T[],T[]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] Collect[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult[]], T[])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], T[])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: T[] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], T[])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[])
+Microsoft.FSharp.Collections.ArrayModule: Boolean Contains[T](T, T[])
+Microsoft.FSharp.Collections.ArrayModule: Boolean Exists2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Boolean ForAll2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Boolean IsEmpty[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: Int32 CompareWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], T[], T[])
+Microsoft.FSharp.Collections.ArrayModule: Int32 FindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Int32 FindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Int32 Length[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Collections.ArrayModule+Parallel
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryExactlyOne[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryHead[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryItem[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryLast[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Collections.Generic.IEnumerable`1[T] ToSeq[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[System.Int32,T][] Indexed[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T,T][] Pairwise[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T1,T2][] AllPairs[T1,T2](T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T1,T2][] Zip[T1,T2](T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T1[],T2[]] Unzip[T1,T2](System.Tuple`2[T1,T2][])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TKey,System.Int32][] CountBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TKey,T[]][] GroupBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TResult[],TState] MapFoldBack[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,System.Tuple`2[TResult,TState]]], T[], TState)
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TResult[],TState] MapFold[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Tuple`2[TResult,TState]]], TState, T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T[],T[]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T[],T[]] SplitAt[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`3[T1,T2,T3][] Zip3[T1,T2,T3](T1[], T2[], T3[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`3[T1[],T2[],T3[]] Unzip3[T1,T2,T3](System.Tuple`3[T1,T2,T3][])
+Microsoft.FSharp.Collections.ArrayModule: T Average$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Average[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T ExactlyOne[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T FindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Find[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Get[T](T[], Int32)
+Microsoft.FSharp.Collections.ArrayModule: T Head[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T Item[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T Last[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T MaxBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Max[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T MinBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Min[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T ReduceBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Reduce[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Sum$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Sum[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult AverageBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult AverageBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult Pick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult SumBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult SumBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] Collect[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult[]], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], T1[], T2[], T3[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] MapIndexed2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]]], T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: TState Fold2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TState]]], TState, T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: TState FoldBack2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], T1[], T2[], TState)
+Microsoft.FSharp.Collections.ArrayModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], T[], TState)
+Microsoft.FSharp.Collections.ArrayModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, T[])
+Microsoft.FSharp.Collections.ArrayModule: TState[] ScanBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], T[], TState)
+Microsoft.FSharp.Collections.ArrayModule: TState[] Scan[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Append[T](T[], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Concat[T](System.Collections.Generic.IEnumerable`1[T[]])
+Microsoft.FSharp.Collections.ArrayModule: T[] Copy[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Create[T](Int32, T)
+Microsoft.FSharp.Collections.ArrayModule: T[] DistinctBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Distinct[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Empty[T]()
+Microsoft.FSharp.Collections.ArrayModule: T[] Except[T](System.Collections.Generic.IEnumerable`1[T], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] GetSubArray[T](T[], Int32, Int32)
+Microsoft.FSharp.Collections.ArrayModule: T[] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T])
+Microsoft.FSharp.Collections.ArrayModule: T[] InsertAt[T](Int32, T, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] InsertManyAt[T](Int32, System.Collections.Generic.IEnumerable`1[T], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] OfList[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ArrayModule: T[] OfSeq[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.ArrayModule: T[] Permute[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.Int32], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] RemoveAt[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] RemoveManyAt[T](Int32, Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Replicate[T](Int32, T)
+Microsoft.FSharp.Collections.ArrayModule: T[] Reverse[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Singleton[T](T)
+Microsoft.FSharp.Collections.ArrayModule: T[] SkipWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Skip[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] SortByDescending[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] SortBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] SortDescending[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] SortWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Sort[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Tail[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] TakeWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Take[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Truncate[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Unfold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[T,TState]]], TState)
+Microsoft.FSharp.Collections.ArrayModule: T[] UpdateAt[T](Int32, T, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Where[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] ZeroCreate[T](Int32)
+Microsoft.FSharp.Collections.ArrayModule: T[][] ChunkBySize[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[][] SplitInto[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[][] Transpose[T](System.Collections.Generic.IEnumerable`1[T[]])
+Microsoft.FSharp.Collections.ArrayModule: T[][] Windowed[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: Void CopyTo[T](T[], Int32, T[], Int32, Int32)
+Microsoft.FSharp.Collections.ArrayModule: Void Fill[T](T[], Int32, Int32, T)
+Microsoft.FSharp.Collections.ArrayModule: Void Iterate2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]], T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: Void IterateIndexed2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]]], T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], T[])
+Microsoft.FSharp.Collections.ArrayModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[])
+Microsoft.FSharp.Collections.ArrayModule: Void Set[T](T[], Int32, T)
+Microsoft.FSharp.Collections.ArrayModule: Void SortInPlaceBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
+Microsoft.FSharp.Collections.ArrayModule: Void SortInPlaceWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], T[])
+Microsoft.FSharp.Collections.ArrayModule: Void SortInPlace[T](T[])
+Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] FromFunction[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]])
+Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] NonStructural$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]])
+Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] NonStructural[T]()
+Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] Structural[T]()
+Microsoft.FSharp.Collections.FSharpList`1+Tags[T]: Int32 Cons
+Microsoft.FSharp.Collections.FSharpList`1+Tags[T]: Int32 Empty
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean Equals(Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean Equals(System.Object)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean IsCons
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean IsEmpty
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean get_IsCons()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean get_IsEmpty()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 CompareTo(Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 GetHashCode()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 GetReverseIndex(Int32, Int32)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 Length
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 Tag
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 get_Length()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 get_Tag()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1+Tags[T]
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Cons(T, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Empty
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] GetSlice(Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Tail
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] TailOrNull
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] get_Empty()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] get_Tail()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] get_TailOrNull()
+Microsoft.FSharp.Collections.FSharpList`1[T]: System.String ToString()
+Microsoft.FSharp.Collections.FSharpList`1[T]: T Head
+Microsoft.FSharp.Collections.FSharpList`1[T]: T HeadOrDefault
+Microsoft.FSharp.Collections.FSharpList`1[T]: T Item [Int32]
+Microsoft.FSharp.Collections.FSharpList`1[T]: T get_Head()
+Microsoft.FSharp.Collections.FSharpList`1[T]: T get_HeadOrDefault()
+Microsoft.FSharp.Collections.FSharpList`1[T]: T get_Item(Int32)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Void .ctor(T, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean ContainsKey(TKey)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean Equals(System.Object)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean IsEmpty
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean TryGetValue(TKey, TValue ByRef)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean get_IsEmpty()
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Int32 Count
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Int32 GetHashCode()
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Int32 get_Count()
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Add(TKey, TValue)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Change(TKey, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpOption`1[TValue],Microsoft.FSharp.Core.FSharpOption`1[TValue]])
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Remove(TKey)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Core.FSharpOption`1[TValue] TryFind(TKey)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TKey] Keys
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TKey] get_Keys()
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TValue] Values
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TValue] get_Values()
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.String ToString()
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: TValue Item [TKey]
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: TValue get_Item(TKey)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Void .ctor(System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,TValue]])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean Contains(T)
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean Equals(System.Object)
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsEmpty
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsProperSubsetOf(Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsProperSupersetOf(Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsSubsetOf(Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsSupersetOf(Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean get_IsEmpty()
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Int32 Count
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Int32 GetHashCode()
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Int32 get_Count()
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] Add(T)
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] Remove(T)
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] op_Addition(Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] op_Subtraction(Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: System.String ToString()
+Microsoft.FSharp.Collections.FSharpSet`1[T]: T MaximumElement
+Microsoft.FSharp.Collections.FSharpSet`1[T]: T MinimumElement
+Microsoft.FSharp.Collections.FSharpSet`1[T]: T get_MaximumElement()
+Microsoft.FSharp.Collections.FSharpSet`1[T]: T get_MinimumElement()
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Void .ctor(System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] FromFunctions[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]])
+Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] LimitedStructural[T](Int32)
+Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] NonStructural$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]])
+Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] NonStructural[T]()
+Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] Reference[T]()
+Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] Structural[T]()
+Microsoft.FSharp.Collections.ListModule: Boolean Contains[T](T, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Boolean Exists2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Boolean ForAll2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Boolean IsEmpty[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Int32 CompareWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], Microsoft.FSharp.Collections.FSharpList`1[T], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Int32 FindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Int32 FindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Int32 Length[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] ChunkBySize[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] SplitInto[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] Transpose[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpList`1[T]])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] Windowed[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[System.Int32,T]] Indexed[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T,T]] Pairwise[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T1,T2]] AllPairs[T1,T2](Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T1,T2]] Zip[T1,T2](Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,Microsoft.FSharp.Collections.FSharpList`1[T]]] GroupBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,System.Int32]] CountBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[T1,T2,T3]] Zip3[T1,T2,T3](Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2], Microsoft.FSharp.Collections.FSharpList`1[T3])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Collect[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Collections.FSharpList`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2], Microsoft.FSharp.Collections.FSharpList`1[T3])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] MapIndexed2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TState] ScanBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Collections.FSharpList`1[T], TState)
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TState] Scan[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Append[T](Microsoft.FSharp.Collections.FSharpList`1[T], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Concat[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpList`1[T]])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] DistinctBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Distinct[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Empty[T]()
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Except[T](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] InsertAt[T](Int32, T, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] InsertManyAt[T](Int32, System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] OfArray[T](T[])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] OfSeq[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Permute[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.Int32], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RemoveAt[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RemoveManyAt[T](Int32, Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Replicate[T](Int32, T)
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Reverse[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Singleton[T](T)
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SkipWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Skip[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortByDescending[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortDescending[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Sort[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Tail[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] TakeWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Take[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Truncate[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Unfold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[T,TState]]], TState)
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] UpdateAt[T](Int32, T, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Where[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryExactlyOne[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryHead[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryItem[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryLast[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: System.Collections.Generic.IEnumerable`1[T] ToSeq[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[T1],Microsoft.FSharp.Collections.FSharpList`1[T2]] Unzip[T1,T2](Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T1,T2]])
+Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[TResult],TState] MapFoldBack[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,System.Tuple`2[TResult,TState]]], Microsoft.FSharp.Collections.FSharpList`1[T], TState)
+Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[TResult],TState] MapFold[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Tuple`2[TResult,TState]]], TState, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[T],Microsoft.FSharp.Collections.FSharpList`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[T],Microsoft.FSharp.Collections.FSharpList`1[T]] SplitAt[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: System.Tuple`3[Microsoft.FSharp.Collections.FSharpList`1[T1],Microsoft.FSharp.Collections.FSharpList`1[T2],Microsoft.FSharp.Collections.FSharpList`1[T3]] Unzip3[T1,T2,T3](Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[T1,T2,T3]])
+Microsoft.FSharp.Collections.ListModule: T Average$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Average[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T ExactlyOne[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T FindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Find[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Get[T](Microsoft.FSharp.Collections.FSharpList`1[T], Int32)
+Microsoft.FSharp.Collections.ListModule: T Head[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Item[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Last[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T MaxBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Max[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T MinBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Min[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T ReduceBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Reduce[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Sum$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Sum[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: TResult AverageBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: TResult AverageBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: TResult Pick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: TResult SumBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: TResult SumBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: TState Fold2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TState]]], TState, Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: TState FoldBack2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2], TState)
+Microsoft.FSharp.Collections.ListModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Collections.FSharpList`1[T], TState)
+Microsoft.FSharp.Collections.ListModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T[] ToArray[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Void Iterate2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Void IterateIndexed2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.MapModule: Boolean ContainsKey[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Boolean Exists[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Boolean ForAll[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Boolean IsEmpty[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Int32 Count[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,T]] ToList[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TResult] Map[TKey,T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Add[TKey,T](TKey, T, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Change[TKey,T](TKey, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpOption`1[T],Microsoft.FSharp.Core.FSharpOption`1[T]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Empty[TKey,T]()
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Filter[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] OfArray[TKey,T](System.Tuple`2[TKey,T][])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] OfList[TKey,T](Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,T]])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] OfSeq[TKey,T](System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,T]])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Remove[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Core.FSharpOption`1[TKey] TryFindKey[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[TKey,T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Collections.Generic.ICollection`1[TKey] Keys[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Collections.Generic.ICollection`1[T] Values[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,T]] ToSeq[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpMap`2[TKey,T],Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]] Partition[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Tuple`2[TKey,T] MaxKeyValue[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Tuple`2[TKey,T] MinKeyValue[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Tuple`2[TKey,T][] ToArray[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: T Find[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: TKey FindKey[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: TResult Pick[TKey,T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: TState FoldBack[TKey,T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T], TState)
+Microsoft.FSharp.Collections.MapModule: TState Fold[TKey,T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]]], TState, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Void Iterate[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.SeqModule: Boolean Contains[T](T, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Boolean Exists2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Boolean ForAll2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Boolean IsEmpty[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Int32 CompareWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Int32 FindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Int32 FindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Int32 Length[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryExactlyOne[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryHead[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryItem[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryLast[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Collections.Generic.IEnumerable`1[T]] Transpose[TCollection,T](System.Collections.Generic.IEnumerable`1[TCollection])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[System.Int32,T]] Indexed[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[T,T]] Pairwise[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[T1,T2]] AllPairs[T1,T2](System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[T1,T2]] Zip[T1,T2](System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,System.Collections.Generic.IEnumerable`1[T]]] GroupBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,System.Int32]] CountBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`3[T1,T2,T3]] Zip3[T1,T2,T3](System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2], System.Collections.Generic.IEnumerable`1[T3])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Collect[T,TCollection,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TCollection], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2], System.Collections.Generic.IEnumerable`1[T3])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] MapIndexed2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TState] ScanBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], System.Collections.Generic.IEnumerable`1[T], TState)
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TState] Scan[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T[]] ChunkBySize[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T[]] SplitInto[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T[]] Windowed[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Append[T](System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Cache[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Cast[T](System.Collections.IEnumerable)
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Concat[TCollection,T](System.Collections.Generic.IEnumerable`1[TCollection])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Delay[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Collections.Generic.IEnumerable`1[T]])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] DistinctBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Distinct[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Empty[T]()
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Except[T](System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] InitializeInfinite[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] InsertAt[T](Int32, T, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] InsertManyAt[T](Int32, System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] OfArray[T](T[])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] OfList[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Permute[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.Int32], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] ReadOnly[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RemoveAt[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RemoveManyAt[T](Int32, Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Replicate[T](Int32, T)
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Reverse[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Singleton[T](T)
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SkipWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Skip[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortByDescending[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortDescending[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Sort[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Tail[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] TakeWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Take[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Truncate[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Unfold[TState,T](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[T,TState]]], TState)
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] UpdateAt[T](Int32, T, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Where[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Tuple`2[System.Collections.Generic.IEnumerable`1[TResult],TState] MapFoldBack[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,System.Tuple`2[TResult,TState]]], System.Collections.Generic.IEnumerable`1[T], TState)
+Microsoft.FSharp.Collections.SeqModule: System.Tuple`2[System.Collections.Generic.IEnumerable`1[TResult],TState] MapFold[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Tuple`2[TResult,TState]]], TState, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Average$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Average[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T ExactlyOne[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T FindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Find[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Get[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Head[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Item[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Last[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T MaxBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Max[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T MinBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Min[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T ReduceBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Reduce[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Sum$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Sum[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: TResult AverageBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: TResult AverageBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: TResult Pick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: TResult SumBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: TResult SumBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: TState Fold2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TState]]], TState, System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: TState FoldBack2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2], TState)
+Microsoft.FSharp.Collections.SeqModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], System.Collections.Generic.IEnumerable`1[T], TState)
+Microsoft.FSharp.Collections.SeqModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T[] ToArray[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Void Iterate2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: Void IterateIndexed2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean Contains[T](T, Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean IsEmpty[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean IsProperSubset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean IsProperSuperset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean IsSubset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean IsSuperset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Int32 Count[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Add[T](T, Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Difference[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Empty[T]()
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] IntersectMany[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpSet`1[T]])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Intersect[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] OfArray[T](T[])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] OfList[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] OfSeq[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Remove[T](T, Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Singleton[T](T)
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] UnionMany[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpSet`1[T]])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Union[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: System.Collections.Generic.IEnumerable`1[T] ToSeq[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpSet`1[T],Microsoft.FSharp.Collections.FSharpSet`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: T MaxElement[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: T MinElement[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Collections.FSharpSet`1[T], TState)
+Microsoft.FSharp.Collections.SetModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: T[] ToArray[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Boolean IsCancellationRequested
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Boolean get_IsCancellationRequested()
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn OnCancellation()
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn OnSuccess(T)
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn Success(Microsoft.FSharp.Control.AsyncActivation`1[T], T)
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Void OnExceptionRaised()
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn Bind[T,TResult](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn CallThenInvoke[T,TResult](Microsoft.FSharp.Control.AsyncActivation`1[T], TResult, Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn Invoke[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Control.AsyncActivation`1[T])
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn TryFinally[T](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn TryWith[T](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]])
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.FSharpAsync`1[T] MakeAsync[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.AsyncActivation`1[T],Microsoft.FSharp.Control.AsyncReturn])
+Microsoft.FSharp.Control.BackgroundTaskBuilder: System.Threading.Tasks.Task`1[T] RunDynamic[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
+Microsoft.FSharp.Control.BackgroundTaskBuilder: System.Threading.Tasks.Task`1[T] Run[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
+Microsoft.FSharp.Control.CommonExtensions: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AsyncWrite(System.IO.Stream, Byte[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.CommonExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Byte[]] AsyncReadBytes(System.IO.Stream, Int32)
+Microsoft.FSharp.Control.CommonExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Int32] AsyncRead(System.IO.Stream, Byte[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.CommonExtensions: System.IDisposable SubscribeToObservable[T](System.IObservable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.CommonExtensions: Void AddToObservable[T](System.IObservable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[System.Tuple`2[T,T]],System.Tuple`2[T,T]] Pairwise[TDel,T](Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult],TResult] Choose[T,TResult,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult],TResult] Map[T,TResult,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult],TResult] Scan[TResult,T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], TResult, Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] Filter[T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] Merge[TDel1,T,TDel2](Microsoft.FSharp.Control.IEvent`2[TDel1,T], Microsoft.FSharp.Control.IEvent`2[TDel2,T])
+Microsoft.FSharp.Control.EventModule: System.Tuple`2[Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult1],TResult1],Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult2],TResult2]] Split[T,TResult1,TResult2,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[TResult1,TResult2]], Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: System.Tuple`2[Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T],Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T]] Partition[T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: Void Add[T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Control.FSharpAsync`1[T]] StartChild[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpChoice`2[T,System.Exception]] Catch[T](Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[T]] Choice[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[T]]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AwaitTask(System.Threading.Tasks.Task)
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Ignore[T](Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Sleep(Int32)
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Sleep(System.TimeSpan)
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] SwitchToContext(System.Threading.SynchronizationContext)
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] SwitchToNewThread()
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] SwitchToThreadPool()
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Boolean] AwaitIAsyncResult(System.IAsyncResult, Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Boolean] AwaitWaitHandle(System.Threading.WaitHandle, Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.IDisposable] OnCancel(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Threading.CancellationToken] CancellationToken
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Threading.CancellationToken] get_CancellationToken()
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Threading.Tasks.Task`1[T]] StartChildAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.Tasks.TaskCreationOptions])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Parallel[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Parallel[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Sequential[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitEvent[TDel,T](Microsoft.FSharp.Control.IEvent`2[TDel,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitTask[T](System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,TArg2,TArg3,T](TArg1, TArg2, TArg3, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`5[TArg1,TArg2,TArg3,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,TArg2,T](TArg1, TArg2, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`4[TArg1,TArg2,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,T](TArg1, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[TArg1,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromContinuations[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit],Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.Unit],Microsoft.FSharp.Core.FSharpFunc`2[System.OperationCanceledException,Microsoft.FSharp.Core.Unit]],Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] TryCancelled[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.OperationCanceledException,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.FSharpAsync: System.Threading.CancellationToken DefaultCancellationToken
+Microsoft.FSharp.Control.FSharpAsync: System.Threading.CancellationToken get_DefaultCancellationToken()
+Microsoft.FSharp.Control.FSharpAsync: System.Threading.Tasks.Task`1[T] StartAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.Tasks.TaskCreationOptions], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsync: System.Threading.Tasks.Task`1[T] StartImmediateAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsync: System.Tuple`3[Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[TArg,System.AsyncCallback,System.Object],System.IAsyncResult],Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T],Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,Microsoft.FSharp.Core.Unit]] AsBeginEnd[TArg,T](Microsoft.FSharp.Core.FSharpFunc`2[TArg,Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.FSharpAsync: T RunSynchronously[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsync: Void CancelDefaultToken()
+Microsoft.FSharp.Control.FSharpAsync: Void Start(Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsync: Void StartImmediate(Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsync: Void StartWithContinuations[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[System.OperationCanceledException,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] For[T](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] While(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Zero()
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Bind[T,TResult](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[TResult]])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Using[T,TResult](T, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[TResult]])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] Combine[T](Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] Delay[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] ReturnFrom[T](Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] Return[T](T)
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] TryFinally[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] TryWith[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply]: Void Reply(TReply)
+Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate] Publish
+Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate] get_Publish()
+Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Void .ctor()
+Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Void Trigger(System.Object[])
+Microsoft.FSharp.Control.FSharpEvent`1[T]: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] Publish
+Microsoft.FSharp.Control.FSharpEvent`1[T]: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] get_Publish()
+Microsoft.FSharp.Control.FSharpEvent`1[T]: Void .ctor()
+Microsoft.FSharp.Control.FSharpEvent`1[T]: Void Trigger(T)
+Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Microsoft.FSharp.Control.IEvent`2[TDelegate,TArgs] Publish
+Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Microsoft.FSharp.Control.IEvent`2[TDelegate,TArgs] get_Publish()
+Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Void .ctor()
+Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Void Trigger(System.Object, TArgs)
+Microsoft.FSharp.Control.FSharpHandler`1[T]: System.IAsyncResult BeginInvoke(System.Object, T, System.AsyncCallback, System.Object)
+Microsoft.FSharp.Control.FSharpHandler`1[T]: Void .ctor(System.Object, IntPtr)
+Microsoft.FSharp.Control.FSharpHandler`1[T]: Void EndInvoke(System.IAsyncResult)
+Microsoft.FSharp.Control.FSharpHandler`1[T]: Void Invoke(System.Object, T)
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 CurrentQueueLength
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 DefaultTimeout
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 get_CurrentQueueLength()
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 get_DefaultTimeout()
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[TMsg]] TryReceive(Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[TReply]] PostAndTryAsyncReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[T]] TryScan[T](Microsoft.FSharp.Core.FSharpFunc`2[TMsg,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[TMsg] Receive(Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[TReply] PostAndAsyncReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[T] Scan[T](Microsoft.FSharp.Core.FSharpFunc`2[TMsg,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpHandler`1[System.Exception] Error
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg] Start(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg],Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Core.FSharpOption`1[TReply] TryPostAndReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: TReply PostAndReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void .ctor(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg],Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void Post(TMsg)
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void Start()
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void add_Error(Microsoft.FSharp.Control.FSharpHandler`1[System.Exception])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void remove_Error(Microsoft.FSharp.Control.FSharpHandler`1[System.Exception])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void set_DefaultTimeout(Int32)
+Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate]: Void AddHandler(TDelegate)
+Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate]: Void RemoveHandler(TDelegate)
+Microsoft.FSharp.Control.LazyExtensions: System.Lazy`1[T] CreateFromValue[T](T)
+Microsoft.FSharp.Control.LazyExtensions: System.Lazy`1[T] Create[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T])
+Microsoft.FSharp.Control.LazyExtensions: T Force[T](System.Lazy`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IDisposable Subscribe[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[System.Tuple`2[T,T]] Pairwise[T](System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[TResult] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[TResult] Scan[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], TResult, System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[T] Merge[T](System.IObservable`1[T], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.Tuple`2[System.IObservable`1[TResult1],System.IObservable`1[TResult2]] Split[T,TResult1,TResult2](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[TResult1,TResult2]], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.Tuple`2[System.IObservable`1[T],System.IObservable`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: Void Add[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], System.IObservable`1[T])
+Microsoft.FSharp.Control.TaskBuilder: System.Threading.Tasks.Task`1[T] RunDynamic[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
+Microsoft.FSharp.Control.TaskBuilder: System.Threading.Tasks.Task`1[T] Run[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit] For[T,TOverall](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit] While[TOverall](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit] Zero[TOverall]()
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] Combine[TOverall,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] Delay[TOverall,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] TryFinally[TOverall,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] TryWith[TOverall,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] Using[TResource,TOverall,T](TResource, Microsoft.FSharp.Core.FSharpFunc`2[TResource,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] Return[T](T)
+Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority: Boolean TaskBuilderBase.BindDynamic.Static[TOverall,TResult1,TResult2](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall]] ByRef, System.Threading.Tasks.Task`1[TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind[TResult1,TOverall,TResult2](Microsoft.FSharp.Control.TaskBuilderBase, System.Threading.Tasks.Task`1[TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom[T](Microsoft.FSharp.Control.TaskBuilderBase, System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Boolean TaskBuilderBase.BindDynamic.Static$W[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike,TAwaiter], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall]] ByRef, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Boolean TaskBuilderBase.BindDynamic.Static[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall]] ByRef, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind$W[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike,TAwaiter], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,System.Boolean], Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] TaskBuilderBase.Using[TResource,TOverall,T](Microsoft.FSharp.Control.TaskBuilderBase, TResource, Microsoft.FSharp.Core.FSharpFunc`2[TResource,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom$W[TTaskLike,TAwaiter,T](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike,TAwaiter], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,T], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,System.Boolean], Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike)
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom[TTaskLike,TAwaiter,T](Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike)
+Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind[TResult1,TOverall,TResult2](Microsoft.FSharp.Control.TaskBuilderBase, Microsoft.FSharp.Control.FSharpAsync`1[TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom[T](Microsoft.FSharp.Control.TaskBuilderBase, Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.BackgroundTaskBuilder backgroundTask
+Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.BackgroundTaskBuilder get_backgroundTask()
+Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.TaskBuilder get_task()
+Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.TaskBuilder task
+Microsoft.FSharp.Control.TaskStateMachineData`1[T]: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1[T] MethodBuilder
+Microsoft.FSharp.Control.TaskStateMachineData`1[T]: T Result
+Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AsyncDownloadFile(System.Net.WebClient, System.Uri, System.String)
+Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Byte[]] AsyncDownloadData(System.Net.WebClient, System.Uri)
+Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Net.WebResponse] AsyncGetResponse(System.Net.WebRequest)
+Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.String] AsyncDownloadString(System.Net.WebClient, System.Uri)
+Microsoft.FSharp.Core.AbstractClassAttribute: Void .ctor()
+Microsoft.FSharp.Core.AllowNullLiteralAttribute: Boolean Value
+Microsoft.FSharp.Core.AllowNullLiteralAttribute: Boolean get_Value()
+Microsoft.FSharp.Core.AllowNullLiteralAttribute: Void .ctor()
+Microsoft.FSharp.Core.AllowNullLiteralAttribute: Void .ctor(Boolean)
+Microsoft.FSharp.Core.AutoOpenAttribute: System.String Path
+Microsoft.FSharp.Core.AutoOpenAttribute: System.String get_Path()
+Microsoft.FSharp.Core.AutoOpenAttribute: Void .ctor()
+Microsoft.FSharp.Core.AutoOpenAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.AutoSerializableAttribute: Boolean Value
+Microsoft.FSharp.Core.AutoSerializableAttribute: Boolean get_Value()
+Microsoft.FSharp.Core.AutoSerializableAttribute: Void .ctor(Boolean)
+Microsoft.FSharp.Core.ByRefKinds: Microsoft.FSharp.Core.ByRefKinds+In
+Microsoft.FSharp.Core.ByRefKinds: Microsoft.FSharp.Core.ByRefKinds+InOut
+Microsoft.FSharp.Core.ByRefKinds: Microsoft.FSharp.Core.ByRefKinds+Out
+Microsoft.FSharp.Core.CLIEventAttribute: Void .ctor()
+Microsoft.FSharp.Core.CLIMutableAttribute: Void .ctor()
+Microsoft.FSharp.Core.ClassAttribute: Void .ctor()
+Microsoft.FSharp.Core.ComparisonConditionalOnAttribute: Void .ctor()
+Microsoft.FSharp.Core.CompilationArgumentCountsAttribute: System.Collections.Generic.IEnumerable`1[System.Int32] Counts
+Microsoft.FSharp.Core.CompilationArgumentCountsAttribute: System.Collections.Generic.IEnumerable`1[System.Int32] get_Counts()
+Microsoft.FSharp.Core.CompilationArgumentCountsAttribute: Void .ctor(Int32[])
+Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 SequenceNumber
+Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 VariantNumber
+Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 get_SequenceNumber()
+Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 get_VariantNumber()
+Microsoft.FSharp.Core.CompilationMappingAttribute: Microsoft.FSharp.Core.SourceConstructFlags SourceConstructFlags
+Microsoft.FSharp.Core.CompilationMappingAttribute: Microsoft.FSharp.Core.SourceConstructFlags get_SourceConstructFlags()
+Microsoft.FSharp.Core.CompilationMappingAttribute: System.String ResourceName
+Microsoft.FSharp.Core.CompilationMappingAttribute: System.String get_ResourceName()
+Microsoft.FSharp.Core.CompilationMappingAttribute: System.Type[] TypeDefinitions
+Microsoft.FSharp.Core.CompilationMappingAttribute: System.Type[] get_TypeDefinitions()
+Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(Microsoft.FSharp.Core.SourceConstructFlags)
+Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(Microsoft.FSharp.Core.SourceConstructFlags, Int32)
+Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(Microsoft.FSharp.Core.SourceConstructFlags, Int32, Int32)
+Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(System.String, System.Type[])
+Microsoft.FSharp.Core.CompilationRepresentationAttribute: Microsoft.FSharp.Core.CompilationRepresentationFlags Flags
+Microsoft.FSharp.Core.CompilationRepresentationAttribute: Microsoft.FSharp.Core.CompilationRepresentationFlags get_Flags()
+Microsoft.FSharp.Core.CompilationRepresentationAttribute: Void .ctor(Microsoft.FSharp.Core.CompilationRepresentationFlags)
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Int32 value__
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags Event
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags Instance
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags ModuleSuffix
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags None
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags Static
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags UseNullAsTrueValue
+Microsoft.FSharp.Core.CompilationSourceNameAttribute: System.String SourceName
+Microsoft.FSharp.Core.CompilationSourceNameAttribute: System.String get_SourceName()
+Microsoft.FSharp.Core.CompilationSourceNameAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.CompiledNameAttribute: System.String CompiledName
+Microsoft.FSharp.Core.CompiledNameAttribute: System.String get_CompiledName()
+Microsoft.FSharp.Core.CompiledNameAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean IsError
+Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean IsHidden
+Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean get_IsError()
+Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean get_IsHidden()
+Microsoft.FSharp.Core.CompilerMessageAttribute: Int32 MessageNumber
+Microsoft.FSharp.Core.CompilerMessageAttribute: Int32 get_MessageNumber()
+Microsoft.FSharp.Core.CompilerMessageAttribute: System.String Message
+Microsoft.FSharp.Core.CompilerMessageAttribute: System.String get_Message()
+Microsoft.FSharp.Core.CompilerMessageAttribute: Void .ctor(System.String, Int32)
+Microsoft.FSharp.Core.CompilerMessageAttribute: Void set_IsError(Boolean)
+Microsoft.FSharp.Core.CompilerMessageAttribute: Void set_IsHidden(Boolean)
+Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object)
+Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: TResult EndInvoke(System.IAsyncResult)
+Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: TResult Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
+Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: Void .ctor(System.Object, IntPtr)
+Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: T[] AddManyAndClose(System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: T[] Close()
+Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: Void Add(T)
+Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: Void AddMany(System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Boolean CheckClose
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Boolean get_CheckClose()
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Int32 GenerateNext(System.Collections.Generic.IEnumerable`1[T] ByRef)
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: System.Collections.Generic.IEnumerator`1[T] GetFreshEnumerator()
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: T LastGenerated
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: T get_LastGenerated()
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Void .ctor()
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Void Close()
+Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace[] GetNestedNamespaces()
+Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.String NamespaceName
+Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.String get_NamespaceName()
+Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.Type ResolveTypeName(System.String)
+Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.Type[] GetTypes()
+Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: Int32 ResumptionPoint
+Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: Int32 get_ResumptionPoint()
+Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: TData Data
+Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: TData get_Data()
+Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: Void set_Data(TData)
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider2: System.Reflection.MethodBase ApplyStaticArgumentsForMethod(System.Reflection.MethodBase, System.String, System.Object[])
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider2: System.Reflection.ParameterInfo[] GetStaticParametersForMethod(System.Reflection.MethodBase)
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Byte[] GetGeneratedAssemblyContents(System.Reflection.Assembly)
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace[] GetNamespaces()
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Microsoft.FSharp.Quotations.FSharpExpr GetInvokerExpression(System.Reflection.MethodBase, Microsoft.FSharp.Quotations.FSharpExpr[])
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: System.EventHandler Invalidate
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: System.Reflection.ParameterInfo[] GetStaticParameters(System.Type)
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: System.Type ApplyStaticArguments(System.Type, System.String[], System.Object[])
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Void add_Invalidate(System.EventHandler)
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Void remove_Invalidate(System.EventHandler)
+Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] AddManyAndClose(System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Close()
+Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Void Add(T)
+Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Void AddMany(System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object)
+Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: Void .ctor(System.Object, IntPtr)
+Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: Void EndInvoke(System.IAsyncResult)
+Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: Void Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
+Microsoft.FSharp.Core.CompilerServices.NoEagerConstraintApplicationAttribute: Void .ctor()
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean CombineDynamic[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean TryFinallyAsyncDynamic[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean TryWithDynamic[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean WhileDynamic[TData](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean YieldDynamic[TData](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] For[T,TData](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] While[TData](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] Yield[TData]()
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] Zero[TData]()
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] Combine[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] Delay[TData,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] TryFinallyAsync[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] TryFinally[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] TryWith[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] Using[TResource,TData,T](TResource, Microsoft.FSharp.Core.FSharpFunc`2[TResource,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: Boolean EndInvoke(System.IAsyncResult)
+Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: Boolean Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
+Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object)
+Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: Void .ctor(System.Object, IntPtr)
+Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData]: Int32 ResumptionPoint
+Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData]: Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData] ResumptionDynamicInfo
+Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData]: TData Data
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData] ResumptionFunc
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData] get_ResumptionFunc()
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: System.Object ResumptionData
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: System.Object get_ResumptionData()
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void .ctor(Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData])
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void MoveNext(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void SetStateMachine(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine)
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void set_ResumptionData(System.Object)
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void set_ResumptionFunc(Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData])
+Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: Boolean EndInvoke(System.IAsyncResult)
+Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: Boolean Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
+Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object)
+Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: Void .ctor(System.Object, IntPtr)
+Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: Microsoft.FSharp.Control.IEvent`2[TDelegate,TArgs] CreateEvent[TDelegate,TArgs](Microsoft.FSharp.Core.FSharpFunc`2[TDelegate,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[TDelegate,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpFunc`2[System.Object,Microsoft.FSharp.Core.FSharpFunc`2[TArgs,Microsoft.FSharp.Core.Unit]],TDelegate])
+Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[TResult] EnumerateFromFunctions[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
+Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[TResult] EnumerateUsing[T,TCollection,TResult](T, Microsoft.FSharp.Core.FSharpFunc`2[T,TCollection])
+Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[T] EnumerateThenFinally[T](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[T] EnumerateWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine, System.AsyncCallback, System.Object)
+Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void .ctor(System.Object, IntPtr)
+Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void EndInvoke(System.IAsyncResult)
+Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine)
+Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Boolean __useResumableCode[T]()
+Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] __resumableEntry()
+Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: T __resumeAt[T](Int32)
+Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: TResult __stateMachine[TData,TResult](Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult])
+Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Void __debugPoint(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: System.String AssemblyName
+Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: System.String get_AssemblyName()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: Void .ctor()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderAttribute: Void .ctor()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean IsHostedExecution
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean IsInvalidationSupported
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean SystemRuntimeContainsType(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean get_IsHostedExecution()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean get_IsInvalidationSupported()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String ResolutionFolder
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String RuntimeAssembly
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String TemporaryFolder
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String get_ResolutionFolder()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String get_RuntimeAssembly()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String get_TemporaryFolder()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String[] ReferencedAssemblies
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String[] get_ReferencedAssemblies()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.Version SystemRuntimeAssemblyVersion
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.Version get_SystemRuntimeAssemblyVersion()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void .ctor(Microsoft.FSharp.Core.FSharpFunc`2[System.String,System.Boolean])
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void .ctor(Microsoft.FSharp.Core.FSharpFunc`2[System.String,System.Boolean], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.String[]])
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_IsHostedExecution(Boolean)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_IsInvalidationSupported(Boolean)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_ReferencedAssemblies(System.String[])
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_ResolutionFolder(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_RuntimeAssembly(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_SystemRuntimeAssemblyVersion(System.Version)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_TemporaryFolder(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 Column
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 Line
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 get_Column()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 get_Line()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: System.String FilePath
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: System.String get_FilePath()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void .ctor()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void set_Column(Int32)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void set_FilePath(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void set_Line(Int32)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderEditorHideMethodsAttribute: Void .ctor()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes: Int32 value__
+Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes: Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes IsErased
+Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes: Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes SuppressRelocate
+Microsoft.FSharp.Core.CompilerServices.TypeProviderXmlDocAttribute: System.String CommentText
+Microsoft.FSharp.Core.CompilerServices.TypeProviderXmlDocAttribute: System.String get_CommentText()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderXmlDocAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.CustomComparisonAttribute: Void .ctor()
+Microsoft.FSharp.Core.CustomEqualityAttribute: Void .ctor()
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean AllowIntoPattern
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean IsLikeGroupJoin
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean IsLikeJoin
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean IsLikeZip
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean MaintainsVariableSpace
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean MaintainsVariableSpaceUsingBind
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_AllowIntoPattern()
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_IsLikeGroupJoin()
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_IsLikeJoin()
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_IsLikeZip()
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_MaintainsVariableSpace()
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_MaintainsVariableSpaceUsingBind()
+Microsoft.FSharp.Core.CustomOperationAttribute: System.String JoinConditionWord
+Microsoft.FSharp.Core.CustomOperationAttribute: System.String Name
+Microsoft.FSharp.Core.CustomOperationAttribute: System.String get_JoinConditionWord()
+Microsoft.FSharp.Core.CustomOperationAttribute: System.String get_Name()
+Microsoft.FSharp.Core.CustomOperationAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_AllowIntoPattern(Boolean)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_IsLikeGroupJoin(Boolean)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_IsLikeJoin(Boolean)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_IsLikeZip(Boolean)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_JoinConditionWord(System.String)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_MaintainsVariableSpace(Boolean)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_MaintainsVariableSpaceUsingBind(Boolean)
+Microsoft.FSharp.Core.DefaultAugmentationAttribute: Boolean Value
+Microsoft.FSharp.Core.DefaultAugmentationAttribute: Boolean get_Value()
+Microsoft.FSharp.Core.DefaultAugmentationAttribute: Void .ctor(Boolean)
+Microsoft.FSharp.Core.DefaultValueAttribute: Boolean Check
+Microsoft.FSharp.Core.DefaultValueAttribute: Boolean get_Check()
+Microsoft.FSharp.Core.DefaultValueAttribute: Void .ctor()
+Microsoft.FSharp.Core.DefaultValueAttribute: Void .ctor(Boolean)
+Microsoft.FSharp.Core.EntryPointAttribute: Void .ctor()
+Microsoft.FSharp.Core.EqualityConditionalOnAttribute: Void .ctor()
+Microsoft.FSharp.Core.ExperimentalAttribute: System.String Message
+Microsoft.FSharp.Core.ExperimentalAttribute: System.String get_Message()
+Microsoft.FSharp.Core.ExperimentalAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: Byte ToByte[T](T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: SByte ToSByte[T](T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Byte ToByte[T](T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Double ToDouble$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Double ToDouble[T](T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Collections.FSharpSet`1[T] CreateSet[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Control.FSharpAsyncBuilder DefaultAsyncBuilder
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Control.FSharpAsyncBuilder get_DefaultAsyncBuilder()
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Linq.QueryBuilder get_query()
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Linq.QueryBuilder query
+Microsoft.FSharp.Core.ExtraTopLevelOperators: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: SByte ToSByte[T](T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Single ToSingle$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Single ToSingle[T](T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: System.Collections.Generic.IDictionary`2[TKey,TValue] CreateDictionary[TKey,TValue](System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,TValue]])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: System.Collections.Generic.IReadOnlyDictionary`2[TKey,TValue] CreateReadOnlyDictionary[TKey,TValue](System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,TValue]])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T LazyPattern[T](System.Lazy`1[T])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatLineToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatLineToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatLine[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToStringThenFail[T,TResult](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToString[T](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,System.String])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormat[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T SpliceExpression[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T SpliceUntypedExpression[T](Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T[,] CreateArray2D[?,T](System.Collections.Generic.IEnumerable`1[?])
+Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]: T1 Item
+Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]: T1 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2]: T2 Item
+Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2]: T2 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`2+Tags[T1,T2]: Int32 Choice1Of2
+Microsoft.FSharp.Core.FSharpChoice`2+Tags[T1,T2]: Int32 Choice2Of2
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`2[T1,T2])
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean IsChoice1Of2
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean IsChoice2Of2
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean get_IsChoice1Of2()
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean get_IsChoice2Of2()
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`2[T1,T2])
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 Tag
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2]
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2+Tags[T1,T2]
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2[T1,T2] NewChoice1Of2(T1)
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2[T1,T2] NewChoice2Of2(T2)
+Microsoft.FSharp.Core.FSharpChoice`3+Choice1Of3[T1,T2,T3]: T1 Item
+Microsoft.FSharp.Core.FSharpChoice`3+Choice1Of3[T1,T2,T3]: T1 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`3+Choice2Of3[T1,T2,T3]: T2 Item
+Microsoft.FSharp.Core.FSharpChoice`3+Choice2Of3[T1,T2,T3]: T2 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`3+Choice3Of3[T1,T2,T3]: T3 Item
+Microsoft.FSharp.Core.FSharpChoice`3+Choice3Of3[T1,T2,T3]: T3 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]: Int32 Choice1Of3
+Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]: Int32 Choice2Of3
+Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]: Int32 Choice3Of3
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3])
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean IsChoice1Of3
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean IsChoice2Of3
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean IsChoice3Of3
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean get_IsChoice1Of3()
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean get_IsChoice2Of3()
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean get_IsChoice3Of3()
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3])
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 Tag
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Choice1Of3[T1,T2,T3]
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Choice2Of3[T1,T2,T3]
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Choice3Of3[T1,T2,T3]
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3] NewChoice1Of3(T1)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3] NewChoice2Of3(T2)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3] NewChoice3Of3(T3)
+Microsoft.FSharp.Core.FSharpChoice`4+Choice1Of4[T1,T2,T3,T4]: T1 Item
+Microsoft.FSharp.Core.FSharpChoice`4+Choice1Of4[T1,T2,T3,T4]: T1 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`4+Choice2Of4[T1,T2,T3,T4]: T2 Item
+Microsoft.FSharp.Core.FSharpChoice`4+Choice2Of4[T1,T2,T3,T4]: T2 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`4+Choice3Of4[T1,T2,T3,T4]: T3 Item
+Microsoft.FSharp.Core.FSharpChoice`4+Choice3Of4[T1,T2,T3,T4]: T3 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`4+Choice4Of4[T1,T2,T3,T4]: T4 Item
+Microsoft.FSharp.Core.FSharpChoice`4+Choice4Of4[T1,T2,T3,T4]: T4 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice1Of4
+Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice2Of4
+Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice3Of4
+Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice4Of4
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4])
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice1Of4
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice2Of4
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice3Of4
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice4Of4
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice1Of4()
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice2Of4()
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice3Of4()
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice4Of4()
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4])
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 Tag
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice1Of4[T1,T2,T3,T4]
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice2Of4[T1,T2,T3,T4]
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice3Of4[T1,T2,T3,T4]
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice4Of4[T1,T2,T3,T4]
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice1Of4(T1)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice2Of4(T2)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice3Of4(T3)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice4Of4(T4)
+Microsoft.FSharp.Core.FSharpChoice`5+Choice1Of5[T1,T2,T3,T4,T5]: T1 Item
+Microsoft.FSharp.Core.FSharpChoice`5+Choice1Of5[T1,T2,T3,T4,T5]: T1 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`5+Choice2Of5[T1,T2,T3,T4,T5]: T2 Item
+Microsoft.FSharp.Core.FSharpChoice`5+Choice2Of5[T1,T2,T3,T4,T5]: T2 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`5+Choice3Of5[T1,T2,T3,T4,T5]: T3 Item
+Microsoft.FSharp.Core.FSharpChoice`5+Choice3Of5[T1,T2,T3,T4,T5]: T3 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`5+Choice4Of5[T1,T2,T3,T4,T5]: T4 Item
+Microsoft.FSharp.Core.FSharpChoice`5+Choice4Of5[T1,T2,T3,T4,T5]: T4 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`5+Choice5Of5[T1,T2,T3,T4,T5]: T5 Item
+Microsoft.FSharp.Core.FSharpChoice`5+Choice5Of5[T1,T2,T3,T4,T5]: T5 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice1Of5
+Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice2Of5
+Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice3Of5
+Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice4Of5
+Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice5Of5
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5])
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice1Of5
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice2Of5
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice3Of5
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice4Of5
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice5Of5
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice1Of5()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice2Of5()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice3Of5()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice4Of5()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice5Of5()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5])
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 Tag
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice1Of5[T1,T2,T3,T4,T5]
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice2Of5[T1,T2,T3,T4,T5]
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice3Of5[T1,T2,T3,T4,T5]
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice4Of5[T1,T2,T3,T4,T5]
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice5Of5[T1,T2,T3,T4,T5]
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice1Of5(T1)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice2Of5(T2)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice3Of5(T3)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice4Of5(T4)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice5Of5(T5)
+Microsoft.FSharp.Core.FSharpChoice`6+Choice1Of6[T1,T2,T3,T4,T5,T6]: T1 Item
+Microsoft.FSharp.Core.FSharpChoice`6+Choice1Of6[T1,T2,T3,T4,T5,T6]: T1 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`6+Choice2Of6[T1,T2,T3,T4,T5,T6]: T2 Item
+Microsoft.FSharp.Core.FSharpChoice`6+Choice2Of6[T1,T2,T3,T4,T5,T6]: T2 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`6+Choice3Of6[T1,T2,T3,T4,T5,T6]: T3 Item
+Microsoft.FSharp.Core.FSharpChoice`6+Choice3Of6[T1,T2,T3,T4,T5,T6]: T3 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`6+Choice4Of6[T1,T2,T3,T4,T5,T6]: T4 Item
+Microsoft.FSharp.Core.FSharpChoice`6+Choice4Of6[T1,T2,T3,T4,T5,T6]: T4 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`6+Choice5Of6[T1,T2,T3,T4,T5,T6]: T5 Item
+Microsoft.FSharp.Core.FSharpChoice`6+Choice5Of6[T1,T2,T3,T4,T5,T6]: T5 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`6+Choice6Of6[T1,T2,T3,T4,T5,T6]: T6 Item
+Microsoft.FSharp.Core.FSharpChoice`6+Choice6Of6[T1,T2,T3,T4,T5,T6]: T6 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice1Of6
+Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice2Of6
+Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice3Of6
+Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice4Of6
+Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice5Of6
+Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice6Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6])
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice1Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice2Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice3Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice4Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice5Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice6Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice1Of6()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice2Of6()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice3Of6()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice4Of6()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice5Of6()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice6Of6()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6])
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 Tag
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice1Of6[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice2Of6[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice3Of6[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice4Of6[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice5Of6[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice6Of6[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice1Of6(T1)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice2Of6(T2)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice3Of6(T3)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice4Of6(T4)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice5Of6(T5)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice6Of6(T6)
+Microsoft.FSharp.Core.FSharpChoice`7+Choice1Of7[T1,T2,T3,T4,T5,T6,T7]: T1 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice1Of7[T1,T2,T3,T4,T5,T6,T7]: T1 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Choice2Of7[T1,T2,T3,T4,T5,T6,T7]: T2 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice2Of7[T1,T2,T3,T4,T5,T6,T7]: T2 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Choice3Of7[T1,T2,T3,T4,T5,T6,T7]: T3 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice3Of7[T1,T2,T3,T4,T5,T6,T7]: T3 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Choice4Of7[T1,T2,T3,T4,T5,T6,T7]: T4 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice4Of7[T1,T2,T3,T4,T5,T6,T7]: T4 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Choice5Of7[T1,T2,T3,T4,T5,T6,T7]: T5 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice5Of7[T1,T2,T3,T4,T5,T6,T7]: T5 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Choice6Of7[T1,T2,T3,T4,T5,T6,T7]: T6 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice6Of7[T1,T2,T3,T4,T5,T6,T7]: T6 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Choice7Of7[T1,T2,T3,T4,T5,T6,T7]: T7 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice7Of7[T1,T2,T3,T4,T5,T6,T7]: T7 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice1Of7
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice2Of7
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice3Of7
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice4Of7
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice5Of7
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice6Of7
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice7Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7])
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice1Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice2Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice3Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice4Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice5Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice6Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice7Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice1Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice2Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice3Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice4Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice5Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice6Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice7Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7])
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 Tag
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice1Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice2Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice3Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice4Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice5Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice6Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice7Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice1Of7(T1)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice2Of7(T2)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice3Of7(T3)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice4Of7(T4)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice5Of7(T5)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice6Of7(T6)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice7Of7(T7)
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] FromConverter(System.Converter`2[T,TResult])
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] op_Implicit(System.Converter`2[T,TResult])
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: System.Converter`2[T,TResult] ToConverter(Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: System.Converter`2[T,TResult] op_Implicit(Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: TResult Invoke(T)
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: V InvokeFast[V](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,V]], T, TResult)
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Void .ctor()
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: W InvokeFast[V,W](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[V,W]]], T, TResult, V)
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: X InvokeFast[V,W,X](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[V,Microsoft.FSharp.Core.FSharpFunc`2[W,X]]]], T, TResult, V, W)
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Y InvokeFast[V,W,X,Y](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[V,Microsoft.FSharp.Core.FSharpFunc`2[W,Microsoft.FSharp.Core.FSharpFunc`2[X,Y]]]]], T, TResult, V, W, X)
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 Major
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 Minor
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 Release
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 get_Major()
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 get_Minor()
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 get_Release()
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Void .ctor(Int32, Int32, Int32)
+Microsoft.FSharp.Core.FSharpOption`1+Tags[T]: Int32 None
+Microsoft.FSharp.Core.FSharpOption`1+Tags[T]: Int32 Some
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean IsNone
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean IsSome
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean get_IsNone(Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean get_IsSome(Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 GetTag(Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1+Tags[T]
+Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] None
+Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] Some(T)
+Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] get_None()
+Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] op_Implicit(T)
+Microsoft.FSharp.Core.FSharpOption`1[T]: System.String ToString()
+Microsoft.FSharp.Core.FSharpOption`1[T]: T Value
+Microsoft.FSharp.Core.FSharpOption`1[T]: T get_Value()
+Microsoft.FSharp.Core.FSharpOption`1[T]: Void .ctor(T)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpRef`1[T])
+Microsoft.FSharp.Core.FSharpRef`1[T]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpRef`1[T])
+Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpRef`1[T]: T Value
+Microsoft.FSharp.Core.FSharpRef`1[T]: T contents
+Microsoft.FSharp.Core.FSharpRef`1[T]: T contents@
+Microsoft.FSharp.Core.FSharpRef`1[T]: T get_Value()
+Microsoft.FSharp.Core.FSharpRef`1[T]: T get_contents()
+Microsoft.FSharp.Core.FSharpRef`1[T]: Void .ctor(T)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Void set_Value(T)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Void set_contents(T)
+Microsoft.FSharp.Core.FSharpResult`2+Tags[T,TError]: Int32 Error
+Microsoft.FSharp.Core.FSharpResult`2+Tags[T,TError]: Int32 Ok
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean Equals(Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean IsError
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean IsOk
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean get_IsError()
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean get_IsOk()
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 Tag
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Microsoft.FSharp.Core.FSharpResult`2+Tags[T,TError]
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Microsoft.FSharp.Core.FSharpResult`2[T,TError] NewError(TError)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Microsoft.FSharp.Core.FSharpResult`2[T,TError] NewOk(T)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: T ResultValue
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: T get_ResultValue()
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: TError ErrorValue
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: TError get_ErrorValue()
+Microsoft.FSharp.Core.FSharpTypeFunc: System.Object Specialize[T]()
+Microsoft.FSharp.Core.FSharpTypeFunc: Void .ctor()
+Microsoft.FSharp.Core.FSharpValueOption`1+Tags[T]: Int32 ValueNone
+Microsoft.FSharp.Core.FSharpValueOption`1+Tags[T]: Int32 ValueSome
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsNone
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsSome
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsValueNone
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsValueSome
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsNone()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsSome()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsValueNone()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsValueSome()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 Tag
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1+Tags[T]
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] NewValueSome(T)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] None
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] Some(T)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] ValueNone
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] get_None()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] get_ValueNone()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] op_Implicit(T)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: System.String ToString()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: T Item
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: T Value
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: T get_Item()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: T get_Value()
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit] FromAction(System.Action)
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T] FromFunc[T](System.Func`1[T])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit] FromAction[T](System.Action`1[T])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit] ToFSharpFunc[T](System.Action`1[T])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] FromFunc[T,TResult](System.Func`2[T,TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] ToFSharpFunc[T,TResult](System.Converter`2[T,TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,Microsoft.FSharp.Core.Unit]]]]] FromAction[T1,T2,T3,T4,T5](System.Action`5[T1,T2,T3,T4,T5])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]]] FromFunc[T1,T2,T3,T4,T5,TResult](System.Func`6[T1,T2,T3,T4,T5,TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]]] FuncFromTupled[T1,T2,T3,T4,T5,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`5[T1,T2,T3,T4,T5],TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.Unit]]]] FromAction[T1,T2,T3,T4](System.Action`4[T1,T2,T3,T4])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]]] FromFunc[T1,T2,T3,T4,TResult](System.Func`5[T1,T2,T3,T4,TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]]] FuncFromTupled[T1,T2,T3,T4,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`4[T1,T2,T3,T4],TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.Unit]]] FromAction[T1,T2,T3](System.Action`3[T1,T2,T3])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]] FromFunc[T1,T2,T3,TResult](System.Func`4[T1,T2,T3,TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]] FuncFromTupled[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[T1,T2,T3],TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]] FromAction[T1,T2](System.Action`2[T1,T2])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]] FromFunc[T1,T2,TResult](System.Func`3[T1,T2,TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]] FuncFromTupled[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[T1,T2],TResult])
+Microsoft.FSharp.Core.GeneralizableValueAttribute: Void .ctor()
+Microsoft.FSharp.Core.InlineIfLambdaAttribute: Void .ctor()
+Microsoft.FSharp.Core.InterfaceAttribute: Void .ctor()
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String AddressOpNotFirstClassString
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String InputArrayEmptyString
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String InputMustBeNonNegativeString
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String InputSequenceEmptyString
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String NoNegateMinValueString
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_AddressOpNotFirstClassString()
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_InputArrayEmptyString()
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_InputMustBeNonNegativeString()
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_InputSequenceEmptyString()
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_NoNegateMinValueString()
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple2[T1,T2](System.Collections.IEqualityComparer, System.Tuple`2[T1,T2], System.Tuple`2[T1,T2])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple3[T1,T2,T3](System.Collections.IEqualityComparer, System.Tuple`3[T1,T2,T3], System.Tuple`3[T1,T2,T3])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple4[T1,T2,T3,T4](System.Collections.IEqualityComparer, System.Tuple`4[T1,T2,T3,T4], System.Tuple`4[T1,T2,T3,T4])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple5[T1,T2,T3,T4,T5](System.Collections.IEqualityComparer, System.Tuple`5[T1,T2,T3,T4,T5], System.Tuple`5[T1,T2,T3,T4,T5])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericEqualityERIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericEqualityIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericEqualityWithComparerIntrinsic[T](System.Collections.IEqualityComparer, T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericGreaterOrEqualIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericGreaterThanIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericLessOrEqualIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericLessThanIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean PhysicalEqualityIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple2[T1,T2](System.Collections.IComparer, System.Tuple`2[T1,T2], System.Tuple`2[T1,T2])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple3[T1,T2,T3](System.Collections.IComparer, System.Tuple`3[T1,T2,T3], System.Tuple`3[T1,T2,T3])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple4[T1,T2,T3,T4](System.Collections.IComparer, System.Tuple`4[T1,T2,T3,T4], System.Tuple`4[T1,T2,T3,T4])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple5[T1,T2,T3,T4,T5](System.Collections.IComparer, System.Tuple`5[T1,T2,T3,T4,T5], System.Tuple`5[T1,T2,T3,T4,T5])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple2[T1,T2](System.Collections.IEqualityComparer, System.Tuple`2[T1,T2])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple3[T1,T2,T3](System.Collections.IEqualityComparer, System.Tuple`3[T1,T2,T3])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple4[T1,T2,T3,T4](System.Collections.IEqualityComparer, System.Tuple`4[T1,T2,T3,T4])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple5[T1,T2,T3,T4,T5](System.Collections.IEqualityComparer, System.Tuple`5[T1,T2,T3,T4,T5])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericComparisonIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericComparisonWithComparerIntrinsic[T](System.Collections.IComparer, T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericHashIntrinsic[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericHashWithComparerIntrinsic[T](System.Collections.IEqualityComparer, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 LimitedGenericHashIntrinsic[T](Int32, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 PhysicalHashIntrinsic[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Boolean TypeTestFast[T](System.Object)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Boolean TypeTestGeneric[T](System.Object)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Char GetString(System.String, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: System.Decimal MakeDecimal(Int32, Int32, Int32, Boolean, Byte)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T CheckThis[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T CreateInstance[T]()
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray2D[T](T[,], Int32, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray3D[T](T[,,], Int32, Int32, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray4D[T](T[,,,], Int32, Int32, Int32, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray[T](T[], Int32)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T UnboxFast[T](System.Object)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T UnboxGeneric[T](System.Object)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void Dispose[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void FailInit()
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void FailStaticInit()
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray2D[T](T[,], Int32, Int32, T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray3D[T](T[,,], Int32, Int32, Int32, T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray4D[T](T[,,,], Int32, Int32, Int32, Int32, T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray[T](T[], Int32, T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean Or(Boolean, Boolean)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean op_Amp(Boolean, Boolean)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean op_BooleanAnd(Boolean, Boolean)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean op_BooleanOr(Boolean, Boolean)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: IntPtr op_IntegerAddressOf[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: T& op_AddressOf[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericEqualityER[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericEqualityWithComparer[T](System.Collections.IEqualityComparer, T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericEquality[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericGreaterOrEqual[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericGreaterThan[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericLessOrEqual[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericLessThan[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean PhysicalEquality[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Byte ByteWithMeasure(Byte)
+Microsoft.FSharp.Core.LanguagePrimitives: Double FloatWithMeasure(Double)
+Microsoft.FSharp.Core.LanguagePrimitives: Int16 Int16WithMeasure(Int16)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericComparisonWithComparer[T](System.Collections.IComparer, T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericComparison[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericHashWithComparer[T](System.Collections.IEqualityComparer, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericHash[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericLimitedHash[T](Int32, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 Int32WithMeasure(Int32)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 ParseInt32(System.String)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 PhysicalHash[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives: Int64 Int64WithMeasure(Int64)
+Microsoft.FSharp.Core.LanguagePrimitives: Int64 ParseInt64(System.String)
+Microsoft.FSharp.Core.LanguagePrimitives: IntPtr IntPtrWithMeasure(IntPtr)
+Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings
+Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+HashCompare
+Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions
+Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators
+Microsoft.FSharp.Core.LanguagePrimitives: SByte SByteWithMeasure(SByte)
+Microsoft.FSharp.Core.LanguagePrimitives: Single Float32WithMeasure(Single)
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IComparer`1[T] FastGenericComparerFromTable[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IComparer`1[T] FastGenericComparer[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IEqualityComparer`1[T] FastGenericEqualityComparerFromTable[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IEqualityComparer`1[T] FastGenericEqualityComparer[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IEqualityComparer`1[T] FastLimitedGenericEqualityComparer[T](Int32)
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IComparer GenericComparer
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IComparer get_GenericComparer()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer GenericEqualityComparer
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer GenericEqualityERComparer
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer get_GenericEqualityComparer()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer get_GenericEqualityERComparer()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Decimal DecimalWithMeasure(System.Decimal)
+Microsoft.FSharp.Core.LanguagePrimitives: T DivideByInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], T, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives: T DivideByIntDynamic[T](T, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives: T DivideByInt[T](T, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives: T EnumToValue[TEnum,T](TEnum)
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericMaximum[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericMinimum[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericOne$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T])
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericOneDynamic[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericOne[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericZero$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T])
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericZeroDynamic[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericZero[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: TEnum EnumOfValue[T,TEnum](T)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult AdditionDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult BitwiseAndDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult BitwiseOrDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedAdditionDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedExplicitDynamic[T,TResult](T)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedMultiplyDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedSubtractionDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedUnaryNegationDynamic[T,TResult](T)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult DivisionDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult EqualityDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult ExclusiveOrDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult ExplicitDynamic[T,TResult](T)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult GreaterThanDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult GreaterThanOrEqualDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult InequalityDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult LeftShiftDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult LessThanDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult LessThanOrEqualDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult LogicalNotDynamic[T,TResult](T)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult ModulusDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult MultiplyDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult RightShiftDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult SubtractionDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult UnaryNegationDynamic[T,TResult](T)
+Microsoft.FSharp.Core.LanguagePrimitives: UInt16 UInt16WithMeasure(UInt16)
+Microsoft.FSharp.Core.LanguagePrimitives: UInt32 ParseUInt32(System.String)
+Microsoft.FSharp.Core.LanguagePrimitives: UInt32 UInt32WithMeasure(UInt32)
+Microsoft.FSharp.Core.LanguagePrimitives: UInt64 ParseUInt64(System.String)
+Microsoft.FSharp.Core.LanguagePrimitives: UInt64 UInt64WithMeasure(UInt64)
+Microsoft.FSharp.Core.LanguagePrimitives: UIntPtr UIntPtrWithMeasure(UIntPtr)
+Microsoft.FSharp.Core.LiteralAttribute: Void .ctor()
+Microsoft.FSharp.Core.MatchFailureException: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.MatchFailureException: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.MatchFailureException: Int32 Data1
+Microsoft.FSharp.Core.MatchFailureException: Int32 Data2
+Microsoft.FSharp.Core.MatchFailureException: Int32 GetHashCode()
+Microsoft.FSharp.Core.MatchFailureException: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.MatchFailureException: Int32 get_Data1()
+Microsoft.FSharp.Core.MatchFailureException: Int32 get_Data2()
+Microsoft.FSharp.Core.MatchFailureException: System.String Data0
+Microsoft.FSharp.Core.MatchFailureException: System.String Message
+Microsoft.FSharp.Core.MatchFailureException: System.String get_Data0()
+Microsoft.FSharp.Core.MatchFailureException: System.String get_Message()
+Microsoft.FSharp.Core.MatchFailureException: Void .ctor()
+Microsoft.FSharp.Core.MatchFailureException: Void .ctor(System.String, Int32, Int32)
+Microsoft.FSharp.Core.MeasureAnnotatedAbbreviationAttribute: Void .ctor()
+Microsoft.FSharp.Core.MeasureAttribute: Void .ctor()
+Microsoft.FSharp.Core.NoComparisonAttribute: Void .ctor()
+Microsoft.FSharp.Core.NoCompilerInliningAttribute: Void .ctor()
+Microsoft.FSharp.Core.NoDynamicInvocationAttribute: Void .ctor()
+Microsoft.FSharp.Core.NoEqualityAttribute: Void .ctor()
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: System.Object FromInt64Dynamic(Int64)
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: System.Object FromStringDynamic(System.String)
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromInt32[T](Int32)
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromInt64[T](Int64)
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromOne[T]()
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromString[T](System.String)
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromZero[T]()
+Microsoft.FSharp.Core.NumericLiterals: Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI
+Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 String.GetReverseIndex(System.String, Int32, Int32)
+Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 [,,,]`1.GetReverseIndex[T](T[,,,], Int32, Int32)
+Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 [,,]`1.GetReverseIndex[T](T[,,], Int32, Int32)
+Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 [,]`1.GetReverseIndex[T](T[,], Int32, Int32)
+Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 []`1.GetReverseIndex[T](T[], Int32, Int32)
+Microsoft.FSharp.Core.Operators+Checked: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T)
+Microsoft.FSharp.Core.Operators+Checked: Byte ToByte[T](T)
+Microsoft.FSharp.Core.Operators+Checked: Char ToChar$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Char], T)
+Microsoft.FSharp.Core.Operators+Checked: Char ToChar[T](T)
+Microsoft.FSharp.Core.Operators+Checked: Int16 ToInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int16], T)
+Microsoft.FSharp.Core.Operators+Checked: Int16 ToInt16[T](T)
+Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T)
+Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T)
+Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt32[T](T)
+Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt[T](T)
+Microsoft.FSharp.Core.Operators+Checked: Int64 ToInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int64], T)
+Microsoft.FSharp.Core.Operators+Checked: Int64 ToInt64[T](T)
+Microsoft.FSharp.Core.Operators+Checked: IntPtr ToIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.IntPtr], T)
+Microsoft.FSharp.Core.Operators+Checked: IntPtr ToIntPtr[T](T)
+Microsoft.FSharp.Core.Operators+Checked: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T)
+Microsoft.FSharp.Core.Operators+Checked: SByte ToSByte[T](T)
+Microsoft.FSharp.Core.Operators+Checked: T op_UnaryNegation$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators+Checked: T op_UnaryNegation[T](T)
+Microsoft.FSharp.Core.Operators+Checked: T3 op_Addition$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators+Checked: T3 op_Addition[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators+Checked: T3 op_Multiply$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators+Checked: T3 op_Multiply[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators+Checked: T3 op_Subtraction$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators+Checked: T3 op_Subtraction[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators+Checked: UInt16 ToUInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt16], T)
+Microsoft.FSharp.Core.Operators+Checked: UInt16 ToUInt16[T](T)
+Microsoft.FSharp.Core.Operators+Checked: UInt32 ToUInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], T)
+Microsoft.FSharp.Core.Operators+Checked: UInt32 ToUInt32[T](T)
+Microsoft.FSharp.Core.Operators+Checked: UInt64 ToUInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt64], T)
+Microsoft.FSharp.Core.Operators+Checked: UInt64 ToUInt64[T](T)
+Microsoft.FSharp.Core.Operators+Checked: UIntPtr ToUIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UIntPtr], T)
+Microsoft.FSharp.Core.Operators+Checked: UIntPtr ToUIntPtr[T](T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Equality$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Equality[T](T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThan$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThanOrEqual$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThanOrEqual[T,TResult](T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThan[T,TResult](T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Inequality$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Inequality[T](T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThan$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThanOrEqual$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThanOrEqual[T,TResult](T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThan[T,TResult](T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Int32 Compare$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Int32 Compare[T](T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Int32 Hash[T](T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Max$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Max[T](T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Min$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Min[T](T, T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Byte PowByte(Byte, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Double PowDouble(Double, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int16 PowInt16(Int16, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int32 PowInt32(Int32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int32 SignDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int64 PowInt64(Int64, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: IntPtr PowIntPtr(IntPtr, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: SByte PowSByte(SByte, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Single PowSingle(Single, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Byte] RangeByte(Byte, Byte, Byte)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Char] RangeChar(Char, Char)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Double] RangeDouble(Double, Double, Double)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Int16] RangeInt16(Int16, Int16, Int16)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Int32] RangeInt32(Int32, Int32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Int64] RangeInt64(Int64, Int64, Int64)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.IntPtr] RangeIntPtr(IntPtr, IntPtr, IntPtr)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.SByte] RangeSByte(SByte, SByte, SByte)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Single] RangeSingle(Single, Single, Single)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UInt16] RangeUInt16(UInt16, UInt16, UInt16)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UInt32] RangeUInt32(UInt32, UInt32, UInt32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UInt64] RangeUInt64(UInt64, UInt64, UInt64)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UIntPtr] RangeUIntPtr(UIntPtr, UIntPtr, UIntPtr)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[T] RangeGeneric[T](T, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[T] RangeStepGeneric[TStep,T](TStep, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TStep,T]], T, TStep, T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Decimal PowDecimal(System.Decimal, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.String GetStringSlice(System.String, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AbsDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AcosDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AsinDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AtanDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T CeilingDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T CosDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T CoshDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T ExpDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T FloorDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T Log10Dynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T LogDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T PowDynamic[T,TResult](T, TResult)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T PowGeneric[T](T, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T RoundDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T SinDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T SinhDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T TanDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T TanhDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T TruncateDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T2 Atan2Dynamic[T1,T2](T1, T1)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T2 SqrtDynamic[T1,T2](T1)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,,] GetArraySlice4D[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice3D[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle1[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle2[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle3[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice2D[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice3DFixedSingle1[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice3DFixedSingle2[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice3DFixedSingle3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble1[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble3[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble5[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble6[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice2DFixed1[T](T[,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice2DFixed2[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice3DFixedDouble1[T](T[,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice3DFixedDouble2[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice3DFixedDouble3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple1[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple3[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple4[T](T[,,,], Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice[T](T[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UInt16 PowUInt16(UInt16, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UInt32 PowUInt32(UInt32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UInt64 PowUInt64(UInt64, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UIntPtr PowUIntPtr(UIntPtr, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice2DFixed1[T](T[,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice2DFixed2[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice2D[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedDouble1[T](T[,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedDouble2[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedDouble3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedSingle1[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedSingle2[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedSingle3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3D[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble1[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble3[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble5[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble6[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle1[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle2[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle3[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple1[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Int32, T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple3[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple4[T](T[,,,], Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4D[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice[T](T[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[])
+Microsoft.FSharp.Core.Operators+Unchecked: Boolean Equals[T](T, T)
+Microsoft.FSharp.Core.Operators+Unchecked: Int32 Compare[T](T, T)
+Microsoft.FSharp.Core.Operators+Unchecked: Int32 Hash[T](T)
+Microsoft.FSharp.Core.Operators+Unchecked: T DefaultOf[T]()
+Microsoft.FSharp.Core.Operators+Unchecked: T Unbox[T](System.Object)
+Microsoft.FSharp.Core.Operators: Boolean IsNull[T](T)
+Microsoft.FSharp.Core.Operators: Boolean Not(Boolean)
+Microsoft.FSharp.Core.Operators: Boolean op_Equality[T](T, T)
+Microsoft.FSharp.Core.Operators: Boolean op_GreaterThanOrEqual[T](T, T)
+Microsoft.FSharp.Core.Operators: Boolean op_GreaterThan[T](T, T)
+Microsoft.FSharp.Core.Operators: Boolean op_Inequality[T](T, T)
+Microsoft.FSharp.Core.Operators: Boolean op_LessThanOrEqual[T](T, T)
+Microsoft.FSharp.Core.Operators: Boolean op_LessThan[T](T, T)
+Microsoft.FSharp.Core.Operators: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T)
+Microsoft.FSharp.Core.Operators: Byte ToByte[T](T)
+Microsoft.FSharp.Core.Operators: Char ToChar$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Char], T)
+Microsoft.FSharp.Core.Operators: Char ToChar[T](T)
+Microsoft.FSharp.Core.Operators: Double Infinity
+Microsoft.FSharp.Core.Operators: Double NaN
+Microsoft.FSharp.Core.Operators: Double ToDouble$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], T)
+Microsoft.FSharp.Core.Operators: Double ToDouble[T](T)
+Microsoft.FSharp.Core.Operators: Double get_Infinity()
+Microsoft.FSharp.Core.Operators: Double get_NaN()
+Microsoft.FSharp.Core.Operators: Int16 ToInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int16], T)
+Microsoft.FSharp.Core.Operators: Int16 ToInt16[T](T)
+Microsoft.FSharp.Core.Operators: Int32 Compare[T](T, T)
+Microsoft.FSharp.Core.Operators: Int32 Hash[T](T)
+Microsoft.FSharp.Core.Operators: Int32 Sign$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T)
+Microsoft.FSharp.Core.Operators: Int32 Sign[T](T)
+Microsoft.FSharp.Core.Operators: Int32 SizeOf[T]()
+Microsoft.FSharp.Core.Operators: Int32 ToInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T)
+Microsoft.FSharp.Core.Operators: Int32 ToInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T)
+Microsoft.FSharp.Core.Operators: Int32 ToInt32[T](T)
+Microsoft.FSharp.Core.Operators: Int32 ToInt[T](T)
+Microsoft.FSharp.Core.Operators: Int32 limitedHash[T](Int32, T)
+Microsoft.FSharp.Core.Operators: Int64 ToInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int64], T)
+Microsoft.FSharp.Core.Operators: Int64 ToInt64[T](T)
+Microsoft.FSharp.Core.Operators: IntPtr ToIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.IntPtr], T)
+Microsoft.FSharp.Core.Operators: IntPtr ToIntPtr[T](T)
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Collections.FSharpList`1[T] op_Append[T](Microsoft.FSharp.Collections.FSharpList`1[T], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpFunc`2[T1,T3] op_ComposeLeft[T2,T3,T1](Microsoft.FSharp.Core.FSharpFunc`2[T2,T3], Microsoft.FSharp.Core.FSharpFunc`2[T1,T2])
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpFunc`2[T1,T3] op_ComposeRight[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,T2], Microsoft.FSharp.Core.FSharpFunc`2[T2,T3])
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpOption`1[System.String] FailurePattern(System.Exception)
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpOption`1[T] TryUnbox[T](System.Object)
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpRef`1[T] Ref[T](T)
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+ArrayExtensions
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+Checked
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+NonStructuralComparison
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+OperatorIntrinsics
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+Unchecked
+Microsoft.FSharp.Core.Operators: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T)
+Microsoft.FSharp.Core.Operators: SByte ToSByte[T](T)
+Microsoft.FSharp.Core.Operators: Single InfinitySingle
+Microsoft.FSharp.Core.Operators: Single NaNSingle
+Microsoft.FSharp.Core.Operators: Single ToSingle$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], T)
+Microsoft.FSharp.Core.Operators: Single ToSingle[T](T)
+Microsoft.FSharp.Core.Operators: Single get_InfinitySingle()
+Microsoft.FSharp.Core.Operators: Single get_NaNSingle()
+Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] CreateSequence[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_Range$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T)
+Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_RangeStep$W[T,TStep](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TStep], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TStep,T]], T, TStep, T)
+Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_RangeStep[T,TStep](T, TStep, T)
+Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_Range[T](T, T)
+Microsoft.FSharp.Core.Operators: System.Decimal ToDecimal$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Decimal], T)
+Microsoft.FSharp.Core.Operators: System.Decimal ToDecimal[T](T)
+Microsoft.FSharp.Core.Operators: System.Exception Failure(System.String)
+Microsoft.FSharp.Core.Operators: System.IO.TextReader ConsoleIn[T]()
+Microsoft.FSharp.Core.Operators: System.IO.TextWriter ConsoleError[T]()
+Microsoft.FSharp.Core.Operators: System.IO.TextWriter ConsoleOut[T]()
+Microsoft.FSharp.Core.Operators: System.Object Box[T](T)
+Microsoft.FSharp.Core.Operators: System.RuntimeMethodHandle MethodHandleOf[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
+Microsoft.FSharp.Core.Operators: System.String NameOf[T](T)
+Microsoft.FSharp.Core.Operators: System.String ToString[T](T)
+Microsoft.FSharp.Core.Operators: System.String op_Concatenate(System.String, System.String)
+Microsoft.FSharp.Core.Operators: System.Tuple`2[TKey,TValue] KeyValuePattern[TKey,TValue](System.Collections.Generic.KeyValuePair`2[TKey,TValue])
+Microsoft.FSharp.Core.Operators: System.Type TypeDefOf[T]()
+Microsoft.FSharp.Core.Operators: System.Type TypeOf[T]()
+Microsoft.FSharp.Core.Operators: T Abs$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Abs[T](T)
+Microsoft.FSharp.Core.Operators: T Acos$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Acos[T](T)
+Microsoft.FSharp.Core.Operators: T Asin$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Asin[T](T)
+Microsoft.FSharp.Core.Operators: T Atan$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Atan[T](T)
+Microsoft.FSharp.Core.Operators: T Ceiling$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Ceiling[T](T)
+Microsoft.FSharp.Core.Operators: T Cos$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Cos[T](T)
+Microsoft.FSharp.Core.Operators: T Cosh$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Cosh[T](T)
+Microsoft.FSharp.Core.Operators: T DefaultArg[T](Microsoft.FSharp.Core.FSharpOption`1[T], T)
+Microsoft.FSharp.Core.Operators: T DefaultValueArg[T](Microsoft.FSharp.Core.FSharpValueOption`1[T], T)
+Microsoft.FSharp.Core.Operators: T Exit[T](Int32)
+Microsoft.FSharp.Core.Operators: T Exp$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Exp[T](T)
+Microsoft.FSharp.Core.Operators: T FailWith[T](System.String)
+Microsoft.FSharp.Core.Operators: T Floor$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Floor[T](T)
+Microsoft.FSharp.Core.Operators: T Identity[T](T)
+Microsoft.FSharp.Core.Operators: T InvalidArg[T](System.String, System.String)
+Microsoft.FSharp.Core.Operators: T InvalidOp[T](System.String)
+Microsoft.FSharp.Core.Operators: T Lock[TLock,T](TLock, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T])
+Microsoft.FSharp.Core.Operators: T Log$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Log10$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Log10[T](T)
+Microsoft.FSharp.Core.Operators: T Log[T](T)
+Microsoft.FSharp.Core.Operators: T Max[T](T, T)
+Microsoft.FSharp.Core.Operators: T Min[T](T, T)
+Microsoft.FSharp.Core.Operators: T NullArg[T](System.String)
+Microsoft.FSharp.Core.Operators: T PowInteger$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, Int32)
+Microsoft.FSharp.Core.Operators: T PowInteger[T](T, Int32)
+Microsoft.FSharp.Core.Operators: T Raise[T](System.Exception)
+Microsoft.FSharp.Core.Operators: T Reraise[T]()
+Microsoft.FSharp.Core.Operators: T Rethrow[T]()
+Microsoft.FSharp.Core.Operators: T Round$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Round[T](T)
+Microsoft.FSharp.Core.Operators: T Sin$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Sin[T](T)
+Microsoft.FSharp.Core.Operators: T Sinh$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Sinh[T](T)
+Microsoft.FSharp.Core.Operators: T Tan$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Tan[T](T)
+Microsoft.FSharp.Core.Operators: T Tanh$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Tanh[T](T)
+Microsoft.FSharp.Core.Operators: T Truncate$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Truncate[T](T)
+Microsoft.FSharp.Core.Operators: T Unbox[T](System.Object)
+Microsoft.FSharp.Core.Operators: T op_BitwiseAnd$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T)
+Microsoft.FSharp.Core.Operators: T op_BitwiseAnd[T](T, T)
+Microsoft.FSharp.Core.Operators: T op_BitwiseOr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T)
+Microsoft.FSharp.Core.Operators: T op_BitwiseOr[T](T, T)
+Microsoft.FSharp.Core.Operators: T op_Dereference[T](Microsoft.FSharp.Core.FSharpRef`1[T])
+Microsoft.FSharp.Core.Operators: T op_ExclusiveOr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T)
+Microsoft.FSharp.Core.Operators: T op_ExclusiveOr[T](T, T)
+Microsoft.FSharp.Core.Operators: T op_Exponentiation$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,T]], T, TResult)
+Microsoft.FSharp.Core.Operators: T op_Exponentiation[T,TResult](T, TResult)
+Microsoft.FSharp.Core.Operators: T op_LeftShift$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], T, Int32)
+Microsoft.FSharp.Core.Operators: T op_LeftShift[T](T, Int32)
+Microsoft.FSharp.Core.Operators: T op_LogicalNot$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T op_LogicalNot[T](T)
+Microsoft.FSharp.Core.Operators: T op_RightShift$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], T, Int32)
+Microsoft.FSharp.Core.Operators: T op_RightShift[T](T, Int32)
+Microsoft.FSharp.Core.Operators: T op_UnaryNegation$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T op_UnaryNegation[T](T)
+Microsoft.FSharp.Core.Operators: T op_UnaryPlus$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T op_UnaryPlus[T](T)
+Microsoft.FSharp.Core.Operators: T1 Fst[T1,T2](System.Tuple`2[T1,T2])
+Microsoft.FSharp.Core.Operators: T2 Atan2$W[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T1,T2]], T1, T1)
+Microsoft.FSharp.Core.Operators: T2 Atan2[T1,T2](T1, T1)
+Microsoft.FSharp.Core.Operators: T2 Snd[T1,T2](System.Tuple`2[T1,T2])
+Microsoft.FSharp.Core.Operators: T3 op_Addition$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Addition[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Division$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Division[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Modulus$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Modulus[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Multiply$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Multiply[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Subtraction$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Subtraction[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators: TResult Sqrt$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T)
+Microsoft.FSharp.Core.Operators: TResult Sqrt[T,TResult](T)
+Microsoft.FSharp.Core.Operators: TResult ToEnum[TResult](Int32)
+Microsoft.FSharp.Core.Operators: TResult Using[T,TResult](T, Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
+Microsoft.FSharp.Core.Operators: TResult op_PipeLeft2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], T1, T2)
+Microsoft.FSharp.Core.Operators: TResult op_PipeLeft3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], T1, T2, T3)
+Microsoft.FSharp.Core.Operators: TResult op_PipeLeft[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T)
+Microsoft.FSharp.Core.Operators: TResult op_PipeRight2[T1,T2,TResult](T1, T2, Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]])
+Microsoft.FSharp.Core.Operators: TResult op_PipeRight3[T1,T2,T3,TResult](T1, T2, T3, Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]])
+Microsoft.FSharp.Core.Operators: TResult op_PipeRight[T1,TResult](T1, Microsoft.FSharp.Core.FSharpFunc`2[T1,TResult])
+Microsoft.FSharp.Core.Operators: UInt16 ToUInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt16], T)
+Microsoft.FSharp.Core.Operators: UInt16 ToUInt16[T](T)
+Microsoft.FSharp.Core.Operators: UInt32 ToUInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], T)
+Microsoft.FSharp.Core.Operators: UInt32 ToUInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], T)
+Microsoft.FSharp.Core.Operators: UInt32 ToUInt32[T](T)
+Microsoft.FSharp.Core.Operators: UInt32 ToUInt[T](T)
+Microsoft.FSharp.Core.Operators: UInt64 ToUInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt64], T)
+Microsoft.FSharp.Core.Operators: UInt64 ToUInt64[T](T)
+Microsoft.FSharp.Core.Operators: UIntPtr ToUIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UIntPtr], T)
+Microsoft.FSharp.Core.Operators: UIntPtr ToUIntPtr[T](T)
+Microsoft.FSharp.Core.Operators: Void Decrement(Microsoft.FSharp.Core.FSharpRef`1[System.Int32])
+Microsoft.FSharp.Core.Operators: Void Ignore[T](T)
+Microsoft.FSharp.Core.Operators: Void Increment(Microsoft.FSharp.Core.FSharpRef`1[System.Int32])
+Microsoft.FSharp.Core.Operators: Void op_ColonEquals[T](Microsoft.FSharp.Core.FSharpRef`1[T], T)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: FSharpFunc`3 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]])
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult] Invoke(T1)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: TResult Invoke(T1, T2)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: Void .ctor()
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: FSharpFunc`4 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]])
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]] Invoke(T1)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: TResult Invoke(T1, T2, T3)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: Void .ctor()
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: FSharpFunc`5 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]]])
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]] Invoke(T1)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: TResult Invoke(T1, T2, T3, T4)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: Void .ctor()
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: FSharpFunc`6 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]]])
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]] Invoke(T1)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: TResult Invoke(T1, T2, T3, T4, T5)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: Void .ctor()
+Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]
+Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]
+Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]
+Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]
+Microsoft.FSharp.Core.OptionModule: Boolean Contains[T](T, Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Boolean IsNone[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Boolean IsSome[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Int32 Count[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], Microsoft.FSharp.Core.FSharpOption`1[T1], Microsoft.FSharp.Core.FSharpOption`1[T2])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], Microsoft.FSharp.Core.FSharpOption`1[T1], Microsoft.FSharp.Core.FSharpOption`1[T2], Microsoft.FSharp.Core.FSharpOption`1[T3])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] Flatten[T](Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpOption`1[T]])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OfNullable[T](System.Nullable`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OfObj[T](T)
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OrElseWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.FSharpOption`1[T]], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OrElse[T](Microsoft.FSharp.Core.FSharpOption`1[T], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: System.Nullable`1[T] ToNullable[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: T DefaultValue[T](T, Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: T DefaultWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: T GetValue[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: T ToObj[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Core.FSharpOption`1[T], TState)
+Microsoft.FSharp.Core.OptionModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: T[] ToArray[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionalArgumentAttribute: Void .ctor()
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Object[] Captures
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Object[] get_Captures()
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.String ToString()
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.String Value
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.String get_Value()
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Type[] CaptureTypes
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Type[] get_CaptureTypes()
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: Void .ctor(System.String)
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: Void .ctor(System.String, System.Object[], System.Type[])
+Microsoft.FSharp.Core.PrintfFormat`5[TPrinter,TState,TResidue,TResult,TTuple]: Void .ctor(System.String)
+Microsoft.FSharp.Core.PrintfFormat`5[TPrinter,TState,TResidue,TResult,TTuple]: Void .ctor(System.String, System.Object[], System.Type[])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatLineToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatLineToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatLine[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[System.String,TResult], Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringBuilderThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], System.Text.StringBuilder, Microsoft.FSharp.Core.PrintfFormat`4[T,System.Text.StringBuilder,Microsoft.FSharp.Core.Unit,TResult])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringBuilder[T](System.Text.StringBuilder, Microsoft.FSharp.Core.PrintfFormat`4[T,System.Text.StringBuilder,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringThenFail[T,TResult](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[System.String,TResult], Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringThen[T](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,System.String])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToTextWriterThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,TResult])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormat[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ProjectionParameterAttribute: Void .ctor()
+Microsoft.FSharp.Core.ReferenceEqualityAttribute: Void .ctor()
+Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Boolean IncludeValue
+Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Boolean get_IncludeValue()
+Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Void .ctor()
+Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Void .ctor(Boolean)
+Microsoft.FSharp.Core.RequireQualifiedAccessAttribute: Void .ctor()
+Microsoft.FSharp.Core.RequiresExplicitTypeArgumentsAttribute: Void .ctor()
+Microsoft.FSharp.Core.ResultModule: Boolean Contains[T,TError](T, Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Boolean Exists[T,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Boolean ForAll[T,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Boolean IsError[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Boolean IsOk[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Int32 Count[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpOption`1[T] ToOption[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpResult`2[T,TResult] MapError[TError,TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[TError,TResult], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpResult`2[TResult,TError] Bind[T,TResult,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpResult`2[TResult,TError]], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpResult`2[TResult,TError] Map[T,TResult,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpValueOption`1[T] ToValueOption[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: T DefaultValue[T,TError](T, Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: T DefaultWith[TError,T](Microsoft.FSharp.Core.FSharpFunc`2[TError,T], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: TState FoldBack[T,TError,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Core.FSharpResult`2[T,TError], TState)
+Microsoft.FSharp.Core.ResultModule: TState Fold[T,TError,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: T[] ToArray[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Void Iterate[T,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.SealedAttribute: Boolean Value
+Microsoft.FSharp.Core.SealedAttribute: Boolean get_Value()
+Microsoft.FSharp.Core.SealedAttribute: Void .ctor()
+Microsoft.FSharp.Core.SealedAttribute: Void .ctor(Boolean)
+Microsoft.FSharp.Core.SourceConstructFlags: Int32 value__
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Closure
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Exception
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Field
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags KindMask
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Module
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags NonPublicRepresentation
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags None
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags ObjectType
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags RecordType
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags SumType
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags UnionCase
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Value
+Microsoft.FSharp.Core.StringModule: Boolean Exists(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Boolean], System.String)
+Microsoft.FSharp.Core.StringModule: Boolean ForAll(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Boolean], System.String)
+Microsoft.FSharp.Core.StringModule: Int32 Length(System.String)
+Microsoft.FSharp.Core.StringModule: System.String Collect(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.String], System.String)
+Microsoft.FSharp.Core.StringModule: System.String Concat(System.String, System.Collections.Generic.IEnumerable`1[System.String])
+Microsoft.FSharp.Core.StringModule: System.String Filter(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Boolean], System.String)
+Microsoft.FSharp.Core.StringModule: System.String Initialize(Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.String])
+Microsoft.FSharp.Core.StringModule: System.String Map(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Char], System.String)
+Microsoft.FSharp.Core.StringModule: System.String MapIndexed(Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Char]], System.String)
+Microsoft.FSharp.Core.StringModule: System.String Replicate(Int32, System.String)
+Microsoft.FSharp.Core.StringModule: Void Iterate(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,Microsoft.FSharp.Core.Unit], System.String)
+Microsoft.FSharp.Core.StringModule: Void IterateIndexed(Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Char,Microsoft.FSharp.Core.Unit]], System.String)
+Microsoft.FSharp.Core.StructAttribute: Void .ctor()
+Microsoft.FSharp.Core.StructuralComparisonAttribute: Void .ctor()
+Microsoft.FSharp.Core.StructuralEqualityAttribute: Void .ctor()
+Microsoft.FSharp.Core.StructuredFormatDisplayAttribute: System.String Value
+Microsoft.FSharp.Core.StructuredFormatDisplayAttribute: System.String get_Value()
+Microsoft.FSharp.Core.StructuredFormatDisplayAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.Unit: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.Unit: Int32 GetHashCode()
+Microsoft.FSharp.Core.UnverifiableAttribute: Void .ctor()
+Microsoft.FSharp.Core.ValueOption: Boolean Contains[T](T, Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Boolean IsNone[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Boolean IsSome[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Int32 Count[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpValueOption`1[TResult]], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], Microsoft.FSharp.Core.FSharpValueOption`1[T1], Microsoft.FSharp.Core.FSharpValueOption`1[T2])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], Microsoft.FSharp.Core.FSharpValueOption`1[T1], Microsoft.FSharp.Core.FSharpValueOption`1[T2], Microsoft.FSharp.Core.FSharpValueOption`1[T3])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] Flatten[T](Microsoft.FSharp.Core.FSharpValueOption`1[Microsoft.FSharp.Core.FSharpValueOption`1[T]])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OfNullable[T](System.Nullable`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OfObj[T](T)
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OrElseWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.FSharpValueOption`1[T]], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OrElse[T](Microsoft.FSharp.Core.FSharpValueOption`1[T], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: System.Nullable`1[T] ToNullable[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: T DefaultValue[T](T, Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: T DefaultWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: T GetValue[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: T ToObj[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Core.FSharpValueOption`1[T], TState)
+Microsoft.FSharp.Core.ValueOption: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: T[] ToArray[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.VolatileFieldAttribute: Void .ctor()
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToByte[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToUInt8$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToUInt8[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Char] ToChar$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Char], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Char] ToChar[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Decimal] ToDecimal$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Decimal], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Decimal] ToDecimal[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToDouble$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToDouble[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToFloat$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToFloat[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int16] ToInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int16], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int16] ToInt16[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt32[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int64] ToInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int64], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int64] ToInt64[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.IntPtr] ToIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.IntPtr], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.IntPtr] ToIntPtr[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToInt8$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToInt8[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToSByte[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToFloat32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToFloat32[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToSingle$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToSingle[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt16] ToUInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt16], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt16] ToUInt16[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt32[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt64] ToUInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt64], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt64] ToUInt64[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UIntPtr] ToUIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UIntPtr], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UIntPtr] ToUIntPtr[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[TResult] ToEnum[TResult](System.Nullable`1[System.Int32])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_EqualsQmark[T](T, System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_GreaterEqualsQmark[T](T, System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_GreaterQmark[T](T, System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_LessEqualsQmark[T](T, System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_LessGreaterQmark[T](T, System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_LessQmark[T](T, System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkEqualsQmark[T](System.Nullable`1[T], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkEquals[T](System.Nullable`1[T], T)
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreaterEqualsQmark[T](System.Nullable`1[T], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreaterEquals[T](System.Nullable`1[T], T)
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreaterQmark[T](System.Nullable`1[T], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreater[T](System.Nullable`1[T], T)
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessEqualsQmark[T](System.Nullable`1[T], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessEquals[T](System.Nullable`1[T], T)
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessGreaterQmark[T](System.Nullable`1[T], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessGreater[T](System.Nullable`1[T], T)
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessQmark[T](System.Nullable`1[T], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLess[T](System.Nullable`1[T], T)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_DivideQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_DivideQmark[T1,T2,T3](T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MinusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MinusQmark[T1,T2,T3](T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MultiplyQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MultiplyQmark[T1,T2,T3](T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PercentQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PercentQmark[T1,T2,T3](T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PlusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PlusQmark[T1,T2,T3](T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivide$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivideQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivideQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivide[T1,T2,T3](System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinus$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinusQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinus[T1,T2,T3](System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiply$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiplyQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiplyQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiply[T1,T2,T3](System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercent$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercentQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercentQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercent[T1,T2,T3](System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlus$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlusQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlus[T1,T2,T3](System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.QueryBuilder: Boolean All[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
+Microsoft.FSharp.Linq.QueryBuilder: Boolean Contains[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], T)
+Microsoft.FSharp.Linq.QueryBuilder: Boolean Exists[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
+Microsoft.FSharp.Linq.QueryBuilder: Int32 Count[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[System.Linq.IGrouping`2[TKey,TValue],Q] GroupValBy[T,TKey,TValue,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[System.Linq.IGrouping`2[TKey,T],Q] GroupBy[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Distinct[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SkipWhile[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Skip[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Int32)
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortByDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortByNullableDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortByNullable[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortBy[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Source[T,Q](System.Linq.IQueryable`1[T])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] TakeWhile[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Take[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Int32)
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenByDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenByNullableDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenByNullable[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenBy[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Where[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] YieldFrom[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Yield[T,Q](T)
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Zero[T,Q]()
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,System.Collections.IEnumerable] Source[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] For[T,Q,TResult,Q2](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Linq.QuerySource`2[TResult,Q2]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] GroupJoin[TOuter,Q,TInner,TKey,TResult](Microsoft.FSharp.Linq.QuerySource`2[TOuter,Q], Microsoft.FSharp.Linq.QuerySource`2[TInner,Q], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TInner,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,Microsoft.FSharp.Core.FSharpFunc`2[System.Collections.Generic.IEnumerable`1[TInner],TResult]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] Join[TOuter,Q,TInner,TKey,TResult](Microsoft.FSharp.Linq.QuerySource`2[TOuter,Q], Microsoft.FSharp.Linq.QuerySource`2[TInner,Q], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TInner,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,Microsoft.FSharp.Core.FSharpFunc`2[TInner,TResult]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] LeftOuterJoin[TOuter,Q,TInner,TKey,TResult](Microsoft.FSharp.Linq.QuerySource`2[TOuter,Q], Microsoft.FSharp.Linq.QuerySource`2[TInner,Q], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TInner,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,Microsoft.FSharp.Core.FSharpFunc`2[System.Collections.Generic.IEnumerable`1[TInner],TResult]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] Select[T,Q,TResult](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Quotations.FSharpExpr`1[T] Quote[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T])
+Microsoft.FSharp.Linq.QueryBuilder: System.Linq.IQueryable`1[T] Run[T](Microsoft.FSharp.Quotations.FSharpExpr`1[Microsoft.FSharp.Linq.QuerySource`2[T,System.Linq.IQueryable]])
+Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] AverageByNullable$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TValue]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
+Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] AverageByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
+Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] MaxByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
+Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] MinByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
+Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] SumByNullable$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
+Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] SumByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
+Microsoft.FSharp.Linq.QueryBuilder: T ExactlyOneOrDefault[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: T ExactlyOne[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: T Find[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
+Microsoft.FSharp.Linq.QueryBuilder: T HeadOrDefault[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: T Head[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: T LastOrDefault[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: T Last[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: T Nth[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Int32)
+Microsoft.FSharp.Linq.QueryBuilder: TValue AverageBy$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TValue]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
+Microsoft.FSharp.Linq.QueryBuilder: TValue AverageBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
+Microsoft.FSharp.Linq.QueryBuilder: TValue MaxBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
+Microsoft.FSharp.Linq.QueryBuilder: TValue MinBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
+Microsoft.FSharp.Linq.QueryBuilder: TValue SumBy$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
+Microsoft.FSharp.Linq.QueryBuilder: TValue SumBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
+Microsoft.FSharp.Linq.QueryBuilder: Void .ctor()
+Microsoft.FSharp.Linq.QueryRunExtensions.HighPriority: System.Collections.Generic.IEnumerable`1[T] RunQueryAsEnumerable[T](Microsoft.FSharp.Linq.QueryBuilder, Microsoft.FSharp.Quotations.FSharpExpr`1[Microsoft.FSharp.Linq.QuerySource`2[T,System.Collections.IEnumerable]])
+Microsoft.FSharp.Linq.QueryRunExtensions.LowPriority: T RunQueryAsValue[T](Microsoft.FSharp.Linq.QueryBuilder, Microsoft.FSharp.Quotations.FSharpExpr`1[T])
+Microsoft.FSharp.Linq.QuerySource`2[T,Q]: System.Collections.Generic.IEnumerable`1[T] Source
+Microsoft.FSharp.Linq.QuerySource`2[T,Q]: System.Collections.Generic.IEnumerable`1[T] get_Source()
+Microsoft.FSharp.Linq.QuerySource`2[T,Q]: Void .ctor(System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`1[T1]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`1[T1]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`1[T1]: Void .ctor(T1)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: Void .ctor(T1, T2)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T3 Item3
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T3 get_Item3()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: Void .ctor(T1, T2, T3)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T3 Item3
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T3 get_Item3()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T4 Item4
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T4 get_Item4()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: Void .ctor(T1, T2, T3, T4)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T3 Item3
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T3 get_Item3()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T4 Item4
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T4 get_Item4()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T5 Item5
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T5 get_Item5()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: Void .ctor(T1, T2, T3, T4, T5)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T3 Item3
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T3 get_Item3()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T4 Item4
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T4 get_Item4()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T5 Item5
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T5 get_Item5()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T6 Item6
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T6 get_Item6()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: Void .ctor(T1, T2, T3, T4, T5, T6)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T3 Item3
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T3 get_Item3()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T4 Item4
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T4 get_Item4()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T5 Item5
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T5 get_Item5()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T6 Item6
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T6 get_Item6()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T7 Item7
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T7 get_Item7()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: Void .ctor(T1, T2, T3, T4, T5, T6, T7)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T3 Item3
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T3 get_Item3()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T4 Item4
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T4 get_Item4()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T5 Item5
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T5 get_Item5()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T6 Item6
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T6 get_Item6()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T7 Item7
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T7 get_Item7()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T8 Item8
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T8 get_Item8()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: Void .ctor(T1, T2, T3, T4, T5, T6, T7, T8)
+Microsoft.FSharp.Linq.RuntimeHelpers.Grouping`2[K,T]: Void .ctor(K, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: Microsoft.FSharp.Quotations.FSharpExpr SubstHelperRaw(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar[], System.Object[])
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: Microsoft.FSharp.Quotations.FSharpExpr`1[T] SubstHelper[T](Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar[], System.Object[])
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Linq.Expressions.Expression QuotationToExpression(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Linq.Expressions.Expression`1[T] ImplicitExpressionConversionHelper[T](T)
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Linq.Expressions.Expression`1[T] QuotationToLambdaExpression[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T])
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Object EvaluateQuotation(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: T MemberInitializationHelper[T](T)
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: T NewAnonymousObjectHelper[T](T)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Boolean IsNullPointer[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr AddPointerInlined[T](IntPtr, Int32)
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr NullPointer[T]()
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr OfILSigPtrInlined[T](T*)
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr OfNativeIntInlined[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr OfVoidPtrInlined[T](Void*)
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr StackAllocate[T](Int32)
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr ToNativeIntInlined[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: T GetPointerInlined[T](IntPtr, Int32)
+Microsoft.FSharp.NativeInterop.NativePtrModule: T ReadPointerInlined[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: T& ToByRefInlined[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: T* ToILSigPtrInlined[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void ClearPointerInlined[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void CopyBlockInlined[T](IntPtr, IntPtr, Int32)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void CopyPointerInlined[T](IntPtr, IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void InitializeBlockInlined[T](IntPtr, Byte, UInt32)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void SetPointerInlined[T](IntPtr, Int32, T)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void WritePointerInlined[T](IntPtr, T)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void* ToVoidPtrInlined[T](IntPtr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],Microsoft.FSharp.Collections.FSharpList`1[System.Type],Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]]] SpecificCallPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] UnitPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] MethodWithReflectedDefinitionPattern(System.Reflection.MethodBase)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] PropertyGetterWithReflectedDefinitionPattern(System.Reflection.PropertyInfo)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] PropertySetterWithReflectedDefinitionPattern(System.Reflection.PropertyInfo)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Boolean] BoolPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Byte] BytePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Char] CharPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Decimal] DecimalPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Double] DoublePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int16] Int16Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] Int32Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int64] Int64Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.SByte] SBytePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Single] SinglePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.String] StringPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpVar]],Microsoft.FSharp.Quotations.FSharpExpr]] LambdasPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]]] ApplicationsPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] AndAlsoPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] OrElsePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.UInt16] UInt16Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.UInt32] UInt32Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.UInt64] UInt64Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.ExprShapeModule: Microsoft.FSharp.Core.FSharpChoice`3[Microsoft.FSharp.Quotations.FSharpVar,System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr],System.Tuple`2[System.Object,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] ShapePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.ExprShapeModule: Microsoft.FSharp.Quotations.FSharpExpr RebuildShapeCombination(System.Object, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Boolean Equals(System.Object)
+Microsoft.FSharp.Quotations.FSharpExpr: Int32 GetHashCode()
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr] CustomAttributes
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr] get_CustomAttributes()
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] TryGetReflectedDefinition(System.Reflection.MethodBase)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr AddressOf(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr AddressSet(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Application(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Applications(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Call(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Call(System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr CallWithWitnesses(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.MethodInfo, System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr], Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr CallWithWitnesses(System.Reflection.MethodInfo, System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr], Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Coerce(Microsoft.FSharp.Quotations.FSharpExpr, System.Type)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr DefaultValue(System.Type)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Deserialize(System.Type, Microsoft.FSharp.Collections.FSharpList`1[System.Type], Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr], Byte[])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Deserialize40(System.Type, System.Type[], System.Type[], Microsoft.FSharp.Quotations.FSharpExpr[], Byte[])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldGet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.FieldInfo)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldGet(System.Reflection.FieldInfo)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldSet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.FieldInfo, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldSet(System.Reflection.FieldInfo, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr ForIntegerRangeLoop(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr IfThenElse(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Lambda(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Let(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr LetRecursive(Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]], Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewArray(System.Type, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewDelegate(System.Type, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpVar], Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewObject(System.Reflection.ConstructorInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewRecord(System.Type, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewStructTuple(System.Reflection.Assembly, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewTuple(Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewUnionCase(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertyGet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.PropertyInfo, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertyGet(System.Reflection.PropertyInfo, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertySet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.PropertyInfo, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertySet(System.Reflection.PropertyInfo, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Quote(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr QuoteRaw(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr QuoteTyped(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Sequential(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Substitute(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr]])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TryFinally(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TryWith(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TupleGet(Microsoft.FSharp.Quotations.FSharpExpr, Int32)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TypeTest(Microsoft.FSharp.Quotations.FSharpExpr, System.Type)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr UnionCaseTest(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Reflection.UnionCaseInfo)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Value(System.Object, System.Type)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr ValueWithName(System.Object, System.Type, System.String)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr ValueWithName[T](T, System.String)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Value[T](T)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Var(Microsoft.FSharp.Quotations.FSharpVar)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr VarSet(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr WhileLoop(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr WithValue(System.Object, System.Type, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr`1[T] Cast[T](Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr`1[T] GlobalVar[T](System.String)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr`1[T] WithValue[T](T, Microsoft.FSharp.Quotations.FSharpExpr`1[T])
+Microsoft.FSharp.Quotations.FSharpExpr: System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Quotations.FSharpVar] GetFreeVars()
+Microsoft.FSharp.Quotations.FSharpExpr: System.String ToString()
+Microsoft.FSharp.Quotations.FSharpExpr: System.String ToString(Boolean)
+Microsoft.FSharp.Quotations.FSharpExpr: System.Type Type
+Microsoft.FSharp.Quotations.FSharpExpr: System.Type get_Type()
+Microsoft.FSharp.Quotations.FSharpExpr: Void RegisterReflectedDefinitions(System.Reflection.Assembly, System.String, Byte[])
+Microsoft.FSharp.Quotations.FSharpExpr: Void RegisterReflectedDefinitions(System.Reflection.Assembly, System.String, Byte[], System.Type[])
+Microsoft.FSharp.Quotations.FSharpExpr`1[T]: Microsoft.FSharp.Quotations.FSharpExpr Raw
+Microsoft.FSharp.Quotations.FSharpExpr`1[T]: Microsoft.FSharp.Quotations.FSharpExpr get_Raw()
+Microsoft.FSharp.Quotations.FSharpVar: Boolean Equals(System.Object)
+Microsoft.FSharp.Quotations.FSharpVar: Boolean IsMutable
+Microsoft.FSharp.Quotations.FSharpVar: Boolean get_IsMutable()
+Microsoft.FSharp.Quotations.FSharpVar: Int32 GetHashCode()
+Microsoft.FSharp.Quotations.FSharpVar: Microsoft.FSharp.Quotations.FSharpVar Global(System.String, System.Type)
+Microsoft.FSharp.Quotations.FSharpVar: System.String Name
+Microsoft.FSharp.Quotations.FSharpVar: System.String ToString()
+Microsoft.FSharp.Quotations.FSharpVar: System.String get_Name()
+Microsoft.FSharp.Quotations.FSharpVar: System.Type Type
+Microsoft.FSharp.Quotations.FSharpVar: System.Type get_Type()
+Microsoft.FSharp.Quotations.FSharpVar: Void .ctor(System.String, System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]] NewStructTuplePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]] NewTuplePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] AddressOfPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] QuotePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] QuoteRawPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] QuoteTypedPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpVar] VarPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]],Microsoft.FSharp.Quotations.FSharpExpr]] LetRecursivePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.FieldInfo]] FieldGetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] AddressSetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] ApplicationPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] SequentialPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] TryFinallyPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] WhileLoopPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Reflection.UnionCaseInfo]] UnionCaseTestPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,System.Int32]] TupleGetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,System.Type]] CoercePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,System.Type]] TypeTestPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]] LambdaPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]] VarSetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Reflection.UnionCaseInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewUnionCasePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Object,System.Type]] ValuePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Reflection.ConstructorInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewObjectPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Type,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewArrayPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Type,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewRecordPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.FieldInfo,Microsoft.FSharp.Quotations.FSharpExpr]] FieldSetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.MethodInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] CallPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.PropertyInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] PropertyGetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] IfThenElsePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] LetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Object,System.Type,Microsoft.FSharp.Quotations.FSharpExpr]] WithValuePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Object,System.Type,System.String]] ValueWithNamePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Type,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpVar],Microsoft.FSharp.Quotations.FSharpExpr]] NewDelegatePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`4[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.PropertyInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr],Microsoft.FSharp.Quotations.FSharpExpr]] PropertySetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`4[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] ForIntegerRangeLoopPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`5[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.MethodInfo,System.Reflection.MethodInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr],Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] CallWithWitnessesPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`5[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]] TryWithPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Type] DefaultValuePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Boolean FSharpType.IsExceptionRepresentation.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Boolean FSharpType.IsRecord.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Boolean FSharpType.IsUnion.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Int32] FSharpValue.PreComputeUnionTagReader.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] FSharpValue.PreComputeRecordReader.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] FSharpValue.PreComputeUnionReader.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] FSharpValue.PreComputeRecordConstructor.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] FSharpValue.PreComputeUnionConstructor.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Reflection.UnionCaseInfo[] FSharpType.GetUnionCases.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object FSharpValue.MakeRecord.Static(System.Type, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object FSharpValue.MakeUnion.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object[] FSharpValue.GetExceptionFields.Static(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object[] FSharpValue.GetRecordFields.Static(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.ConstructorInfo FSharpValue.PreComputeRecordConstructorInfo.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.MemberInfo FSharpValue.PreComputeUnionTagMemberInfo.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.MethodInfo FSharpValue.PreComputeUnionConstructorInfo.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.PropertyInfo[] FSharpType.GetExceptionFields.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.PropertyInfo[] FSharpType.GetRecordFields.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Tuple`2[Microsoft.FSharp.Reflection.UnionCaseInfo,System.Object[]] FSharpValue.GetUnionFields.Static(System.Object, System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpType: Boolean IsExceptionRepresentation(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpType: Boolean IsFunction(System.Type)
+Microsoft.FSharp.Reflection.FSharpType: Boolean IsModule(System.Type)
+Microsoft.FSharp.Reflection.FSharpType: Boolean IsRecord(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpType: Boolean IsTuple(System.Type)
+Microsoft.FSharp.Reflection.FSharpType: Boolean IsUnion(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpType: Microsoft.FSharp.Reflection.UnionCaseInfo[] GetUnionCases(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpType: System.Reflection.PropertyInfo[] GetExceptionFields(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpType: System.Reflection.PropertyInfo[] GetRecordFields(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpType: System.Tuple`2[System.Type,System.Type] GetFunctionElements(System.Type)
+Microsoft.FSharp.Reflection.FSharpType: System.Type MakeFunctionType(System.Type, System.Type)
+Microsoft.FSharp.Reflection.FSharpType: System.Type MakeStructTupleType(System.Reflection.Assembly, System.Type[])
+Microsoft.FSharp.Reflection.FSharpType: System.Type MakeTupleType(System.Reflection.Assembly, System.Type[])
+Microsoft.FSharp.Reflection.FSharpType: System.Type MakeTupleType(System.Type[])
+Microsoft.FSharp.Reflection.FSharpType: System.Type[] GetTupleElements(System.Type)
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Int32] PreComputeUnionTagReader(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] PreComputeRecordReader(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] PreComputeTupleReader(System.Type)
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] PreComputeUnionReader(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object] PreComputeRecordFieldReader(System.Reflection.PropertyInfo)
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] PreComputeRecordConstructor(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] PreComputeTupleConstructor(System.Type)
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] PreComputeUnionConstructor(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Object GetRecordField(System.Object, System.Reflection.PropertyInfo)
+Microsoft.FSharp.Reflection.FSharpValue: System.Object GetTupleField(System.Object, Int32)
+Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeFunction(System.Type, Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object])
+Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeRecord(System.Type, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeTuple(System.Object[], System.Type)
+Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeUnion(Microsoft.FSharp.Reflection.UnionCaseInfo, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Object[] GetExceptionFields(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Object[] GetRecordFields(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Object[] GetTupleFields(System.Object)
+Microsoft.FSharp.Reflection.FSharpValue: System.Reflection.ConstructorInfo PreComputeRecordConstructorInfo(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Reflection.MemberInfo PreComputeUnionTagMemberInfo(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Reflection.MethodInfo PreComputeUnionConstructorInfo(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Tuple`2[Microsoft.FSharp.Reflection.UnionCaseInfo,System.Object[]] GetUnionFields(System.Object, System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Tuple`2[System.Reflection.ConstructorInfo,Microsoft.FSharp.Core.FSharpOption`1[System.Type]] PreComputeTupleConstructorInfo(System.Type)
+Microsoft.FSharp.Reflection.FSharpValue: System.Tuple`2[System.Reflection.PropertyInfo,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Type,System.Int32]]] PreComputeTuplePropertyInfo(System.Type, Int32)
+Microsoft.FSharp.Reflection.UnionCaseInfo: Boolean Equals(System.Object)
+Microsoft.FSharp.Reflection.UnionCaseInfo: Int32 GetHashCode()
+Microsoft.FSharp.Reflection.UnionCaseInfo: Int32 Tag
+Microsoft.FSharp.Reflection.UnionCaseInfo: Int32 get_Tag()
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Collections.Generic.IList`1[System.Reflection.CustomAttributeData] GetCustomAttributesData()
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Object[] GetCustomAttributes()
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Object[] GetCustomAttributes(System.Type)
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Reflection.PropertyInfo[] GetFields()
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.String Name
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.String ToString()
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.String get_Name()
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type DeclaringType
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type get_DeclaringType()
\ No newline at end of file
diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.release.bsl b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.release.bsl
new file mode 100644
index 00000000000..029951a590b
--- /dev/null
+++ b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.release.bsl
@@ -0,0 +1,2508 @@
+! AssemblyReference: System.Runtime.Numerics
+! AssemblyReference: netstandard
+Microsoft.FSharp.Collections.Array2DModule: Int32 Base1[T](T[,])
+Microsoft.FSharp.Collections.Array2DModule: Int32 Base2[T](T[,])
+Microsoft.FSharp.Collections.Array2DModule: Int32 Length1[T](T[,])
+Microsoft.FSharp.Collections.Array2DModule: Int32 Length2[T](T[,])
+Microsoft.FSharp.Collections.Array2DModule: T Get[T](T[,], Int32, Int32)
+Microsoft.FSharp.Collections.Array2DModule: TResult[,] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]]], T[,])
+Microsoft.FSharp.Collections.Array2DModule: TResult[,] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[,])
+Microsoft.FSharp.Collections.Array2DModule: T[,] Copy[T](T[,])
+Microsoft.FSharp.Collections.Array2DModule: T[,] CreateBased[T](Int32, Int32, Int32, Int32, T)
+Microsoft.FSharp.Collections.Array2DModule: T[,] Create[T](Int32, Int32, T)
+Microsoft.FSharp.Collections.Array2DModule: T[,] InitializeBased[T](Int32, Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]])
+Microsoft.FSharp.Collections.Array2DModule: T[,] Initialize[T](Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]])
+Microsoft.FSharp.Collections.Array2DModule: T[,] Rebase[T](T[,])
+Microsoft.FSharp.Collections.Array2DModule: T[,] ZeroCreateBased[T](Int32, Int32, Int32, Int32)
+Microsoft.FSharp.Collections.Array2DModule: T[,] ZeroCreate[T](Int32, Int32)
+Microsoft.FSharp.Collections.Array2DModule: Void CopyTo[T](T[,], Int32, Int32, T[,], Int32, Int32, Int32, Int32)
+Microsoft.FSharp.Collections.Array2DModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]]], T[,])
+Microsoft.FSharp.Collections.Array2DModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[,])
+Microsoft.FSharp.Collections.Array2DModule: Void Set[T](T[,], Int32, Int32, T)
+Microsoft.FSharp.Collections.Array3DModule: Int32 Length1[T](T[,,])
+Microsoft.FSharp.Collections.Array3DModule: Int32 Length2[T](T[,,])
+Microsoft.FSharp.Collections.Array3DModule: Int32 Length3[T](T[,,])
+Microsoft.FSharp.Collections.Array3DModule: T Get[T](T[,,], Int32, Int32, Int32)
+Microsoft.FSharp.Collections.Array3DModule: TResult[,,] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]]]], T[,,])
+Microsoft.FSharp.Collections.Array3DModule: TResult[,,] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[,,])
+Microsoft.FSharp.Collections.Array3DModule: T[,,] Create[T](Int32, Int32, Int32, T)
+Microsoft.FSharp.Collections.Array3DModule: T[,,] Initialize[T](Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]]])
+Microsoft.FSharp.Collections.Array3DModule: T[,,] ZeroCreate[T](Int32, Int32, Int32)
+Microsoft.FSharp.Collections.Array3DModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]]]], T[,,])
+Microsoft.FSharp.Collections.Array3DModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[,,])
+Microsoft.FSharp.Collections.Array3DModule: Void Set[T](T[,,], Int32, Int32, Int32, T)
+Microsoft.FSharp.Collections.Array4DModule: Int32 Length1[T](T[,,,])
+Microsoft.FSharp.Collections.Array4DModule: Int32 Length2[T](T[,,,])
+Microsoft.FSharp.Collections.Array4DModule: Int32 Length3[T](T[,,,])
+Microsoft.FSharp.Collections.Array4DModule: Int32 Length4[T](T[,,,])
+Microsoft.FSharp.Collections.Array4DModule: T Get[T](T[,,,], Int32, Int32, Int32, Int32)
+Microsoft.FSharp.Collections.Array4DModule: T[,,,] Create[T](Int32, Int32, Int32, Int32, T)
+Microsoft.FSharp.Collections.Array4DModule: T[,,,] Initialize[T](Int32, Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]]]])
+Microsoft.FSharp.Collections.Array4DModule: T[,,,] ZeroCreate[T](Int32, Int32, Int32, Int32)
+Microsoft.FSharp.Collections.Array4DModule: Void Set[T](T[,,,], Int32, Int32, Int32, Int32, T)
+Microsoft.FSharp.Collections.ArrayModule+Parallel: System.Tuple`2[T[],T[]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] Collect[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult[]], T[])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], T[])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: T[] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], T[])
+Microsoft.FSharp.Collections.ArrayModule+Parallel: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[])
+Microsoft.FSharp.Collections.ArrayModule: Boolean Contains[T](T, T[])
+Microsoft.FSharp.Collections.ArrayModule: Boolean Exists2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Boolean ForAll2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Boolean IsEmpty[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: Int32 CompareWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], T[], T[])
+Microsoft.FSharp.Collections.ArrayModule: Int32 FindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Int32 FindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Int32 Length[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Collections.ArrayModule+Parallel
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryExactlyOne[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryHead[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryItem[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryLast[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Collections.Generic.IEnumerable`1[T] ToSeq[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[System.Int32,T][] Indexed[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T,T][] Pairwise[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T1,T2][] AllPairs[T1,T2](T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T1,T2][] Zip[T1,T2](T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T1[],T2[]] Unzip[T1,T2](System.Tuple`2[T1,T2][])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TKey,System.Int32][] CountBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TKey,T[]][] GroupBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TResult[],TState] MapFoldBack[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,System.Tuple`2[TResult,TState]]], T[], TState)
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TResult[],TState] MapFold[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Tuple`2[TResult,TState]]], TState, T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T[],T[]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T[],T[]] SplitAt[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`3[T1,T2,T3][] Zip3[T1,T2,T3](T1[], T2[], T3[])
+Microsoft.FSharp.Collections.ArrayModule: System.Tuple`3[T1[],T2[],T3[]] Unzip3[T1,T2,T3](System.Tuple`3[T1,T2,T3][])
+Microsoft.FSharp.Collections.ArrayModule: T Average$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Average[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T ExactlyOne[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T FindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Find[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Get[T](T[], Int32)
+Microsoft.FSharp.Collections.ArrayModule: T Head[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T Item[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T Last[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T MaxBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Max[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T MinBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Min[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T ReduceBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Reduce[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Sum$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[])
+Microsoft.FSharp.Collections.ArrayModule: T Sum[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult AverageBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult AverageBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult Pick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult SumBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult SumBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] Collect[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult[]], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], T1[], T2[], T3[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] MapIndexed2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]]], T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], T[])
+Microsoft.FSharp.Collections.ArrayModule: TResult[] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
+Microsoft.FSharp.Collections.ArrayModule: TState Fold2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TState]]], TState, T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: TState FoldBack2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], T1[], T2[], TState)
+Microsoft.FSharp.Collections.ArrayModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], T[], TState)
+Microsoft.FSharp.Collections.ArrayModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, T[])
+Microsoft.FSharp.Collections.ArrayModule: TState[] ScanBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], T[], TState)
+Microsoft.FSharp.Collections.ArrayModule: TState[] Scan[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Append[T](T[], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Concat[T](System.Collections.Generic.IEnumerable`1[T[]])
+Microsoft.FSharp.Collections.ArrayModule: T[] Copy[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Create[T](Int32, T)
+Microsoft.FSharp.Collections.ArrayModule: T[] DistinctBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Distinct[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Empty[T]()
+Microsoft.FSharp.Collections.ArrayModule: T[] Except[T](System.Collections.Generic.IEnumerable`1[T], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] GetSubArray[T](T[], Int32, Int32)
+Microsoft.FSharp.Collections.ArrayModule: T[] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T])
+Microsoft.FSharp.Collections.ArrayModule: T[] InsertAt[T](Int32, T, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] InsertManyAt[T](Int32, System.Collections.Generic.IEnumerable`1[T], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] OfList[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ArrayModule: T[] OfSeq[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.ArrayModule: T[] Permute[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.Int32], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] RemoveAt[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] RemoveManyAt[T](Int32, Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Replicate[T](Int32, T)
+Microsoft.FSharp.Collections.ArrayModule: T[] Reverse[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Singleton[T](T)
+Microsoft.FSharp.Collections.ArrayModule: T[] SkipWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Skip[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] SortByDescending[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] SortBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] SortDescending[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] SortWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Sort[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Tail[T](T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] TakeWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Take[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Truncate[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Unfold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[T,TState]]], TState)
+Microsoft.FSharp.Collections.ArrayModule: T[] UpdateAt[T](Int32, T, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] Where[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
+Microsoft.FSharp.Collections.ArrayModule: T[] ZeroCreate[T](Int32)
+Microsoft.FSharp.Collections.ArrayModule: T[][] ChunkBySize[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[][] SplitInto[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: T[][] Transpose[T](System.Collections.Generic.IEnumerable`1[T[]])
+Microsoft.FSharp.Collections.ArrayModule: T[][] Windowed[T](Int32, T[])
+Microsoft.FSharp.Collections.ArrayModule: Void CopyTo[T](T[], Int32, T[], Int32, Int32)
+Microsoft.FSharp.Collections.ArrayModule: Void Fill[T](T[], Int32, Int32, T)
+Microsoft.FSharp.Collections.ArrayModule: Void Iterate2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]], T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: Void IterateIndexed2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]]], T1[], T2[])
+Microsoft.FSharp.Collections.ArrayModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], T[])
+Microsoft.FSharp.Collections.ArrayModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[])
+Microsoft.FSharp.Collections.ArrayModule: Void Set[T](T[], Int32, T)
+Microsoft.FSharp.Collections.ArrayModule: Void SortInPlaceBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
+Microsoft.FSharp.Collections.ArrayModule: Void SortInPlaceWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], T[])
+Microsoft.FSharp.Collections.ArrayModule: Void SortInPlace[T](T[])
+Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] FromFunction[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]])
+Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] NonStructural$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]])
+Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] NonStructural[T]()
+Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] Structural[T]()
+Microsoft.FSharp.Collections.FSharpList`1+Tags[T]: Int32 Cons
+Microsoft.FSharp.Collections.FSharpList`1+Tags[T]: Int32 Empty
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean Equals(Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean Equals(System.Object)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean IsCons
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean IsEmpty
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean get_IsCons()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean get_IsEmpty()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 CompareTo(Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 GetHashCode()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 GetReverseIndex(Int32, Int32)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 Length
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 Tag
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 get_Length()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 get_Tag()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1+Tags[T]
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Cons(T, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Empty
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] GetSlice(Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Tail
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] TailOrNull
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] get_Empty()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] get_Tail()
+Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] get_TailOrNull()
+Microsoft.FSharp.Collections.FSharpList`1[T]: System.String ToString()
+Microsoft.FSharp.Collections.FSharpList`1[T]: T Head
+Microsoft.FSharp.Collections.FSharpList`1[T]: T HeadOrDefault
+Microsoft.FSharp.Collections.FSharpList`1[T]: T Item [Int32]
+Microsoft.FSharp.Collections.FSharpList`1[T]: T get_Head()
+Microsoft.FSharp.Collections.FSharpList`1[T]: T get_HeadOrDefault()
+Microsoft.FSharp.Collections.FSharpList`1[T]: T get_Item(Int32)
+Microsoft.FSharp.Collections.FSharpList`1[T]: Void .ctor(T, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean ContainsKey(TKey)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean Equals(System.Object)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean IsEmpty
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean TryGetValue(TKey, TValue ByRef)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean get_IsEmpty()
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Int32 Count
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Int32 GetHashCode()
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Int32 get_Count()
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Add(TKey, TValue)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Change(TKey, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpOption`1[TValue],Microsoft.FSharp.Core.FSharpOption`1[TValue]])
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Remove(TKey)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Core.FSharpOption`1[TValue] TryFind(TKey)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TKey] Keys
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TKey] get_Keys()
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TValue] Values
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TValue] get_Values()
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.String ToString()
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: TValue Item [TKey]
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: TValue get_Item(TKey)
+Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Void .ctor(System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,TValue]])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean Contains(T)
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean Equals(System.Object)
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsEmpty
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsProperSubsetOf(Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsProperSupersetOf(Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsSubsetOf(Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsSupersetOf(Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean get_IsEmpty()
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Int32 Count
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Int32 GetHashCode()
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Int32 get_Count()
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] Add(T)
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] Remove(T)
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] op_Addition(Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] op_Subtraction(Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.FSharpSet`1[T]: System.String ToString()
+Microsoft.FSharp.Collections.FSharpSet`1[T]: T MaximumElement
+Microsoft.FSharp.Collections.FSharpSet`1[T]: T MinimumElement
+Microsoft.FSharp.Collections.FSharpSet`1[T]: T get_MaximumElement()
+Microsoft.FSharp.Collections.FSharpSet`1[T]: T get_MinimumElement()
+Microsoft.FSharp.Collections.FSharpSet`1[T]: Void .ctor(System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] FromFunctions[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]])
+Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] LimitedStructural[T](Int32)
+Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] NonStructural$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]])
+Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] NonStructural[T]()
+Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] Reference[T]()
+Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] Structural[T]()
+Microsoft.FSharp.Collections.ListModule: Boolean Contains[T](T, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Boolean Exists2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Boolean ForAll2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Boolean IsEmpty[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Int32 CompareWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], Microsoft.FSharp.Collections.FSharpList`1[T], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Int32 FindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Int32 FindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Int32 Length[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] ChunkBySize[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] SplitInto[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] Transpose[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpList`1[T]])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] Windowed[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[System.Int32,T]] Indexed[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T,T]] Pairwise[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T1,T2]] AllPairs[T1,T2](Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T1,T2]] Zip[T1,T2](Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,Microsoft.FSharp.Collections.FSharpList`1[T]]] GroupBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,System.Int32]] CountBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[T1,T2,T3]] Zip3[T1,T2,T3](Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2], Microsoft.FSharp.Collections.FSharpList`1[T3])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Collect[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Collections.FSharpList`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2], Microsoft.FSharp.Collections.FSharpList`1[T3])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] MapIndexed2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TState] ScanBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Collections.FSharpList`1[T], TState)
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TState] Scan[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Append[T](Microsoft.FSharp.Collections.FSharpList`1[T], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Concat[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpList`1[T]])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] DistinctBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Distinct[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Empty[T]()
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Except[T](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] InsertAt[T](Int32, T, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] InsertManyAt[T](Int32, System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] OfArray[T](T[])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] OfSeq[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Permute[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.Int32], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RemoveAt[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RemoveManyAt[T](Int32, Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Replicate[T](Int32, T)
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Reverse[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Singleton[T](T)
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SkipWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Skip[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortByDescending[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortDescending[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Sort[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Tail[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] TakeWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Take[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Truncate[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Unfold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[T,TState]]], TState)
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] UpdateAt[T](Int32, T, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Where[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryExactlyOne[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryHead[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryItem[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryLast[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: System.Collections.Generic.IEnumerable`1[T] ToSeq[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[T1],Microsoft.FSharp.Collections.FSharpList`1[T2]] Unzip[T1,T2](Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T1,T2]])
+Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[TResult],TState] MapFoldBack[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,System.Tuple`2[TResult,TState]]], Microsoft.FSharp.Collections.FSharpList`1[T], TState)
+Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[TResult],TState] MapFold[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Tuple`2[TResult,TState]]], TState, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[T],Microsoft.FSharp.Collections.FSharpList`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[T],Microsoft.FSharp.Collections.FSharpList`1[T]] SplitAt[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: System.Tuple`3[Microsoft.FSharp.Collections.FSharpList`1[T1],Microsoft.FSharp.Collections.FSharpList`1[T2],Microsoft.FSharp.Collections.FSharpList`1[T3]] Unzip3[T1,T2,T3](Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[T1,T2,T3]])
+Microsoft.FSharp.Collections.ListModule: T Average$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Average[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T ExactlyOne[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T FindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Find[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Get[T](Microsoft.FSharp.Collections.FSharpList`1[T], Int32)
+Microsoft.FSharp.Collections.ListModule: T Head[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Item[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Last[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T MaxBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Max[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T MinBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Min[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T ReduceBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Reduce[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Sum$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T Sum[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: TResult AverageBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: TResult AverageBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: TResult Pick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: TResult SumBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: TResult SumBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: TState Fold2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TState]]], TState, Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: TState FoldBack2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2], TState)
+Microsoft.FSharp.Collections.ListModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Collections.FSharpList`1[T], TState)
+Microsoft.FSharp.Collections.ListModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: T[] ToArray[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Void Iterate2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Void IterateIndexed2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
+Microsoft.FSharp.Collections.ListModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.ListModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.MapModule: Boolean ContainsKey[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Boolean Exists[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Boolean ForAll[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Boolean IsEmpty[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Int32 Count[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,T]] ToList[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TResult] Map[TKey,T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Add[TKey,T](TKey, T, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Change[TKey,T](TKey, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpOption`1[T],Microsoft.FSharp.Core.FSharpOption`1[T]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Empty[TKey,T]()
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Filter[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] OfArray[TKey,T](System.Tuple`2[TKey,T][])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] OfList[TKey,T](Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,T]])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] OfSeq[TKey,T](System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,T]])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Remove[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Core.FSharpOption`1[TKey] TryFindKey[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[TKey,T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Collections.Generic.ICollection`1[TKey] Keys[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Collections.Generic.ICollection`1[T] Values[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,T]] ToSeq[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpMap`2[TKey,T],Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]] Partition[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Tuple`2[TKey,T] MaxKeyValue[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Tuple`2[TKey,T] MinKeyValue[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: System.Tuple`2[TKey,T][] ToArray[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: T Find[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: TKey FindKey[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: TResult Pick[TKey,T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: TState FoldBack[TKey,T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T], TState)
+Microsoft.FSharp.Collections.MapModule: TState Fold[TKey,T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]]], TState, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.MapModule: Void Iterate[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
+Microsoft.FSharp.Collections.SeqModule: Boolean Contains[T](T, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Boolean Exists2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Boolean ForAll2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Boolean IsEmpty[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Int32 CompareWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Int32 FindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Int32 FindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Int32 Length[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryExactlyOne[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryHead[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryItem[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryLast[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Collections.Generic.IEnumerable`1[T]] Transpose[TCollection,T](System.Collections.Generic.IEnumerable`1[TCollection])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[System.Int32,T]] Indexed[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[T,T]] Pairwise[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[T1,T2]] AllPairs[T1,T2](System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[T1,T2]] Zip[T1,T2](System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,System.Collections.Generic.IEnumerable`1[T]]] GroupBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,System.Int32]] CountBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`3[T1,T2,T3]] Zip3[T1,T2,T3](System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2], System.Collections.Generic.IEnumerable`1[T3])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Collect[T,TCollection,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TCollection], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2], System.Collections.Generic.IEnumerable`1[T3])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] MapIndexed2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TState] ScanBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], System.Collections.Generic.IEnumerable`1[T], TState)
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TState] Scan[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T[]] ChunkBySize[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T[]] SplitInto[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T[]] Windowed[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Append[T](System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Cache[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Cast[T](System.Collections.IEnumerable)
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Concat[TCollection,T](System.Collections.Generic.IEnumerable`1[TCollection])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Delay[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Collections.Generic.IEnumerable`1[T]])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] DistinctBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Distinct[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Empty[T]()
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Except[T](System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] InitializeInfinite[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] InsertAt[T](Int32, T, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] InsertManyAt[T](Int32, System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] OfArray[T](T[])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] OfList[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Permute[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.Int32], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] ReadOnly[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RemoveAt[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RemoveManyAt[T](Int32, Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Replicate[T](Int32, T)
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Reverse[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Singleton[T](T)
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SkipWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Skip[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortByDescending[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortDescending[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Sort[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Tail[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] TakeWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Take[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Truncate[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Unfold[TState,T](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[T,TState]]], TState)
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] UpdateAt[T](Int32, T, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Where[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: System.Tuple`2[System.Collections.Generic.IEnumerable`1[TResult],TState] MapFoldBack[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,System.Tuple`2[TResult,TState]]], System.Collections.Generic.IEnumerable`1[T], TState)
+Microsoft.FSharp.Collections.SeqModule: System.Tuple`2[System.Collections.Generic.IEnumerable`1[TResult],TState] MapFold[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Tuple`2[TResult,TState]]], TState, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Average$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Average[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T ExactlyOne[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T FindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Find[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Get[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Head[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Item[T](Int32, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Last[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T MaxBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Max[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T MinBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Min[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T ReduceBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Reduce[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Sum$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T Sum[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: TResult AverageBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: TResult AverageBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: TResult Pick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: TResult SumBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: TResult SumBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: TState Fold2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TState]]], TState, System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: TState FoldBack2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2], TState)
+Microsoft.FSharp.Collections.SeqModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], System.Collections.Generic.IEnumerable`1[T], TState)
+Microsoft.FSharp.Collections.SeqModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: T[] ToArray[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Void Iterate2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: Void IterateIndexed2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
+Microsoft.FSharp.Collections.SeqModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SeqModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean Contains[T](T, Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean IsEmpty[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean IsProperSubset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean IsProperSuperset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean IsSubset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Boolean IsSuperset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Int32 Count[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Add[T](T, Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Difference[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Empty[T]()
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] IntersectMany[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpSet`1[T]])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Intersect[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] OfArray[T](T[])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] OfList[T](Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] OfSeq[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Remove[T](T, Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Singleton[T](T)
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] UnionMany[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpSet`1[T]])
+Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Union[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: System.Collections.Generic.IEnumerable`1[T] ToSeq[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpSet`1[T],Microsoft.FSharp.Collections.FSharpSet`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: T MaxElement[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: T MinElement[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Collections.FSharpSet`1[T], TState)
+Microsoft.FSharp.Collections.SetModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: T[] ToArray[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Boolean IsCancellationRequested
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Boolean get_IsCancellationRequested()
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn OnCancellation()
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn OnSuccess(T)
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn Success(Microsoft.FSharp.Control.AsyncActivation`1[T], T)
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Void OnExceptionRaised()
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn Bind[T,TResult](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn CallThenInvoke[T,TResult](Microsoft.FSharp.Control.AsyncActivation`1[T], TResult, Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn Invoke[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Control.AsyncActivation`1[T])
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn TryFinally[T](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn TryWith[T](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]])
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.FSharpAsync`1[T] MakeAsync[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.AsyncActivation`1[T],Microsoft.FSharp.Control.AsyncReturn])
+Microsoft.FSharp.Control.BackgroundTaskBuilder: System.Threading.Tasks.Task`1[T] RunDynamic[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
+Microsoft.FSharp.Control.BackgroundTaskBuilder: System.Threading.Tasks.Task`1[T] Run[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
+Microsoft.FSharp.Control.CommonExtensions: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AsyncWrite(System.IO.Stream, Byte[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.CommonExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Byte[]] AsyncReadBytes(System.IO.Stream, Int32)
+Microsoft.FSharp.Control.CommonExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Int32] AsyncRead(System.IO.Stream, Byte[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.CommonExtensions: System.IDisposable SubscribeToObservable[T](System.IObservable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.CommonExtensions: Void AddToObservable[T](System.IObservable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[System.Tuple`2[T,T]],System.Tuple`2[T,T]] Pairwise[TDel,T](Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult],TResult] Choose[T,TResult,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult],TResult] Map[T,TResult,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult],TResult] Scan[TResult,T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], TResult, Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] Filter[T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] Merge[TDel1,T,TDel2](Microsoft.FSharp.Control.IEvent`2[TDel1,T], Microsoft.FSharp.Control.IEvent`2[TDel2,T])
+Microsoft.FSharp.Control.EventModule: System.Tuple`2[Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult1],TResult1],Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult2],TResult2]] Split[T,TResult1,TResult2,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[TResult1,TResult2]], Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: System.Tuple`2[Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T],Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T]] Partition[T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.EventModule: Void Add[T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Control.IEvent`2[TDel,T])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Control.FSharpAsync`1[T]] StartChild[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpChoice`2[T,System.Exception]] Catch[T](Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[T]] Choice[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[T]]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AwaitTask(System.Threading.Tasks.Task)
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Ignore[T](Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Sleep(Int32)
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Sleep(System.TimeSpan)
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] SwitchToContext(System.Threading.SynchronizationContext)
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] SwitchToNewThread()
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] SwitchToThreadPool()
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Boolean] AwaitIAsyncResult(System.IAsyncResult, Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Boolean] AwaitWaitHandle(System.Threading.WaitHandle, Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.IDisposable] OnCancel(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Threading.CancellationToken] CancellationToken
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Threading.CancellationToken] get_CancellationToken()
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Threading.Tasks.Task`1[T]] StartChildAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.Tasks.TaskCreationOptions])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Parallel[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Parallel[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Sequential[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitEvent[TDel,T](Microsoft.FSharp.Control.IEvent`2[TDel,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitTask[T](System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,TArg2,TArg3,T](TArg1, TArg2, TArg3, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`5[TArg1,TArg2,TArg3,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,TArg2,T](TArg1, TArg2, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`4[TArg1,TArg2,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,T](TArg1, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[TArg1,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromContinuations[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit],Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.Unit],Microsoft.FSharp.Core.FSharpFunc`2[System.OperationCanceledException,Microsoft.FSharp.Core.Unit]],Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] TryCancelled[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.OperationCanceledException,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.FSharpAsync: System.Threading.CancellationToken DefaultCancellationToken
+Microsoft.FSharp.Control.FSharpAsync: System.Threading.CancellationToken get_DefaultCancellationToken()
+Microsoft.FSharp.Control.FSharpAsync: System.Threading.Tasks.Task`1[T] StartAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.Tasks.TaskCreationOptions], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsync: System.Threading.Tasks.Task`1[T] StartImmediateAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsync: System.Tuple`3[Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[TArg,System.AsyncCallback,System.Object],System.IAsyncResult],Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T],Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,Microsoft.FSharp.Core.Unit]] AsBeginEnd[TArg,T](Microsoft.FSharp.Core.FSharpFunc`2[TArg,Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.FSharpAsync: T RunSynchronously[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsync: Void CancelDefaultToken()
+Microsoft.FSharp.Control.FSharpAsync: Void Start(Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsync: Void StartImmediate(Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsync: Void StartWithContinuations[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[System.OperationCanceledException,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] For[T](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] While(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Zero()
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Bind[T,TResult](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[TResult]])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Using[T,TResult](T, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[TResult]])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] Combine[T](Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] Delay[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] ReturnFrom[T](Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] Return[T](T)
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] TryFinally[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] TryWith[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply]: Void Reply(TReply)
+Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate] Publish
+Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate] get_Publish()
+Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Void .ctor()
+Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Void Trigger(System.Object[])
+Microsoft.FSharp.Control.FSharpEvent`1[T]: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] Publish
+Microsoft.FSharp.Control.FSharpEvent`1[T]: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] get_Publish()
+Microsoft.FSharp.Control.FSharpEvent`1[T]: Void .ctor()
+Microsoft.FSharp.Control.FSharpEvent`1[T]: Void Trigger(T)
+Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Microsoft.FSharp.Control.IEvent`2[TDelegate,TArgs] Publish
+Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Microsoft.FSharp.Control.IEvent`2[TDelegate,TArgs] get_Publish()
+Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Void .ctor()
+Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Void Trigger(System.Object, TArgs)
+Microsoft.FSharp.Control.FSharpHandler`1[T]: System.IAsyncResult BeginInvoke(System.Object, T, System.AsyncCallback, System.Object)
+Microsoft.FSharp.Control.FSharpHandler`1[T]: Void .ctor(System.Object, IntPtr)
+Microsoft.FSharp.Control.FSharpHandler`1[T]: Void EndInvoke(System.IAsyncResult)
+Microsoft.FSharp.Control.FSharpHandler`1[T]: Void Invoke(System.Object, T)
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 CurrentQueueLength
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 DefaultTimeout
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 get_CurrentQueueLength()
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 get_DefaultTimeout()
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[TMsg]] TryReceive(Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[TReply]] PostAndTryAsyncReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[T]] TryScan[T](Microsoft.FSharp.Core.FSharpFunc`2[TMsg,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[TMsg] Receive(Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[TReply] PostAndAsyncReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[T] Scan[T](Microsoft.FSharp.Core.FSharpFunc`2[TMsg,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpHandler`1[System.Exception] Error
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg] Start(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg],Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Core.FSharpOption`1[TReply] TryPostAndReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: TReply PostAndReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void .ctor(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg],Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void Post(TMsg)
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void Start()
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void add_Error(Microsoft.FSharp.Control.FSharpHandler`1[System.Exception])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void remove_Error(Microsoft.FSharp.Control.FSharpHandler`1[System.Exception])
+Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void set_DefaultTimeout(Int32)
+Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate]: Void AddHandler(TDelegate)
+Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate]: Void RemoveHandler(TDelegate)
+Microsoft.FSharp.Control.LazyExtensions: System.Lazy`1[T] CreateFromValue[T](T)
+Microsoft.FSharp.Control.LazyExtensions: System.Lazy`1[T] Create[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T])
+Microsoft.FSharp.Control.LazyExtensions: T Force[T](System.Lazy`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IDisposable Subscribe[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[System.Tuple`2[T,T]] Pairwise[T](System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[TResult] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[TResult] Scan[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], TResult, System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[T] Merge[T](System.IObservable`1[T], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.Tuple`2[System.IObservable`1[TResult1],System.IObservable`1[TResult2]] Split[T,TResult1,TResult2](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[TResult1,TResult2]], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: System.Tuple`2[System.IObservable`1[T],System.IObservable`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.IObservable`1[T])
+Microsoft.FSharp.Control.ObservableModule: Void Add[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], System.IObservable`1[T])
+Microsoft.FSharp.Control.TaskBuilder: System.Threading.Tasks.Task`1[T] RunDynamic[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
+Microsoft.FSharp.Control.TaskBuilder: System.Threading.Tasks.Task`1[T] Run[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit] For[T,TOverall](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit] While[TOverall](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit] Zero[TOverall]()
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] Combine[TOverall,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] Delay[TOverall,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] TryFinally[TOverall,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] TryWith[TOverall,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] Using[TResource,TOverall,T](TResource, Microsoft.FSharp.Core.FSharpFunc`2[TResource,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]])
+Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] Return[T](T)
+Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority: Boolean TaskBuilderBase.BindDynamic.Static[TOverall,TResult1,TResult2](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall]] ByRef, System.Threading.Tasks.Task`1[TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind[TResult1,TOverall,TResult2](Microsoft.FSharp.Control.TaskBuilderBase, System.Threading.Tasks.Task`1[TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom[T](Microsoft.FSharp.Control.TaskBuilderBase, System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Boolean TaskBuilderBase.BindDynamic.Static$W[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike,TAwaiter], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall]] ByRef, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Boolean TaskBuilderBase.BindDynamic.Static[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall]] ByRef, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind$W[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike,TAwaiter], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,System.Boolean], Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] TaskBuilderBase.Using[TResource,TOverall,T](Microsoft.FSharp.Control.TaskBuilderBase, TResource, Microsoft.FSharp.Core.FSharpFunc`2[TResource,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom$W[TTaskLike,TAwaiter,T](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike,TAwaiter], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,T], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,System.Boolean], Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike)
+Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom[TTaskLike,TAwaiter,T](Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike)
+Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind[TResult1,TOverall,TResult2](Microsoft.FSharp.Control.TaskBuilderBase, Microsoft.FSharp.Control.FSharpAsync`1[TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
+Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom[T](Microsoft.FSharp.Control.TaskBuilderBase, Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.BackgroundTaskBuilder backgroundTask
+Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.BackgroundTaskBuilder get_backgroundTask()
+Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.TaskBuilder get_task()
+Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.TaskBuilder task
+Microsoft.FSharp.Control.TaskStateMachineData`1[T]: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1[T] MethodBuilder
+Microsoft.FSharp.Control.TaskStateMachineData`1[T]: T Result
+Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AsyncDownloadFile(System.Net.WebClient, System.Uri, System.String)
+Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Byte[]] AsyncDownloadData(System.Net.WebClient, System.Uri)
+Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Net.WebResponse] AsyncGetResponse(System.Net.WebRequest)
+Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.String] AsyncDownloadString(System.Net.WebClient, System.Uri)
+Microsoft.FSharp.Core.AbstractClassAttribute: Void .ctor()
+Microsoft.FSharp.Core.AllowNullLiteralAttribute: Boolean Value
+Microsoft.FSharp.Core.AllowNullLiteralAttribute: Boolean get_Value()
+Microsoft.FSharp.Core.AllowNullLiteralAttribute: Void .ctor()
+Microsoft.FSharp.Core.AllowNullLiteralAttribute: Void .ctor(Boolean)
+Microsoft.FSharp.Core.AutoOpenAttribute: System.String Path
+Microsoft.FSharp.Core.AutoOpenAttribute: System.String get_Path()
+Microsoft.FSharp.Core.AutoOpenAttribute: Void .ctor()
+Microsoft.FSharp.Core.AutoOpenAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.AutoSerializableAttribute: Boolean Value
+Microsoft.FSharp.Core.AutoSerializableAttribute: Boolean get_Value()
+Microsoft.FSharp.Core.AutoSerializableAttribute: Void .ctor(Boolean)
+Microsoft.FSharp.Core.ByRefKinds: Microsoft.FSharp.Core.ByRefKinds+In
+Microsoft.FSharp.Core.ByRefKinds: Microsoft.FSharp.Core.ByRefKinds+InOut
+Microsoft.FSharp.Core.ByRefKinds: Microsoft.FSharp.Core.ByRefKinds+Out
+Microsoft.FSharp.Core.CLIEventAttribute: Void .ctor()
+Microsoft.FSharp.Core.CLIMutableAttribute: Void .ctor()
+Microsoft.FSharp.Core.ClassAttribute: Void .ctor()
+Microsoft.FSharp.Core.ComparisonConditionalOnAttribute: Void .ctor()
+Microsoft.FSharp.Core.CompilationArgumentCountsAttribute: System.Collections.Generic.IEnumerable`1[System.Int32] Counts
+Microsoft.FSharp.Core.CompilationArgumentCountsAttribute: System.Collections.Generic.IEnumerable`1[System.Int32] get_Counts()
+Microsoft.FSharp.Core.CompilationArgumentCountsAttribute: Void .ctor(Int32[])
+Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 SequenceNumber
+Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 VariantNumber
+Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 get_SequenceNumber()
+Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 get_VariantNumber()
+Microsoft.FSharp.Core.CompilationMappingAttribute: Microsoft.FSharp.Core.SourceConstructFlags SourceConstructFlags
+Microsoft.FSharp.Core.CompilationMappingAttribute: Microsoft.FSharp.Core.SourceConstructFlags get_SourceConstructFlags()
+Microsoft.FSharp.Core.CompilationMappingAttribute: System.String ResourceName
+Microsoft.FSharp.Core.CompilationMappingAttribute: System.String get_ResourceName()
+Microsoft.FSharp.Core.CompilationMappingAttribute: System.Type[] TypeDefinitions
+Microsoft.FSharp.Core.CompilationMappingAttribute: System.Type[] get_TypeDefinitions()
+Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(Microsoft.FSharp.Core.SourceConstructFlags)
+Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(Microsoft.FSharp.Core.SourceConstructFlags, Int32)
+Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(Microsoft.FSharp.Core.SourceConstructFlags, Int32, Int32)
+Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(System.String, System.Type[])
+Microsoft.FSharp.Core.CompilationRepresentationAttribute: Microsoft.FSharp.Core.CompilationRepresentationFlags Flags
+Microsoft.FSharp.Core.CompilationRepresentationAttribute: Microsoft.FSharp.Core.CompilationRepresentationFlags get_Flags()
+Microsoft.FSharp.Core.CompilationRepresentationAttribute: Void .ctor(Microsoft.FSharp.Core.CompilationRepresentationFlags)
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Int32 value__
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags Event
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags Instance
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags ModuleSuffix
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags None
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags Static
+Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags UseNullAsTrueValue
+Microsoft.FSharp.Core.CompilationSourceNameAttribute: System.String SourceName
+Microsoft.FSharp.Core.CompilationSourceNameAttribute: System.String get_SourceName()
+Microsoft.FSharp.Core.CompilationSourceNameAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.CompiledNameAttribute: System.String CompiledName
+Microsoft.FSharp.Core.CompiledNameAttribute: System.String get_CompiledName()
+Microsoft.FSharp.Core.CompiledNameAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean IsError
+Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean IsHidden
+Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean get_IsError()
+Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean get_IsHidden()
+Microsoft.FSharp.Core.CompilerMessageAttribute: Int32 MessageNumber
+Microsoft.FSharp.Core.CompilerMessageAttribute: Int32 get_MessageNumber()
+Microsoft.FSharp.Core.CompilerMessageAttribute: System.String Message
+Microsoft.FSharp.Core.CompilerMessageAttribute: System.String get_Message()
+Microsoft.FSharp.Core.CompilerMessageAttribute: Void .ctor(System.String, Int32)
+Microsoft.FSharp.Core.CompilerMessageAttribute: Void set_IsError(Boolean)
+Microsoft.FSharp.Core.CompilerMessageAttribute: Void set_IsHidden(Boolean)
+Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object)
+Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: TResult EndInvoke(System.IAsyncResult)
+Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: TResult Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
+Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: Void .ctor(System.Object, IntPtr)
+Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: T[] AddManyAndClose(System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: T[] Close()
+Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: Void Add(T)
+Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: Void AddMany(System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Boolean CheckClose
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Boolean get_CheckClose()
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Int32 GenerateNext(System.Collections.Generic.IEnumerable`1[T] ByRef)
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: System.Collections.Generic.IEnumerator`1[T] GetFreshEnumerator()
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: T LastGenerated
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: T get_LastGenerated()
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Void .ctor()
+Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Void Close()
+Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace[] GetNestedNamespaces()
+Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.String NamespaceName
+Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.String get_NamespaceName()
+Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.Type ResolveTypeName(System.String)
+Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.Type[] GetTypes()
+Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: Int32 ResumptionPoint
+Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: Int32 get_ResumptionPoint()
+Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: TData Data
+Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: TData get_Data()
+Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: Void set_Data(TData)
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider2: System.Reflection.MethodBase ApplyStaticArgumentsForMethod(System.Reflection.MethodBase, System.String, System.Object[])
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider2: System.Reflection.ParameterInfo[] GetStaticParametersForMethod(System.Reflection.MethodBase)
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Byte[] GetGeneratedAssemblyContents(System.Reflection.Assembly)
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace[] GetNamespaces()
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Microsoft.FSharp.Quotations.FSharpExpr GetInvokerExpression(System.Reflection.MethodBase, Microsoft.FSharp.Quotations.FSharpExpr[])
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: System.EventHandler Invalidate
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: System.Reflection.ParameterInfo[] GetStaticParameters(System.Type)
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: System.Type ApplyStaticArguments(System.Type, System.String[], System.Object[])
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Void add_Invalidate(System.EventHandler)
+Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Void remove_Invalidate(System.EventHandler)
+Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] AddManyAndClose(System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Close()
+Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Void Add(T)
+Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Void AddMany(System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object)
+Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: Void .ctor(System.Object, IntPtr)
+Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: Void EndInvoke(System.IAsyncResult)
+Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: Void Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
+Microsoft.FSharp.Core.CompilerServices.NoEagerConstraintApplicationAttribute: Void .ctor()
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean CombineDynamic[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean TryFinallyAsyncDynamic[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean TryWithDynamic[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean WhileDynamic[TData](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean YieldDynamic[TData](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] For[T,TData](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit]])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] While[TData](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] Yield[TData]()
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] Zero[TData]()
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] Combine[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] Delay[TData,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] TryFinallyAsync[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] TryFinally[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] TryWith[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] Using[TResource,TData,T](TResource, Microsoft.FSharp.Core.FSharpFunc`2[TResource,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]])
+Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: Boolean EndInvoke(System.IAsyncResult)
+Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: Boolean Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
+Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object)
+Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: Void .ctor(System.Object, IntPtr)
+Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData]: Int32 ResumptionPoint
+Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData]: Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData] ResumptionDynamicInfo
+Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData]: TData Data
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData] ResumptionFunc
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData] get_ResumptionFunc()
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: System.Object ResumptionData
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: System.Object get_ResumptionData()
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void .ctor(Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData])
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void MoveNext(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void SetStateMachine(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine)
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void set_ResumptionData(System.Object)
+Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void set_ResumptionFunc(Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData])
+Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: Boolean EndInvoke(System.IAsyncResult)
+Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: Boolean Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
+Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object)
+Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: Void .ctor(System.Object, IntPtr)
+Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: Microsoft.FSharp.Control.IEvent`2[TDelegate,TArgs] CreateEvent[TDelegate,TArgs](Microsoft.FSharp.Core.FSharpFunc`2[TDelegate,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[TDelegate,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpFunc`2[System.Object,Microsoft.FSharp.Core.FSharpFunc`2[TArgs,Microsoft.FSharp.Core.Unit]],TDelegate])
+Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[TResult] EnumerateFromFunctions[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
+Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[TResult] EnumerateUsing[T,TCollection,TResult](T, Microsoft.FSharp.Core.FSharpFunc`2[T,TCollection])
+Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[T] EnumerateThenFinally[T](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[T] EnumerateWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine, System.AsyncCallback, System.Object)
+Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void .ctor(System.Object, IntPtr)
+Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void EndInvoke(System.IAsyncResult)
+Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine)
+Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Boolean __useResumableCode[T]()
+Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] __resumableEntry()
+Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: T __resumeAt[T](Int32)
+Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: TResult __stateMachine[TData,TResult](Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult])
+Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Void __debugPoint(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: System.String AssemblyName
+Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: System.String get_AssemblyName()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: Void .ctor()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderAttribute: Void .ctor()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean IsHostedExecution
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean IsInvalidationSupported
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean SystemRuntimeContainsType(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean get_IsHostedExecution()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean get_IsInvalidationSupported()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String ResolutionFolder
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String RuntimeAssembly
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String TemporaryFolder
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String get_ResolutionFolder()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String get_RuntimeAssembly()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String get_TemporaryFolder()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String[] ReferencedAssemblies
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String[] get_ReferencedAssemblies()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.Version SystemRuntimeAssemblyVersion
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.Version get_SystemRuntimeAssemblyVersion()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void .ctor(Microsoft.FSharp.Core.FSharpFunc`2[System.String,System.Boolean])
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void .ctor(Microsoft.FSharp.Core.FSharpFunc`2[System.String,System.Boolean], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.String[]])
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_IsHostedExecution(Boolean)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_IsInvalidationSupported(Boolean)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_ReferencedAssemblies(System.String[])
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_ResolutionFolder(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_RuntimeAssembly(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_SystemRuntimeAssemblyVersion(System.Version)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_TemporaryFolder(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 Column
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 Line
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 get_Column()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 get_Line()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: System.String FilePath
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: System.String get_FilePath()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void .ctor()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void set_Column(Int32)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void set_FilePath(System.String)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void set_Line(Int32)
+Microsoft.FSharp.Core.CompilerServices.TypeProviderEditorHideMethodsAttribute: Void .ctor()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes: Int32 value__
+Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes: Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes IsErased
+Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes: Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes SuppressRelocate
+Microsoft.FSharp.Core.CompilerServices.TypeProviderXmlDocAttribute: System.String CommentText
+Microsoft.FSharp.Core.CompilerServices.TypeProviderXmlDocAttribute: System.String get_CommentText()
+Microsoft.FSharp.Core.CompilerServices.TypeProviderXmlDocAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.CustomComparisonAttribute: Void .ctor()
+Microsoft.FSharp.Core.CustomEqualityAttribute: Void .ctor()
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean AllowIntoPattern
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean IsLikeGroupJoin
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean IsLikeJoin
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean IsLikeZip
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean MaintainsVariableSpace
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean MaintainsVariableSpaceUsingBind
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_AllowIntoPattern()
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_IsLikeGroupJoin()
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_IsLikeJoin()
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_IsLikeZip()
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_MaintainsVariableSpace()
+Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_MaintainsVariableSpaceUsingBind()
+Microsoft.FSharp.Core.CustomOperationAttribute: System.String JoinConditionWord
+Microsoft.FSharp.Core.CustomOperationAttribute: System.String Name
+Microsoft.FSharp.Core.CustomOperationAttribute: System.String get_JoinConditionWord()
+Microsoft.FSharp.Core.CustomOperationAttribute: System.String get_Name()
+Microsoft.FSharp.Core.CustomOperationAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_AllowIntoPattern(Boolean)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_IsLikeGroupJoin(Boolean)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_IsLikeJoin(Boolean)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_IsLikeZip(Boolean)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_JoinConditionWord(System.String)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_MaintainsVariableSpace(Boolean)
+Microsoft.FSharp.Core.CustomOperationAttribute: Void set_MaintainsVariableSpaceUsingBind(Boolean)
+Microsoft.FSharp.Core.DefaultAugmentationAttribute: Boolean Value
+Microsoft.FSharp.Core.DefaultAugmentationAttribute: Boolean get_Value()
+Microsoft.FSharp.Core.DefaultAugmentationAttribute: Void .ctor(Boolean)
+Microsoft.FSharp.Core.DefaultValueAttribute: Boolean Check
+Microsoft.FSharp.Core.DefaultValueAttribute: Boolean get_Check()
+Microsoft.FSharp.Core.DefaultValueAttribute: Void .ctor()
+Microsoft.FSharp.Core.DefaultValueAttribute: Void .ctor(Boolean)
+Microsoft.FSharp.Core.EntryPointAttribute: Void .ctor()
+Microsoft.FSharp.Core.EqualityConditionalOnAttribute: Void .ctor()
+Microsoft.FSharp.Core.ExperimentalAttribute: System.String Message
+Microsoft.FSharp.Core.ExperimentalAttribute: System.String get_Message()
+Microsoft.FSharp.Core.ExperimentalAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: Byte ToByte[T](T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: SByte ToSByte[T](T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Byte ToByte[T](T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Double ToDouble$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Double ToDouble[T](T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Collections.FSharpSet`1[T] CreateSet[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Control.FSharpAsyncBuilder DefaultAsyncBuilder
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Control.FSharpAsyncBuilder get_DefaultAsyncBuilder()
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Linq.QueryBuilder get_query()
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Linq.QueryBuilder query
+Microsoft.FSharp.Core.ExtraTopLevelOperators: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: SByte ToSByte[T](T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Single ToSingle$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: Single ToSingle[T](T)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: System.Collections.Generic.IDictionary`2[TKey,TValue] CreateDictionary[TKey,TValue](System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,TValue]])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: System.Collections.Generic.IReadOnlyDictionary`2[TKey,TValue] CreateReadOnlyDictionary[TKey,TValue](System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,TValue]])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T LazyPattern[T](System.Lazy`1[T])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatLineToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatLineToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatLine[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToStringThenFail[T,TResult](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToString[T](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,System.String])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormat[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T SpliceExpression[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T])
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T SpliceUntypedExpression[T](Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Core.ExtraTopLevelOperators: T[,] CreateArray2D[?,T](System.Collections.Generic.IEnumerable`1[?])
+Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]: T1 Item
+Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]: T1 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2]: T2 Item
+Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2]: T2 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`2+Tags[T1,T2]: Int32 Choice1Of2
+Microsoft.FSharp.Core.FSharpChoice`2+Tags[T1,T2]: Int32 Choice2Of2
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`2[T1,T2])
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean IsChoice1Of2
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean IsChoice2Of2
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean get_IsChoice1Of2()
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean get_IsChoice2Of2()
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`2[T1,T2])
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 Tag
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2]
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2+Tags[T1,T2]
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2[T1,T2] NewChoice1Of2(T1)
+Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2[T1,T2] NewChoice2Of2(T2)
+Microsoft.FSharp.Core.FSharpChoice`3+Choice1Of3[T1,T2,T3]: T1 Item
+Microsoft.FSharp.Core.FSharpChoice`3+Choice1Of3[T1,T2,T3]: T1 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`3+Choice2Of3[T1,T2,T3]: T2 Item
+Microsoft.FSharp.Core.FSharpChoice`3+Choice2Of3[T1,T2,T3]: T2 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`3+Choice3Of3[T1,T2,T3]: T3 Item
+Microsoft.FSharp.Core.FSharpChoice`3+Choice3Of3[T1,T2,T3]: T3 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]: Int32 Choice1Of3
+Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]: Int32 Choice2Of3
+Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]: Int32 Choice3Of3
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3])
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean IsChoice1Of3
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean IsChoice2Of3
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean IsChoice3Of3
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean get_IsChoice1Of3()
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean get_IsChoice2Of3()
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean get_IsChoice3Of3()
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3])
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 Tag
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Choice1Of3[T1,T2,T3]
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Choice2Of3[T1,T2,T3]
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Choice3Of3[T1,T2,T3]
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3] NewChoice1Of3(T1)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3] NewChoice2Of3(T2)
+Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3] NewChoice3Of3(T3)
+Microsoft.FSharp.Core.FSharpChoice`4+Choice1Of4[T1,T2,T3,T4]: T1 Item
+Microsoft.FSharp.Core.FSharpChoice`4+Choice1Of4[T1,T2,T3,T4]: T1 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`4+Choice2Of4[T1,T2,T3,T4]: T2 Item
+Microsoft.FSharp.Core.FSharpChoice`4+Choice2Of4[T1,T2,T3,T4]: T2 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`4+Choice3Of4[T1,T2,T3,T4]: T3 Item
+Microsoft.FSharp.Core.FSharpChoice`4+Choice3Of4[T1,T2,T3,T4]: T3 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`4+Choice4Of4[T1,T2,T3,T4]: T4 Item
+Microsoft.FSharp.Core.FSharpChoice`4+Choice4Of4[T1,T2,T3,T4]: T4 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice1Of4
+Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice2Of4
+Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice3Of4
+Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice4Of4
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4])
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice1Of4
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice2Of4
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice3Of4
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice4Of4
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice1Of4()
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice2Of4()
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice3Of4()
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice4Of4()
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4])
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 Tag
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice1Of4[T1,T2,T3,T4]
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice2Of4[T1,T2,T3,T4]
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice3Of4[T1,T2,T3,T4]
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice4Of4[T1,T2,T3,T4]
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice1Of4(T1)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice2Of4(T2)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice3Of4(T3)
+Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice4Of4(T4)
+Microsoft.FSharp.Core.FSharpChoice`5+Choice1Of5[T1,T2,T3,T4,T5]: T1 Item
+Microsoft.FSharp.Core.FSharpChoice`5+Choice1Of5[T1,T2,T3,T4,T5]: T1 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`5+Choice2Of5[T1,T2,T3,T4,T5]: T2 Item
+Microsoft.FSharp.Core.FSharpChoice`5+Choice2Of5[T1,T2,T3,T4,T5]: T2 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`5+Choice3Of5[T1,T2,T3,T4,T5]: T3 Item
+Microsoft.FSharp.Core.FSharpChoice`5+Choice3Of5[T1,T2,T3,T4,T5]: T3 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`5+Choice4Of5[T1,T2,T3,T4,T5]: T4 Item
+Microsoft.FSharp.Core.FSharpChoice`5+Choice4Of5[T1,T2,T3,T4,T5]: T4 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`5+Choice5Of5[T1,T2,T3,T4,T5]: T5 Item
+Microsoft.FSharp.Core.FSharpChoice`5+Choice5Of5[T1,T2,T3,T4,T5]: T5 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice1Of5
+Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice2Of5
+Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice3Of5
+Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice4Of5
+Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice5Of5
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5])
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice1Of5
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice2Of5
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice3Of5
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice4Of5
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice5Of5
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice1Of5()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice2Of5()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice3Of5()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice4Of5()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice5Of5()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5])
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 Tag
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice1Of5[T1,T2,T3,T4,T5]
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice2Of5[T1,T2,T3,T4,T5]
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice3Of5[T1,T2,T3,T4,T5]
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice4Of5[T1,T2,T3,T4,T5]
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice5Of5[T1,T2,T3,T4,T5]
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice1Of5(T1)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice2Of5(T2)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice3Of5(T3)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice4Of5(T4)
+Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice5Of5(T5)
+Microsoft.FSharp.Core.FSharpChoice`6+Choice1Of6[T1,T2,T3,T4,T5,T6]: T1 Item
+Microsoft.FSharp.Core.FSharpChoice`6+Choice1Of6[T1,T2,T3,T4,T5,T6]: T1 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`6+Choice2Of6[T1,T2,T3,T4,T5,T6]: T2 Item
+Microsoft.FSharp.Core.FSharpChoice`6+Choice2Of6[T1,T2,T3,T4,T5,T6]: T2 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`6+Choice3Of6[T1,T2,T3,T4,T5,T6]: T3 Item
+Microsoft.FSharp.Core.FSharpChoice`6+Choice3Of6[T1,T2,T3,T4,T5,T6]: T3 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`6+Choice4Of6[T1,T2,T3,T4,T5,T6]: T4 Item
+Microsoft.FSharp.Core.FSharpChoice`6+Choice4Of6[T1,T2,T3,T4,T5,T6]: T4 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`6+Choice5Of6[T1,T2,T3,T4,T5,T6]: T5 Item
+Microsoft.FSharp.Core.FSharpChoice`6+Choice5Of6[T1,T2,T3,T4,T5,T6]: T5 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`6+Choice6Of6[T1,T2,T3,T4,T5,T6]: T6 Item
+Microsoft.FSharp.Core.FSharpChoice`6+Choice6Of6[T1,T2,T3,T4,T5,T6]: T6 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice1Of6
+Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice2Of6
+Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice3Of6
+Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice4Of6
+Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice5Of6
+Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice6Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6])
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice1Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice2Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice3Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice4Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice5Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice6Of6
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice1Of6()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice2Of6()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice3Of6()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice4Of6()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice5Of6()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice6Of6()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6])
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 Tag
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice1Of6[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice2Of6[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice3Of6[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice4Of6[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice5Of6[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice6Of6[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice1Of6(T1)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice2Of6(T2)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice3Of6(T3)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice4Of6(T4)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice5Of6(T5)
+Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice6Of6(T6)
+Microsoft.FSharp.Core.FSharpChoice`7+Choice1Of7[T1,T2,T3,T4,T5,T6,T7]: T1 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice1Of7[T1,T2,T3,T4,T5,T6,T7]: T1 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Choice2Of7[T1,T2,T3,T4,T5,T6,T7]: T2 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice2Of7[T1,T2,T3,T4,T5,T6,T7]: T2 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Choice3Of7[T1,T2,T3,T4,T5,T6,T7]: T3 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice3Of7[T1,T2,T3,T4,T5,T6,T7]: T3 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Choice4Of7[T1,T2,T3,T4,T5,T6,T7]: T4 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice4Of7[T1,T2,T3,T4,T5,T6,T7]: T4 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Choice5Of7[T1,T2,T3,T4,T5,T6,T7]: T5 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice5Of7[T1,T2,T3,T4,T5,T6,T7]: T5 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Choice6Of7[T1,T2,T3,T4,T5,T6,T7]: T6 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice6Of7[T1,T2,T3,T4,T5,T6,T7]: T6 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Choice7Of7[T1,T2,T3,T4,T5,T6,T7]: T7 Item
+Microsoft.FSharp.Core.FSharpChoice`7+Choice7Of7[T1,T2,T3,T4,T5,T6,T7]: T7 get_Item()
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice1Of7
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice2Of7
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice3Of7
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice4Of7
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice5Of7
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice6Of7
+Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice7Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7])
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice1Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice2Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice3Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice4Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice5Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice6Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice7Of7
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice1Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice2Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice3Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice4Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice5Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice6Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice7Of7()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7])
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 Tag
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice1Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice2Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice3Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice4Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice5Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice6Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice7Of7[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice1Of7(T1)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice2Of7(T2)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice3Of7(T3)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice4Of7(T4)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice5Of7(T5)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice6Of7(T6)
+Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice7Of7(T7)
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] FromConverter(System.Converter`2[T,TResult])
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] op_Implicit(System.Converter`2[T,TResult])
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: System.Converter`2[T,TResult] ToConverter(Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: System.Converter`2[T,TResult] op_Implicit(Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: TResult Invoke(T)
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: V InvokeFast[V](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,V]], T, TResult)
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Void .ctor()
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: W InvokeFast[V,W](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[V,W]]], T, TResult, V)
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: X InvokeFast[V,W,X](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[V,Microsoft.FSharp.Core.FSharpFunc`2[W,X]]]], T, TResult, V, W)
+Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Y InvokeFast[V,W,X,Y](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[V,Microsoft.FSharp.Core.FSharpFunc`2[W,Microsoft.FSharp.Core.FSharpFunc`2[X,Y]]]]], T, TResult, V, W, X)
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 Major
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 Minor
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 Release
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 get_Major()
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 get_Minor()
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 get_Release()
+Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Void .ctor(Int32, Int32, Int32)
+Microsoft.FSharp.Core.FSharpOption`1+Tags[T]: Int32 None
+Microsoft.FSharp.Core.FSharpOption`1+Tags[T]: Int32 Some
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean IsNone
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean IsSome
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean get_IsNone(Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean get_IsSome(Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 GetTag(Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1+Tags[T]
+Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] None
+Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] Some(T)
+Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] get_None()
+Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] op_Implicit(T)
+Microsoft.FSharp.Core.FSharpOption`1[T]: System.String ToString()
+Microsoft.FSharp.Core.FSharpOption`1[T]: T Value
+Microsoft.FSharp.Core.FSharpOption`1[T]: T get_Value()
+Microsoft.FSharp.Core.FSharpOption`1[T]: Void .ctor(T)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpRef`1[T])
+Microsoft.FSharp.Core.FSharpRef`1[T]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpRef`1[T])
+Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpRef`1[T]: T Value
+Microsoft.FSharp.Core.FSharpRef`1[T]: T contents
+Microsoft.FSharp.Core.FSharpRef`1[T]: T contents@
+Microsoft.FSharp.Core.FSharpRef`1[T]: T get_Value()
+Microsoft.FSharp.Core.FSharpRef`1[T]: T get_contents()
+Microsoft.FSharp.Core.FSharpRef`1[T]: Void .ctor(T)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Void set_Value(T)
+Microsoft.FSharp.Core.FSharpRef`1[T]: Void set_contents(T)
+Microsoft.FSharp.Core.FSharpResult`2+Tags[T,TError]: Int32 Error
+Microsoft.FSharp.Core.FSharpResult`2+Tags[T,TError]: Int32 Ok
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean Equals(Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean IsError
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean IsOk
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean get_IsError()
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean get_IsOk()
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 Tag
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Microsoft.FSharp.Core.FSharpResult`2+Tags[T,TError]
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Microsoft.FSharp.Core.FSharpResult`2[T,TError] NewError(TError)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Microsoft.FSharp.Core.FSharpResult`2[T,TError] NewOk(T)
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: T ResultValue
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: T get_ResultValue()
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: TError ErrorValue
+Microsoft.FSharp.Core.FSharpResult`2[T,TError]: TError get_ErrorValue()
+Microsoft.FSharp.Core.FSharpTypeFunc: System.Object Specialize[T]()
+Microsoft.FSharp.Core.FSharpTypeFunc: Void .ctor()
+Microsoft.FSharp.Core.FSharpValueOption`1+Tags[T]: Int32 ValueNone
+Microsoft.FSharp.Core.FSharpValueOption`1+Tags[T]: Int32 ValueSome
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsNone
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsSome
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsValueNone
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsValueSome
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsNone()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsSome()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsValueNone()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsValueSome()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 CompareTo(System.Object)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 GetHashCode()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 Tag
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 get_Tag()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1+Tags[T]
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] NewValueSome(T)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] None
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] Some(T)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] ValueNone
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] get_None()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] get_ValueNone()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] op_Implicit(T)
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: System.String ToString()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: T Item
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: T Value
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: T get_Item()
+Microsoft.FSharp.Core.FSharpValueOption`1[T]: T get_Value()
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit] FromAction(System.Action)
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T] FromFunc[T](System.Func`1[T])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit] FromAction[T](System.Action`1[T])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit] ToFSharpFunc[T](System.Action`1[T])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] FromFunc[T,TResult](System.Func`2[T,TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] ToFSharpFunc[T,TResult](System.Converter`2[T,TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,Microsoft.FSharp.Core.Unit]]]]] FromAction[T1,T2,T3,T4,T5](System.Action`5[T1,T2,T3,T4,T5])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]]] FromFunc[T1,T2,T3,T4,T5,TResult](System.Func`6[T1,T2,T3,T4,T5,TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]]] FuncFromTupled[T1,T2,T3,T4,T5,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`5[T1,T2,T3,T4,T5],TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.Unit]]]] FromAction[T1,T2,T3,T4](System.Action`4[T1,T2,T3,T4])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]]] FromFunc[T1,T2,T3,T4,TResult](System.Func`5[T1,T2,T3,T4,TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]]] FuncFromTupled[T1,T2,T3,T4,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`4[T1,T2,T3,T4],TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.Unit]]] FromAction[T1,T2,T3](System.Action`3[T1,T2,T3])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]] FromFunc[T1,T2,T3,TResult](System.Func`4[T1,T2,T3,TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]] FuncFromTupled[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[T1,T2,T3],TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]] FromAction[T1,T2](System.Action`2[T1,T2])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]] FromFunc[T1,T2,TResult](System.Func`3[T1,T2,TResult])
+Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]] FuncFromTupled[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[T1,T2],TResult])
+Microsoft.FSharp.Core.GeneralizableValueAttribute: Void .ctor()
+Microsoft.FSharp.Core.InlineIfLambdaAttribute: Void .ctor()
+Microsoft.FSharp.Core.InterfaceAttribute: Void .ctor()
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String AddressOpNotFirstClassString
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String InputArrayEmptyString
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String InputMustBeNonNegativeString
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String InputSequenceEmptyString
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String NoNegateMinValueString
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_AddressOpNotFirstClassString()
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_InputArrayEmptyString()
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_InputMustBeNonNegativeString()
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_InputSequenceEmptyString()
+Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_NoNegateMinValueString()
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple2[T1,T2](System.Collections.IEqualityComparer, System.Tuple`2[T1,T2], System.Tuple`2[T1,T2])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple3[T1,T2,T3](System.Collections.IEqualityComparer, System.Tuple`3[T1,T2,T3], System.Tuple`3[T1,T2,T3])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple4[T1,T2,T3,T4](System.Collections.IEqualityComparer, System.Tuple`4[T1,T2,T3,T4], System.Tuple`4[T1,T2,T3,T4])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple5[T1,T2,T3,T4,T5](System.Collections.IEqualityComparer, System.Tuple`5[T1,T2,T3,T4,T5], System.Tuple`5[T1,T2,T3,T4,T5])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericEqualityERIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericEqualityIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericEqualityWithComparerIntrinsic[T](System.Collections.IEqualityComparer, T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericGreaterOrEqualIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericGreaterThanIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericLessOrEqualIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericLessThanIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean PhysicalEqualityIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple2[T1,T2](System.Collections.IComparer, System.Tuple`2[T1,T2], System.Tuple`2[T1,T2])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple3[T1,T2,T3](System.Collections.IComparer, System.Tuple`3[T1,T2,T3], System.Tuple`3[T1,T2,T3])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple4[T1,T2,T3,T4](System.Collections.IComparer, System.Tuple`4[T1,T2,T3,T4], System.Tuple`4[T1,T2,T3,T4])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple5[T1,T2,T3,T4,T5](System.Collections.IComparer, System.Tuple`5[T1,T2,T3,T4,T5], System.Tuple`5[T1,T2,T3,T4,T5])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple2[T1,T2](System.Collections.IEqualityComparer, System.Tuple`2[T1,T2])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple3[T1,T2,T3](System.Collections.IEqualityComparer, System.Tuple`3[T1,T2,T3])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple4[T1,T2,T3,T4](System.Collections.IEqualityComparer, System.Tuple`4[T1,T2,T3,T4])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple5[T1,T2,T3,T4,T5](System.Collections.IEqualityComparer, System.Tuple`5[T1,T2,T3,T4,T5])
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericComparisonIntrinsic[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericComparisonWithComparerIntrinsic[T](System.Collections.IComparer, T, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericHashIntrinsic[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericHashWithComparerIntrinsic[T](System.Collections.IEqualityComparer, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 LimitedGenericHashIntrinsic[T](Int32, T)
+Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 PhysicalHashIntrinsic[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Boolean TypeTestFast[T](System.Object)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Boolean TypeTestGeneric[T](System.Object)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Char GetString(System.String, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: System.Decimal MakeDecimal(Int32, Int32, Int32, Boolean, Byte)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T CheckThis[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T CreateInstance[T]()
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray2D[T](T[,], Int32, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray3D[T](T[,,], Int32, Int32, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray4D[T](T[,,,], Int32, Int32, Int32, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray[T](T[], Int32)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T UnboxFast[T](System.Object)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T UnboxGeneric[T](System.Object)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void Dispose[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void FailInit()
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void FailStaticInit()
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray2D[T](T[,], Int32, Int32, T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray3D[T](T[,,], Int32, Int32, Int32, T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray4D[T](T[,,,], Int32, Int32, Int32, Int32, T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray[T](T[], Int32, T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean Or(Boolean, Boolean)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean op_Amp(Boolean, Boolean)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean op_BooleanAnd(Boolean, Boolean)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean op_BooleanOr(Boolean, Boolean)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: IntPtr op_IntegerAddressOf[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: T& op_AddressOf[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericEqualityER[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericEqualityWithComparer[T](System.Collections.IEqualityComparer, T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericEquality[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericGreaterOrEqual[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericGreaterThan[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericLessOrEqual[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericLessThan[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Boolean PhysicalEquality[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Byte ByteWithMeasure(Byte)
+Microsoft.FSharp.Core.LanguagePrimitives: Double FloatWithMeasure(Double)
+Microsoft.FSharp.Core.LanguagePrimitives: Int16 Int16WithMeasure(Int16)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericComparisonWithComparer[T](System.Collections.IComparer, T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericComparison[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericHashWithComparer[T](System.Collections.IEqualityComparer, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericHash[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericLimitedHash[T](Int32, T)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 Int32WithMeasure(Int32)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 ParseInt32(System.String)
+Microsoft.FSharp.Core.LanguagePrimitives: Int32 PhysicalHash[T](T)
+Microsoft.FSharp.Core.LanguagePrimitives: Int64 Int64WithMeasure(Int64)
+Microsoft.FSharp.Core.LanguagePrimitives: Int64 ParseInt64(System.String)
+Microsoft.FSharp.Core.LanguagePrimitives: IntPtr IntPtrWithMeasure(IntPtr)
+Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings
+Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+HashCompare
+Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions
+Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators
+Microsoft.FSharp.Core.LanguagePrimitives: SByte SByteWithMeasure(SByte)
+Microsoft.FSharp.Core.LanguagePrimitives: Single Float32WithMeasure(Single)
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IComparer`1[T] FastGenericComparerFromTable[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IComparer`1[T] FastGenericComparer[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IEqualityComparer`1[T] FastGenericEqualityComparerFromTable[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IEqualityComparer`1[T] FastGenericEqualityComparer[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IEqualityComparer`1[T] FastLimitedGenericEqualityComparer[T](Int32)
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IComparer GenericComparer
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IComparer get_GenericComparer()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer GenericEqualityComparer
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer GenericEqualityERComparer
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer get_GenericEqualityComparer()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer get_GenericEqualityERComparer()
+Microsoft.FSharp.Core.LanguagePrimitives: System.Decimal DecimalWithMeasure(System.Decimal)
+Microsoft.FSharp.Core.LanguagePrimitives: T DivideByInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], T, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives: T DivideByIntDynamic[T](T, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives: T DivideByInt[T](T, Int32)
+Microsoft.FSharp.Core.LanguagePrimitives: T EnumToValue[TEnum,T](TEnum)
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericMaximum[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericMinimum[T](T, T)
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericOne$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T])
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericOneDynamic[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericOne[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericZero$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T])
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericZeroDynamic[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: T GenericZero[T]()
+Microsoft.FSharp.Core.LanguagePrimitives: TEnum EnumOfValue[T,TEnum](T)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult AdditionDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult BitwiseAndDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult BitwiseOrDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedAdditionDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedExplicitDynamic[T,TResult](T)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedMultiplyDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedSubtractionDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedUnaryNegationDynamic[T,TResult](T)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult DivisionDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult EqualityDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult ExclusiveOrDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult ExplicitDynamic[T,TResult](T)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult GreaterThanDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult GreaterThanOrEqualDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult InequalityDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult LeftShiftDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult LessThanDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult LessThanOrEqualDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult LogicalNotDynamic[T,TResult](T)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult ModulusDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult MultiplyDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult RightShiftDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult SubtractionDynamic[T1,T2,TResult](T1, T2)
+Microsoft.FSharp.Core.LanguagePrimitives: TResult UnaryNegationDynamic[T,TResult](T)
+Microsoft.FSharp.Core.LanguagePrimitives: UInt16 UInt16WithMeasure(UInt16)
+Microsoft.FSharp.Core.LanguagePrimitives: UInt32 ParseUInt32(System.String)
+Microsoft.FSharp.Core.LanguagePrimitives: UInt32 UInt32WithMeasure(UInt32)
+Microsoft.FSharp.Core.LanguagePrimitives: UInt64 ParseUInt64(System.String)
+Microsoft.FSharp.Core.LanguagePrimitives: UInt64 UInt64WithMeasure(UInt64)
+Microsoft.FSharp.Core.LanguagePrimitives: UIntPtr UIntPtrWithMeasure(UIntPtr)
+Microsoft.FSharp.Core.LiteralAttribute: Void .ctor()
+Microsoft.FSharp.Core.MatchFailureException: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.MatchFailureException: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.MatchFailureException: Int32 Data1
+Microsoft.FSharp.Core.MatchFailureException: Int32 Data2
+Microsoft.FSharp.Core.MatchFailureException: Int32 GetHashCode()
+Microsoft.FSharp.Core.MatchFailureException: Int32 GetHashCode(System.Collections.IEqualityComparer)
+Microsoft.FSharp.Core.MatchFailureException: Int32 get_Data1()
+Microsoft.FSharp.Core.MatchFailureException: Int32 get_Data2()
+Microsoft.FSharp.Core.MatchFailureException: System.String Data0
+Microsoft.FSharp.Core.MatchFailureException: System.String Message
+Microsoft.FSharp.Core.MatchFailureException: System.String get_Data0()
+Microsoft.FSharp.Core.MatchFailureException: System.String get_Message()
+Microsoft.FSharp.Core.MatchFailureException: Void .ctor()
+Microsoft.FSharp.Core.MatchFailureException: Void .ctor(System.String, Int32, Int32)
+Microsoft.FSharp.Core.MeasureAnnotatedAbbreviationAttribute: Void .ctor()
+Microsoft.FSharp.Core.MeasureAttribute: Void .ctor()
+Microsoft.FSharp.Core.NoComparisonAttribute: Void .ctor()
+Microsoft.FSharp.Core.NoCompilerInliningAttribute: Void .ctor()
+Microsoft.FSharp.Core.NoDynamicInvocationAttribute: Void .ctor()
+Microsoft.FSharp.Core.NoEqualityAttribute: Void .ctor()
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: System.Object FromInt64Dynamic(Int64)
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: System.Object FromStringDynamic(System.String)
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromInt32[T](Int32)
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromInt64[T](Int64)
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromOne[T]()
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromString[T](System.String)
+Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromZero[T]()
+Microsoft.FSharp.Core.NumericLiterals: Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI
+Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 String.GetReverseIndex(System.String, Int32, Int32)
+Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 [,,,]`1.GetReverseIndex[T](T[,,,], Int32, Int32)
+Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 [,,]`1.GetReverseIndex[T](T[,,], Int32, Int32)
+Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 [,]`1.GetReverseIndex[T](T[,], Int32, Int32)
+Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 []`1.GetReverseIndex[T](T[], Int32, Int32)
+Microsoft.FSharp.Core.Operators+Checked: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T)
+Microsoft.FSharp.Core.Operators+Checked: Byte ToByte[T](T)
+Microsoft.FSharp.Core.Operators+Checked: Char ToChar$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Char], T)
+Microsoft.FSharp.Core.Operators+Checked: Char ToChar[T](T)
+Microsoft.FSharp.Core.Operators+Checked: Int16 ToInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int16], T)
+Microsoft.FSharp.Core.Operators+Checked: Int16 ToInt16[T](T)
+Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T)
+Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T)
+Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt32[T](T)
+Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt[T](T)
+Microsoft.FSharp.Core.Operators+Checked: Int64 ToInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int64], T)
+Microsoft.FSharp.Core.Operators+Checked: Int64 ToInt64[T](T)
+Microsoft.FSharp.Core.Operators+Checked: IntPtr ToIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.IntPtr], T)
+Microsoft.FSharp.Core.Operators+Checked: IntPtr ToIntPtr[T](T)
+Microsoft.FSharp.Core.Operators+Checked: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T)
+Microsoft.FSharp.Core.Operators+Checked: SByte ToSByte[T](T)
+Microsoft.FSharp.Core.Operators+Checked: T op_UnaryNegation$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators+Checked: T op_UnaryNegation[T](T)
+Microsoft.FSharp.Core.Operators+Checked: T3 op_Addition$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators+Checked: T3 op_Addition[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators+Checked: T3 op_Multiply$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators+Checked: T3 op_Multiply[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators+Checked: T3 op_Subtraction$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators+Checked: T3 op_Subtraction[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators+Checked: UInt16 ToUInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt16], T)
+Microsoft.FSharp.Core.Operators+Checked: UInt16 ToUInt16[T](T)
+Microsoft.FSharp.Core.Operators+Checked: UInt32 ToUInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], T)
+Microsoft.FSharp.Core.Operators+Checked: UInt32 ToUInt32[T](T)
+Microsoft.FSharp.Core.Operators+Checked: UInt64 ToUInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt64], T)
+Microsoft.FSharp.Core.Operators+Checked: UInt64 ToUInt64[T](T)
+Microsoft.FSharp.Core.Operators+Checked: UIntPtr ToUIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UIntPtr], T)
+Microsoft.FSharp.Core.Operators+Checked: UIntPtr ToUIntPtr[T](T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Equality$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Equality[T](T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThan$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThanOrEqual$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThanOrEqual[T,TResult](T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThan[T,TResult](T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Inequality$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Inequality[T](T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThan$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThanOrEqual$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThanOrEqual[T,TResult](T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThan[T,TResult](T, TResult)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Int32 Compare$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Int32 Compare[T](T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: Int32 Hash[T](T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Max$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Max[T](T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Min$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T)
+Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Min[T](T, T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Byte PowByte(Byte, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Double PowDouble(Double, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int16 PowInt16(Int16, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int32 PowInt32(Int32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int32 SignDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int64 PowInt64(Int64, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: IntPtr PowIntPtr(IntPtr, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: SByte PowSByte(SByte, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Single PowSingle(Single, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Byte] RangeByte(Byte, Byte, Byte)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Char] RangeChar(Char, Char)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Double] RangeDouble(Double, Double, Double)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Int16] RangeInt16(Int16, Int16, Int16)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Int32] RangeInt32(Int32, Int32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Int64] RangeInt64(Int64, Int64, Int64)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.IntPtr] RangeIntPtr(IntPtr, IntPtr, IntPtr)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.SByte] RangeSByte(SByte, SByte, SByte)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Single] RangeSingle(Single, Single, Single)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UInt16] RangeUInt16(UInt16, UInt16, UInt16)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UInt32] RangeUInt32(UInt32, UInt32, UInt32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UInt64] RangeUInt64(UInt64, UInt64, UInt64)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UIntPtr] RangeUIntPtr(UIntPtr, UIntPtr, UIntPtr)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[T] RangeGeneric[T](T, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[T] RangeStepGeneric[TStep,T](TStep, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TStep,T]], T, TStep, T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Decimal PowDecimal(System.Decimal, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.String GetStringSlice(System.String, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AbsDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AcosDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AsinDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AtanDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T CeilingDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T CosDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T CoshDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T ExpDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T FloorDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T Log10Dynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T LogDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T PowDynamic[T,TResult](T, TResult)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T PowGeneric[T](T, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T RoundDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T SinDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T SinhDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T TanDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T TanhDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T TruncateDynamic[T](T)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T2 Atan2Dynamic[T1,T2](T1, T1)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T2 SqrtDynamic[T1,T2](T1)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,,] GetArraySlice4D[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice3D[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle1[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle2[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle3[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice2D[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice3DFixedSingle1[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice3DFixedSingle2[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice3DFixedSingle3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble1[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble3[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble5[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble6[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice2DFixed1[T](T[,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice2DFixed2[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice3DFixedDouble1[T](T[,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice3DFixedDouble2[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice3DFixedDouble3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple1[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple3[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple4[T](T[,,,], Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice[T](T[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UInt16 PowUInt16(UInt16, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UInt32 PowUInt32(UInt32, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UInt64 PowUInt64(UInt64, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UIntPtr PowUIntPtr(UIntPtr, Int32)
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice2DFixed1[T](T[,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice2DFixed2[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice2D[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedDouble1[T](T[,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedDouble2[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedDouble3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedSingle1[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedSingle2[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedSingle3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3D[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble1[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble3[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble5[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble6[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, T[,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle1[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle2[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle3[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple1[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Int32, T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple3[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple4[T](T[,,,], Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4D[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,,])
+Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice[T](T[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[])
+Microsoft.FSharp.Core.Operators+Unchecked: Boolean Equals[T](T, T)
+Microsoft.FSharp.Core.Operators+Unchecked: Int32 Compare[T](T, T)
+Microsoft.FSharp.Core.Operators+Unchecked: Int32 Hash[T](T)
+Microsoft.FSharp.Core.Operators+Unchecked: T DefaultOf[T]()
+Microsoft.FSharp.Core.Operators+Unchecked: T Unbox[T](System.Object)
+Microsoft.FSharp.Core.Operators: Boolean IsNull[T](T)
+Microsoft.FSharp.Core.Operators: Boolean Not(Boolean)
+Microsoft.FSharp.Core.Operators: Boolean op_Equality[T](T, T)
+Microsoft.FSharp.Core.Operators: Boolean op_GreaterThanOrEqual[T](T, T)
+Microsoft.FSharp.Core.Operators: Boolean op_GreaterThan[T](T, T)
+Microsoft.FSharp.Core.Operators: Boolean op_Inequality[T](T, T)
+Microsoft.FSharp.Core.Operators: Boolean op_LessThanOrEqual[T](T, T)
+Microsoft.FSharp.Core.Operators: Boolean op_LessThan[T](T, T)
+Microsoft.FSharp.Core.Operators: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T)
+Microsoft.FSharp.Core.Operators: Byte ToByte[T](T)
+Microsoft.FSharp.Core.Operators: Char ToChar$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Char], T)
+Microsoft.FSharp.Core.Operators: Char ToChar[T](T)
+Microsoft.FSharp.Core.Operators: Double Infinity
+Microsoft.FSharp.Core.Operators: Double NaN
+Microsoft.FSharp.Core.Operators: Double ToDouble$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], T)
+Microsoft.FSharp.Core.Operators: Double ToDouble[T](T)
+Microsoft.FSharp.Core.Operators: Double get_Infinity()
+Microsoft.FSharp.Core.Operators: Double get_NaN()
+Microsoft.FSharp.Core.Operators: Int16 ToInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int16], T)
+Microsoft.FSharp.Core.Operators: Int16 ToInt16[T](T)
+Microsoft.FSharp.Core.Operators: Int32 Compare[T](T, T)
+Microsoft.FSharp.Core.Operators: Int32 Hash[T](T)
+Microsoft.FSharp.Core.Operators: Int32 Sign$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T)
+Microsoft.FSharp.Core.Operators: Int32 Sign[T](T)
+Microsoft.FSharp.Core.Operators: Int32 SizeOf[T]()
+Microsoft.FSharp.Core.Operators: Int32 ToInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T)
+Microsoft.FSharp.Core.Operators: Int32 ToInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T)
+Microsoft.FSharp.Core.Operators: Int32 ToInt32[T](T)
+Microsoft.FSharp.Core.Operators: Int32 ToInt[T](T)
+Microsoft.FSharp.Core.Operators: Int32 limitedHash[T](Int32, T)
+Microsoft.FSharp.Core.Operators: Int64 ToInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int64], T)
+Microsoft.FSharp.Core.Operators: Int64 ToInt64[T](T)
+Microsoft.FSharp.Core.Operators: IntPtr ToIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.IntPtr], T)
+Microsoft.FSharp.Core.Operators: IntPtr ToIntPtr[T](T)
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Collections.FSharpList`1[T] op_Append[T](Microsoft.FSharp.Collections.FSharpList`1[T], Microsoft.FSharp.Collections.FSharpList`1[T])
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpFunc`2[T1,T3] op_ComposeLeft[T2,T3,T1](Microsoft.FSharp.Core.FSharpFunc`2[T2,T3], Microsoft.FSharp.Core.FSharpFunc`2[T1,T2])
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpFunc`2[T1,T3] op_ComposeRight[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,T2], Microsoft.FSharp.Core.FSharpFunc`2[T2,T3])
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpOption`1[System.String] FailurePattern(System.Exception)
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpOption`1[T] TryUnbox[T](System.Object)
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpRef`1[T] Ref[T](T)
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+ArrayExtensions
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+Checked
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+NonStructuralComparison
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+OperatorIntrinsics
+Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+Unchecked
+Microsoft.FSharp.Core.Operators: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T)
+Microsoft.FSharp.Core.Operators: SByte ToSByte[T](T)
+Microsoft.FSharp.Core.Operators: Single InfinitySingle
+Microsoft.FSharp.Core.Operators: Single NaNSingle
+Microsoft.FSharp.Core.Operators: Single ToSingle$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], T)
+Microsoft.FSharp.Core.Operators: Single ToSingle[T](T)
+Microsoft.FSharp.Core.Operators: Single get_InfinitySingle()
+Microsoft.FSharp.Core.Operators: Single get_NaNSingle()
+Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] CreateSequence[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_Range$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T)
+Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_RangeStep$W[T,TStep](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TStep], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TStep,T]], T, TStep, T)
+Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_RangeStep[T,TStep](T, TStep, T)
+Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_Range[T](T, T)
+Microsoft.FSharp.Core.Operators: System.Decimal ToDecimal$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Decimal], T)
+Microsoft.FSharp.Core.Operators: System.Decimal ToDecimal[T](T)
+Microsoft.FSharp.Core.Operators: System.Exception Failure(System.String)
+Microsoft.FSharp.Core.Operators: System.IO.TextReader ConsoleIn[T]()
+Microsoft.FSharp.Core.Operators: System.IO.TextWriter ConsoleError[T]()
+Microsoft.FSharp.Core.Operators: System.IO.TextWriter ConsoleOut[T]()
+Microsoft.FSharp.Core.Operators: System.Object Box[T](T)
+Microsoft.FSharp.Core.Operators: System.String NameOf[T](T)
+Microsoft.FSharp.Core.Operators: System.String ToString[T](T)
+Microsoft.FSharp.Core.Operators: System.String op_Concatenate(System.String, System.String)
+Microsoft.FSharp.Core.Operators: System.Tuple`2[TKey,TValue] KeyValuePattern[TKey,TValue](System.Collections.Generic.KeyValuePair`2[TKey,TValue])
+Microsoft.FSharp.Core.Operators: System.Type TypeDefOf[T]()
+Microsoft.FSharp.Core.Operators: System.Type TypeOf[T]()
+Microsoft.FSharp.Core.Operators: T Abs$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Abs[T](T)
+Microsoft.FSharp.Core.Operators: T Acos$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Acos[T](T)
+Microsoft.FSharp.Core.Operators: T Asin$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Asin[T](T)
+Microsoft.FSharp.Core.Operators: T Atan$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Atan[T](T)
+Microsoft.FSharp.Core.Operators: T Ceiling$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Ceiling[T](T)
+Microsoft.FSharp.Core.Operators: T Cos$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Cos[T](T)
+Microsoft.FSharp.Core.Operators: T Cosh$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Cosh[T](T)
+Microsoft.FSharp.Core.Operators: T DefaultArg[T](Microsoft.FSharp.Core.FSharpOption`1[T], T)
+Microsoft.FSharp.Core.Operators: T DefaultValueArg[T](Microsoft.FSharp.Core.FSharpValueOption`1[T], T)
+Microsoft.FSharp.Core.Operators: T Exit[T](Int32)
+Microsoft.FSharp.Core.Operators: T Exp$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Exp[T](T)
+Microsoft.FSharp.Core.Operators: T FailWith[T](System.String)
+Microsoft.FSharp.Core.Operators: T Floor$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Floor[T](T)
+Microsoft.FSharp.Core.Operators: T Identity[T](T)
+Microsoft.FSharp.Core.Operators: T InvalidArg[T](System.String, System.String)
+Microsoft.FSharp.Core.Operators: T InvalidOp[T](System.String)
+Microsoft.FSharp.Core.Operators: T Lock[TLock,T](TLock, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T])
+Microsoft.FSharp.Core.Operators: T Log$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Log10$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Log10[T](T)
+Microsoft.FSharp.Core.Operators: T Log[T](T)
+Microsoft.FSharp.Core.Operators: T Max[T](T, T)
+Microsoft.FSharp.Core.Operators: T Min[T](T, T)
+Microsoft.FSharp.Core.Operators: T NullArg[T](System.String)
+Microsoft.FSharp.Core.Operators: T PowInteger$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, Int32)
+Microsoft.FSharp.Core.Operators: T PowInteger[T](T, Int32)
+Microsoft.FSharp.Core.Operators: T Raise[T](System.Exception)
+Microsoft.FSharp.Core.Operators: T Reraise[T]()
+Microsoft.FSharp.Core.Operators: T Rethrow[T]()
+Microsoft.FSharp.Core.Operators: T Round$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Round[T](T)
+Microsoft.FSharp.Core.Operators: T Sin$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Sin[T](T)
+Microsoft.FSharp.Core.Operators: T Sinh$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Sinh[T](T)
+Microsoft.FSharp.Core.Operators: T Tan$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Tan[T](T)
+Microsoft.FSharp.Core.Operators: T Tanh$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Tanh[T](T)
+Microsoft.FSharp.Core.Operators: T Truncate$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T Truncate[T](T)
+Microsoft.FSharp.Core.Operators: T Unbox[T](System.Object)
+Microsoft.FSharp.Core.Operators: T op_BitwiseAnd$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T)
+Microsoft.FSharp.Core.Operators: T op_BitwiseAnd[T](T, T)
+Microsoft.FSharp.Core.Operators: T op_BitwiseOr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T)
+Microsoft.FSharp.Core.Operators: T op_BitwiseOr[T](T, T)
+Microsoft.FSharp.Core.Operators: T op_Dereference[T](Microsoft.FSharp.Core.FSharpRef`1[T])
+Microsoft.FSharp.Core.Operators: T op_ExclusiveOr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T)
+Microsoft.FSharp.Core.Operators: T op_ExclusiveOr[T](T, T)
+Microsoft.FSharp.Core.Operators: T op_Exponentiation$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,T]], T, TResult)
+Microsoft.FSharp.Core.Operators: T op_Exponentiation[T,TResult](T, TResult)
+Microsoft.FSharp.Core.Operators: T op_LeftShift$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], T, Int32)
+Microsoft.FSharp.Core.Operators: T op_LeftShift[T](T, Int32)
+Microsoft.FSharp.Core.Operators: T op_LogicalNot$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T op_LogicalNot[T](T)
+Microsoft.FSharp.Core.Operators: T op_RightShift$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], T, Int32)
+Microsoft.FSharp.Core.Operators: T op_RightShift[T](T, Int32)
+Microsoft.FSharp.Core.Operators: T op_UnaryNegation$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T op_UnaryNegation[T](T)
+Microsoft.FSharp.Core.Operators: T op_UnaryPlus$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
+Microsoft.FSharp.Core.Operators: T op_UnaryPlus[T](T)
+Microsoft.FSharp.Core.Operators: T1 Fst[T1,T2](System.Tuple`2[T1,T2])
+Microsoft.FSharp.Core.Operators: T2 Atan2$W[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T1,T2]], T1, T1)
+Microsoft.FSharp.Core.Operators: T2 Atan2[T1,T2](T1, T1)
+Microsoft.FSharp.Core.Operators: T2 Snd[T1,T2](System.Tuple`2[T1,T2])
+Microsoft.FSharp.Core.Operators: T3 op_Addition$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Addition[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Division$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Division[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Modulus$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Modulus[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Multiply$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Multiply[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Subtraction$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
+Microsoft.FSharp.Core.Operators: T3 op_Subtraction[T1,T2,T3](T1, T2)
+Microsoft.FSharp.Core.Operators: TResult Sqrt$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T)
+Microsoft.FSharp.Core.Operators: TResult Sqrt[T,TResult](T)
+Microsoft.FSharp.Core.Operators: TResult ToEnum[TResult](Int32)
+Microsoft.FSharp.Core.Operators: TResult Using[T,TResult](T, Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
+Microsoft.FSharp.Core.Operators: TResult op_PipeLeft2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], T1, T2)
+Microsoft.FSharp.Core.Operators: TResult op_PipeLeft3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], T1, T2, T3)
+Microsoft.FSharp.Core.Operators: TResult op_PipeLeft[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T)
+Microsoft.FSharp.Core.Operators: TResult op_PipeRight2[T1,T2,TResult](T1, T2, Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]])
+Microsoft.FSharp.Core.Operators: TResult op_PipeRight3[T1,T2,T3,TResult](T1, T2, T3, Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]])
+Microsoft.FSharp.Core.Operators: TResult op_PipeRight[T1,TResult](T1, Microsoft.FSharp.Core.FSharpFunc`2[T1,TResult])
+Microsoft.FSharp.Core.Operators: UInt16 ToUInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt16], T)
+Microsoft.FSharp.Core.Operators: UInt16 ToUInt16[T](T)
+Microsoft.FSharp.Core.Operators: UInt32 ToUInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], T)
+Microsoft.FSharp.Core.Operators: UInt32 ToUInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], T)
+Microsoft.FSharp.Core.Operators: UInt32 ToUInt32[T](T)
+Microsoft.FSharp.Core.Operators: UInt32 ToUInt[T](T)
+Microsoft.FSharp.Core.Operators: UInt64 ToUInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt64], T)
+Microsoft.FSharp.Core.Operators: UInt64 ToUInt64[T](T)
+Microsoft.FSharp.Core.Operators: UIntPtr ToUIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UIntPtr], T)
+Microsoft.FSharp.Core.Operators: UIntPtr ToUIntPtr[T](T)
+Microsoft.FSharp.Core.Operators: Void Decrement(Microsoft.FSharp.Core.FSharpRef`1[System.Int32])
+Microsoft.FSharp.Core.Operators: Void Ignore[T](T)
+Microsoft.FSharp.Core.Operators: Void Increment(Microsoft.FSharp.Core.FSharpRef`1[System.Int32])
+Microsoft.FSharp.Core.Operators: Void op_ColonEquals[T](Microsoft.FSharp.Core.FSharpRef`1[T], T)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: FSharpFunc`3 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]])
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult] Invoke(T1)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: TResult Invoke(T1, T2)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: Void .ctor()
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: FSharpFunc`4 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]])
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]] Invoke(T1)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: TResult Invoke(T1, T2, T3)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: Void .ctor()
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: FSharpFunc`5 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]]])
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]] Invoke(T1)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: TResult Invoke(T1, T2, T3, T4)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: Void .ctor()
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: FSharpFunc`6 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]]])
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]] Invoke(T1)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: TResult Invoke(T1, T2, T3, T4, T5)
+Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: Void .ctor()
+Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]
+Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]
+Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]
+Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]
+Microsoft.FSharp.Core.OptionModule: Boolean Contains[T](T, Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Boolean IsNone[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Boolean IsSome[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Int32 Count[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], Microsoft.FSharp.Core.FSharpOption`1[T1], Microsoft.FSharp.Core.FSharpOption`1[T2])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], Microsoft.FSharp.Core.FSharpOption`1[T1], Microsoft.FSharp.Core.FSharpOption`1[T2], Microsoft.FSharp.Core.FSharpOption`1[T3])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] Flatten[T](Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpOption`1[T]])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OfNullable[T](System.Nullable`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OfObj[T](T)
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OrElseWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.FSharpOption`1[T]], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OrElse[T](Microsoft.FSharp.Core.FSharpOption`1[T], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: System.Nullable`1[T] ToNullable[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: T DefaultValue[T](T, Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: T DefaultWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: T GetValue[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: T ToObj[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Core.FSharpOption`1[T], TState)
+Microsoft.FSharp.Core.OptionModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: T[] ToArray[T](Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[T])
+Microsoft.FSharp.Core.OptionalArgumentAttribute: Void .ctor()
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Object[] Captures
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Object[] get_Captures()
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.String ToString()
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.String Value
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.String get_Value()
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Type[] CaptureTypes
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Type[] get_CaptureTypes()
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: Void .ctor(System.String)
+Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: Void .ctor(System.String, System.Object[], System.Type[])
+Microsoft.FSharp.Core.PrintfFormat`5[TPrinter,TState,TResidue,TResult,TTuple]: Void .ctor(System.String)
+Microsoft.FSharp.Core.PrintfFormat`5[TPrinter,TState,TResidue,TResult,TTuple]: Void .ctor(System.String, System.Object[], System.Type[])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatLineToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatLineToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatLine[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[System.String,TResult], Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringBuilderThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], System.Text.StringBuilder, Microsoft.FSharp.Core.PrintfFormat`4[T,System.Text.StringBuilder,Microsoft.FSharp.Core.Unit,TResult])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringBuilder[T](System.Text.StringBuilder, Microsoft.FSharp.Core.PrintfFormat`4[T,System.Text.StringBuilder,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringThenFail[T,TResult](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[System.String,TResult], Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringThen[T](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,System.String])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToTextWriterThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,TResult])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormatToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.PrintfModule: T PrintFormat[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Core.ProjectionParameterAttribute: Void .ctor()
+Microsoft.FSharp.Core.ReferenceEqualityAttribute: Void .ctor()
+Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Boolean IncludeValue
+Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Boolean get_IncludeValue()
+Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Void .ctor()
+Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Void .ctor(Boolean)
+Microsoft.FSharp.Core.RequireQualifiedAccessAttribute: Void .ctor()
+Microsoft.FSharp.Core.RequiresExplicitTypeArgumentsAttribute: Void .ctor()
+Microsoft.FSharp.Core.ResultModule: Boolean Contains[T,TError](T, Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Boolean Exists[T,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Boolean ForAll[T,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Boolean IsError[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Boolean IsOk[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Int32 Count[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpOption`1[T] ToOption[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpResult`2[T,TResult] MapError[TError,TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[TError,TResult], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpResult`2[TResult,TError] Bind[T,TResult,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpResult`2[TResult,TError]], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpResult`2[TResult,TError] Map[T,TResult,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpValueOption`1[T] ToValueOption[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: T DefaultValue[T,TError](T, Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: T DefaultWith[TError,T](Microsoft.FSharp.Core.FSharpFunc`2[TError,T], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: TState FoldBack[T,TError,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Core.FSharpResult`2[T,TError], TState)
+Microsoft.FSharp.Core.ResultModule: TState Fold[T,TError,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: T[] ToArray[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.ResultModule: Void Iterate[T,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
+Microsoft.FSharp.Core.SealedAttribute: Boolean Value
+Microsoft.FSharp.Core.SealedAttribute: Boolean get_Value()
+Microsoft.FSharp.Core.SealedAttribute: Void .ctor()
+Microsoft.FSharp.Core.SealedAttribute: Void .ctor(Boolean)
+Microsoft.FSharp.Core.SourceConstructFlags: Int32 value__
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Closure
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Exception
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Field
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags KindMask
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Module
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags NonPublicRepresentation
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags None
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags ObjectType
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags RecordType
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags SumType
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags UnionCase
+Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Value
+Microsoft.FSharp.Core.StringModule: Boolean Exists(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Boolean], System.String)
+Microsoft.FSharp.Core.StringModule: Boolean ForAll(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Boolean], System.String)
+Microsoft.FSharp.Core.StringModule: Int32 Length(System.String)
+Microsoft.FSharp.Core.StringModule: System.String Collect(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.String], System.String)
+Microsoft.FSharp.Core.StringModule: System.String Concat(System.String, System.Collections.Generic.IEnumerable`1[System.String])
+Microsoft.FSharp.Core.StringModule: System.String Filter(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Boolean], System.String)
+Microsoft.FSharp.Core.StringModule: System.String Initialize(Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.String])
+Microsoft.FSharp.Core.StringModule: System.String Map(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Char], System.String)
+Microsoft.FSharp.Core.StringModule: System.String MapIndexed(Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Char]], System.String)
+Microsoft.FSharp.Core.StringModule: System.String Replicate(Int32, System.String)
+Microsoft.FSharp.Core.StringModule: Void Iterate(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,Microsoft.FSharp.Core.Unit], System.String)
+Microsoft.FSharp.Core.StringModule: Void IterateIndexed(Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Char,Microsoft.FSharp.Core.Unit]], System.String)
+Microsoft.FSharp.Core.StructAttribute: Void .ctor()
+Microsoft.FSharp.Core.StructuralComparisonAttribute: Void .ctor()
+Microsoft.FSharp.Core.StructuralEqualityAttribute: Void .ctor()
+Microsoft.FSharp.Core.StructuredFormatDisplayAttribute: System.String Value
+Microsoft.FSharp.Core.StructuredFormatDisplayAttribute: System.String get_Value()
+Microsoft.FSharp.Core.StructuredFormatDisplayAttribute: Void .ctor(System.String)
+Microsoft.FSharp.Core.Unit: Boolean Equals(System.Object)
+Microsoft.FSharp.Core.Unit: Int32 GetHashCode()
+Microsoft.FSharp.Core.UnverifiableAttribute: Void .ctor()
+Microsoft.FSharp.Core.ValueOption: Boolean Contains[T](T, Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Boolean IsNone[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Boolean IsSome[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Int32 Count[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpValueOption`1[TResult]], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], Microsoft.FSharp.Core.FSharpValueOption`1[T1], Microsoft.FSharp.Core.FSharpValueOption`1[T2])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], Microsoft.FSharp.Core.FSharpValueOption`1[T1], Microsoft.FSharp.Core.FSharpValueOption`1[T2], Microsoft.FSharp.Core.FSharpValueOption`1[T3])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] Flatten[T](Microsoft.FSharp.Core.FSharpValueOption`1[Microsoft.FSharp.Core.FSharpValueOption`1[T]])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OfNullable[T](System.Nullable`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OfObj[T](T)
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OrElseWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.FSharpValueOption`1[T]], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OrElse[T](Microsoft.FSharp.Core.FSharpValueOption`1[T], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: System.Nullable`1[T] ToNullable[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: T DefaultValue[T](T, Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: T DefaultWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: T GetValue[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: T ToObj[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Core.FSharpValueOption`1[T], TState)
+Microsoft.FSharp.Core.ValueOption: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: T[] ToArray[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.ValueOption: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpValueOption`1[T])
+Microsoft.FSharp.Core.VolatileFieldAttribute: Void .ctor()
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToByte[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToUInt8$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToUInt8[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Char] ToChar$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Char], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Char] ToChar[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Decimal] ToDecimal$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Decimal], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Decimal] ToDecimal[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToDouble$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToDouble[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToFloat$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToFloat[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int16] ToInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int16], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int16] ToInt16[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt32[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int64] ToInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int64], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int64] ToInt64[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.IntPtr] ToIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.IntPtr], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.IntPtr] ToIntPtr[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToInt8$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToInt8[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToSByte[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToFloat32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToFloat32[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToSingle$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToSingle[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt16] ToUInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt16], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt16] ToUInt16[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt32[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt64] ToUInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt64], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt64] ToUInt64[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UIntPtr] ToUIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UIntPtr], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UIntPtr] ToUIntPtr[T](System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[TResult] ToEnum[TResult](System.Nullable`1[System.Int32])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_EqualsQmark[T](T, System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_GreaterEqualsQmark[T](T, System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_GreaterQmark[T](T, System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_LessEqualsQmark[T](T, System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_LessGreaterQmark[T](T, System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_LessQmark[T](T, System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkEqualsQmark[T](System.Nullable`1[T], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkEquals[T](System.Nullable`1[T], T)
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreaterEqualsQmark[T](System.Nullable`1[T], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreaterEquals[T](System.Nullable`1[T], T)
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreaterQmark[T](System.Nullable`1[T], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreater[T](System.Nullable`1[T], T)
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessEqualsQmark[T](System.Nullable`1[T], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessEquals[T](System.Nullable`1[T], T)
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessGreaterQmark[T](System.Nullable`1[T], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessGreater[T](System.Nullable`1[T], T)
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessQmark[T](System.Nullable`1[T], System.Nullable`1[T])
+Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLess[T](System.Nullable`1[T], T)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_DivideQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_DivideQmark[T1,T2,T3](T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MinusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MinusQmark[T1,T2,T3](T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MultiplyQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MultiplyQmark[T1,T2,T3](T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PercentQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PercentQmark[T1,T2,T3](T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PlusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PlusQmark[T1,T2,T3](T1, System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivide$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivideQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivideQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivide[T1,T2,T3](System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinus$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinusQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinus[T1,T2,T3](System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiply$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiplyQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiplyQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiply[T1,T2,T3](System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercent$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercentQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercentQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercent[T1,T2,T3](System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlus$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlusQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2])
+Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlus[T1,T2,T3](System.Nullable`1[T1], T2)
+Microsoft.FSharp.Linq.QueryBuilder: Boolean All[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
+Microsoft.FSharp.Linq.QueryBuilder: Boolean Contains[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], T)
+Microsoft.FSharp.Linq.QueryBuilder: Boolean Exists[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
+Microsoft.FSharp.Linq.QueryBuilder: Int32 Count[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[System.Linq.IGrouping`2[TKey,TValue],Q] GroupValBy[T,TKey,TValue,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[System.Linq.IGrouping`2[TKey,T],Q] GroupBy[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Distinct[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SkipWhile[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Skip[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Int32)
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortByDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortByNullableDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortByNullable[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortBy[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Source[T,Q](System.Linq.IQueryable`1[T])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] TakeWhile[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Take[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Int32)
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenByDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenByNullableDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenByNullable[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenBy[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Where[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] YieldFrom[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Yield[T,Q](T)
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Zero[T,Q]()
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,System.Collections.IEnumerable] Source[T](System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] For[T,Q,TResult,Q2](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Linq.QuerySource`2[TResult,Q2]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] GroupJoin[TOuter,Q,TInner,TKey,TResult](Microsoft.FSharp.Linq.QuerySource`2[TOuter,Q], Microsoft.FSharp.Linq.QuerySource`2[TInner,Q], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TInner,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,Microsoft.FSharp.Core.FSharpFunc`2[System.Collections.Generic.IEnumerable`1[TInner],TResult]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] Join[TOuter,Q,TInner,TKey,TResult](Microsoft.FSharp.Linq.QuerySource`2[TOuter,Q], Microsoft.FSharp.Linq.QuerySource`2[TInner,Q], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TInner,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,Microsoft.FSharp.Core.FSharpFunc`2[TInner,TResult]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] LeftOuterJoin[TOuter,Q,TInner,TKey,TResult](Microsoft.FSharp.Linq.QuerySource`2[TOuter,Q], Microsoft.FSharp.Linq.QuerySource`2[TInner,Q], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TInner,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,Microsoft.FSharp.Core.FSharpFunc`2[System.Collections.Generic.IEnumerable`1[TInner],TResult]])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] Select[T,Q,TResult](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
+Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Quotations.FSharpExpr`1[T] Quote[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T])
+Microsoft.FSharp.Linq.QueryBuilder: System.Linq.IQueryable`1[T] Run[T](Microsoft.FSharp.Quotations.FSharpExpr`1[Microsoft.FSharp.Linq.QuerySource`2[T,System.Linq.IQueryable]])
+Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] AverageByNullable$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TValue]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
+Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] AverageByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
+Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] MaxByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
+Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] MinByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
+Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] SumByNullable$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
+Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] SumByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
+Microsoft.FSharp.Linq.QueryBuilder: T ExactlyOneOrDefault[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: T ExactlyOne[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: T Find[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
+Microsoft.FSharp.Linq.QueryBuilder: T HeadOrDefault[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: T Head[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: T LastOrDefault[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: T Last[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
+Microsoft.FSharp.Linq.QueryBuilder: T Nth[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Int32)
+Microsoft.FSharp.Linq.QueryBuilder: TValue AverageBy$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TValue]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
+Microsoft.FSharp.Linq.QueryBuilder: TValue AverageBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
+Microsoft.FSharp.Linq.QueryBuilder: TValue MaxBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
+Microsoft.FSharp.Linq.QueryBuilder: TValue MinBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
+Microsoft.FSharp.Linq.QueryBuilder: TValue SumBy$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
+Microsoft.FSharp.Linq.QueryBuilder: TValue SumBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
+Microsoft.FSharp.Linq.QueryBuilder: Void .ctor()
+Microsoft.FSharp.Linq.QueryRunExtensions.HighPriority: System.Collections.Generic.IEnumerable`1[T] RunQueryAsEnumerable[T](Microsoft.FSharp.Linq.QueryBuilder, Microsoft.FSharp.Quotations.FSharpExpr`1[Microsoft.FSharp.Linq.QuerySource`2[T,System.Collections.IEnumerable]])
+Microsoft.FSharp.Linq.QueryRunExtensions.LowPriority: T RunQueryAsValue[T](Microsoft.FSharp.Linq.QueryBuilder, Microsoft.FSharp.Quotations.FSharpExpr`1[T])
+Microsoft.FSharp.Linq.QuerySource`2[T,Q]: System.Collections.Generic.IEnumerable`1[T] Source
+Microsoft.FSharp.Linq.QuerySource`2[T,Q]: System.Collections.Generic.IEnumerable`1[T] get_Source()
+Microsoft.FSharp.Linq.QuerySource`2[T,Q]: Void .ctor(System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`1[T1]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`1[T1]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`1[T1]: Void .ctor(T1)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: Void .ctor(T1, T2)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T3 Item3
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T3 get_Item3()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: Void .ctor(T1, T2, T3)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T3 Item3
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T3 get_Item3()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T4 Item4
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T4 get_Item4()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: Void .ctor(T1, T2, T3, T4)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T3 Item3
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T3 get_Item3()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T4 Item4
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T4 get_Item4()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T5 Item5
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T5 get_Item5()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: Void .ctor(T1, T2, T3, T4, T5)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T3 Item3
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T3 get_Item3()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T4 Item4
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T4 get_Item4()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T5 Item5
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T5 get_Item5()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T6 Item6
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T6 get_Item6()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: Void .ctor(T1, T2, T3, T4, T5, T6)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T3 Item3
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T3 get_Item3()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T4 Item4
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T4 get_Item4()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T5 Item5
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T5 get_Item5()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T6 Item6
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T6 get_Item6()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T7 Item7
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T7 get_Item7()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: Void .ctor(T1, T2, T3, T4, T5, T6, T7)
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T1 Item1
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T1 get_Item1()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T2 Item2
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T2 get_Item2()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T3 Item3
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T3 get_Item3()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T4 Item4
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T4 get_Item4()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T5 Item5
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T5 get_Item5()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T6 Item6
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T6 get_Item6()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T7 Item7
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T7 get_Item7()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T8 Item8
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T8 get_Item8()
+Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: Void .ctor(T1, T2, T3, T4, T5, T6, T7, T8)
+Microsoft.FSharp.Linq.RuntimeHelpers.Grouping`2[K,T]: Void .ctor(K, System.Collections.Generic.IEnumerable`1[T])
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: Microsoft.FSharp.Quotations.FSharpExpr SubstHelperRaw(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar[], System.Object[])
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: Microsoft.FSharp.Quotations.FSharpExpr`1[T] SubstHelper[T](Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar[], System.Object[])
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Linq.Expressions.Expression QuotationToExpression(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Linq.Expressions.Expression`1[T] ImplicitExpressionConversionHelper[T](T)
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Linq.Expressions.Expression`1[T] QuotationToLambdaExpression[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T])
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Object EvaluateQuotation(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: T MemberInitializationHelper[T](T)
+Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: T NewAnonymousObjectHelper[T](T)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Boolean IsNullPointer[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr AddPointerInlined[T](IntPtr, Int32)
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr NullPointer[T]()
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr OfILSigPtrInlined[T](T*)
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr OfNativeIntInlined[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr OfVoidPtrInlined[T](Void*)
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr StackAllocate[T](Int32)
+Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr ToNativeIntInlined[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: T GetPointerInlined[T](IntPtr, Int32)
+Microsoft.FSharp.NativeInterop.NativePtrModule: T ReadPointerInlined[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: T& ToByRefInlined[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: T* ToILSigPtrInlined[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void ClearPointerInlined[T](IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void CopyBlockInlined[T](IntPtr, IntPtr, Int32)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void CopyPointerInlined[T](IntPtr, IntPtr)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void InitializeBlockInlined[T](IntPtr, Byte, UInt32)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void SetPointerInlined[T](IntPtr, Int32, T)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void WritePointerInlined[T](IntPtr, T)
+Microsoft.FSharp.NativeInterop.NativePtrModule: Void* ToVoidPtrInlined[T](IntPtr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],Microsoft.FSharp.Collections.FSharpList`1[System.Type],Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]]] SpecificCallPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] UnitPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] MethodWithReflectedDefinitionPattern(System.Reflection.MethodBase)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] PropertyGetterWithReflectedDefinitionPattern(System.Reflection.PropertyInfo)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] PropertySetterWithReflectedDefinitionPattern(System.Reflection.PropertyInfo)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Boolean] BoolPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Byte] BytePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Char] CharPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Decimal] DecimalPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Double] DoublePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int16] Int16Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] Int32Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int64] Int64Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.SByte] SBytePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Single] SinglePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.String] StringPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpVar]],Microsoft.FSharp.Quotations.FSharpExpr]] LambdasPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]]] ApplicationsPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] AndAlsoPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] OrElsePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.UInt16] UInt16Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.UInt32] UInt32Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.UInt64] UInt64Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.ExprShapeModule: Microsoft.FSharp.Core.FSharpChoice`3[Microsoft.FSharp.Quotations.FSharpVar,System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr],System.Tuple`2[System.Object,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] ShapePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.ExprShapeModule: Microsoft.FSharp.Quotations.FSharpExpr RebuildShapeCombination(System.Object, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Boolean Equals(System.Object)
+Microsoft.FSharp.Quotations.FSharpExpr: Int32 GetHashCode()
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr] CustomAttributes
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr] get_CustomAttributes()
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] TryGetReflectedDefinition(System.Reflection.MethodBase)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr AddressOf(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr AddressSet(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Application(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Applications(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Call(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Call(System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr CallWithWitnesses(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.MethodInfo, System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr], Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr CallWithWitnesses(System.Reflection.MethodInfo, System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr], Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Coerce(Microsoft.FSharp.Quotations.FSharpExpr, System.Type)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr DefaultValue(System.Type)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Deserialize(System.Type, Microsoft.FSharp.Collections.FSharpList`1[System.Type], Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr], Byte[])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Deserialize40(System.Type, System.Type[], System.Type[], Microsoft.FSharp.Quotations.FSharpExpr[], Byte[])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldGet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.FieldInfo)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldGet(System.Reflection.FieldInfo)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldSet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.FieldInfo, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldSet(System.Reflection.FieldInfo, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr ForIntegerRangeLoop(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr IfThenElse(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Lambda(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Let(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr LetRecursive(Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]], Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewArray(System.Type, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewDelegate(System.Type, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpVar], Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewObject(System.Reflection.ConstructorInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewRecord(System.Type, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewStructTuple(System.Reflection.Assembly, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewTuple(Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewUnionCase(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertyGet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.PropertyInfo, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertyGet(System.Reflection.PropertyInfo, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertySet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.PropertyInfo, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertySet(System.Reflection.PropertyInfo, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Quote(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr QuoteRaw(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr QuoteTyped(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Sequential(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Substitute(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr]])
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TryFinally(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TryWith(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TupleGet(Microsoft.FSharp.Quotations.FSharpExpr, Int32)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TypeTest(Microsoft.FSharp.Quotations.FSharpExpr, System.Type)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr UnionCaseTest(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Reflection.UnionCaseInfo)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Value(System.Object, System.Type)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr ValueWithName(System.Object, System.Type, System.String)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr ValueWithName[T](T, System.String)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Value[T](T)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Var(Microsoft.FSharp.Quotations.FSharpVar)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr VarSet(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr WhileLoop(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr WithValue(System.Object, System.Type, Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr`1[T] Cast[T](Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr`1[T] GlobalVar[T](System.String)
+Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr`1[T] WithValue[T](T, Microsoft.FSharp.Quotations.FSharpExpr`1[T])
+Microsoft.FSharp.Quotations.FSharpExpr: System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Quotations.FSharpVar] GetFreeVars()
+Microsoft.FSharp.Quotations.FSharpExpr: System.String ToString()
+Microsoft.FSharp.Quotations.FSharpExpr: System.String ToString(Boolean)
+Microsoft.FSharp.Quotations.FSharpExpr: System.Type Type
+Microsoft.FSharp.Quotations.FSharpExpr: System.Type get_Type()
+Microsoft.FSharp.Quotations.FSharpExpr: Void RegisterReflectedDefinitions(System.Reflection.Assembly, System.String, Byte[])
+Microsoft.FSharp.Quotations.FSharpExpr: Void RegisterReflectedDefinitions(System.Reflection.Assembly, System.String, Byte[], System.Type[])
+Microsoft.FSharp.Quotations.FSharpExpr`1[T]: Microsoft.FSharp.Quotations.FSharpExpr Raw
+Microsoft.FSharp.Quotations.FSharpExpr`1[T]: Microsoft.FSharp.Quotations.FSharpExpr get_Raw()
+Microsoft.FSharp.Quotations.FSharpVar: Boolean Equals(System.Object)
+Microsoft.FSharp.Quotations.FSharpVar: Boolean IsMutable
+Microsoft.FSharp.Quotations.FSharpVar: Boolean get_IsMutable()
+Microsoft.FSharp.Quotations.FSharpVar: Int32 GetHashCode()
+Microsoft.FSharp.Quotations.FSharpVar: Microsoft.FSharp.Quotations.FSharpVar Global(System.String, System.Type)
+Microsoft.FSharp.Quotations.FSharpVar: System.String Name
+Microsoft.FSharp.Quotations.FSharpVar: System.String ToString()
+Microsoft.FSharp.Quotations.FSharpVar: System.String get_Name()
+Microsoft.FSharp.Quotations.FSharpVar: System.Type Type
+Microsoft.FSharp.Quotations.FSharpVar: System.Type get_Type()
+Microsoft.FSharp.Quotations.FSharpVar: Void .ctor(System.String, System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]] NewStructTuplePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]] NewTuplePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] AddressOfPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] QuotePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] QuoteRawPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] QuoteTypedPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpVar] VarPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]],Microsoft.FSharp.Quotations.FSharpExpr]] LetRecursivePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.FieldInfo]] FieldGetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] AddressSetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] ApplicationPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] SequentialPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] TryFinallyPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] WhileLoopPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Reflection.UnionCaseInfo]] UnionCaseTestPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,System.Int32]] TupleGetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,System.Type]] CoercePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,System.Type]] TypeTestPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]] LambdaPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]] VarSetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Reflection.UnionCaseInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewUnionCasePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Object,System.Type]] ValuePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Reflection.ConstructorInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewObjectPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Type,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewArrayPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Type,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewRecordPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.FieldInfo,Microsoft.FSharp.Quotations.FSharpExpr]] FieldSetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.MethodInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] CallPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.PropertyInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] PropertyGetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] IfThenElsePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] LetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Object,System.Type,Microsoft.FSharp.Quotations.FSharpExpr]] WithValuePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Object,System.Type,System.String]] ValueWithNamePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Type,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpVar],Microsoft.FSharp.Quotations.FSharpExpr]] NewDelegatePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`4[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.PropertyInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr],Microsoft.FSharp.Quotations.FSharpExpr]] PropertySetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`4[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] ForIntegerRangeLoopPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`5[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.MethodInfo,System.Reflection.MethodInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr],Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] CallWithWitnessesPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`5[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]] TryWithPattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Type] DefaultValuePattern(Microsoft.FSharp.Quotations.FSharpExpr)
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Boolean FSharpType.IsExceptionRepresentation.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Boolean FSharpType.IsRecord.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Boolean FSharpType.IsUnion.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Int32] FSharpValue.PreComputeUnionTagReader.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] FSharpValue.PreComputeRecordReader.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] FSharpValue.PreComputeUnionReader.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] FSharpValue.PreComputeRecordConstructor.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] FSharpValue.PreComputeUnionConstructor.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Reflection.UnionCaseInfo[] FSharpType.GetUnionCases.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object FSharpValue.MakeRecord.Static(System.Type, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object FSharpValue.MakeUnion.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object[] FSharpValue.GetExceptionFields.Static(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object[] FSharpValue.GetRecordFields.Static(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.ConstructorInfo FSharpValue.PreComputeRecordConstructorInfo.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.MemberInfo FSharpValue.PreComputeUnionTagMemberInfo.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.MethodInfo FSharpValue.PreComputeUnionConstructorInfo.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.PropertyInfo[] FSharpType.GetExceptionFields.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.PropertyInfo[] FSharpType.GetRecordFields.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Tuple`2[Microsoft.FSharp.Reflection.UnionCaseInfo,System.Object[]] FSharpValue.GetUnionFields.Static(System.Object, System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
+Microsoft.FSharp.Reflection.FSharpType: Boolean IsExceptionRepresentation(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpType: Boolean IsFunction(System.Type)
+Microsoft.FSharp.Reflection.FSharpType: Boolean IsModule(System.Type)
+Microsoft.FSharp.Reflection.FSharpType: Boolean IsRecord(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpType: Boolean IsTuple(System.Type)
+Microsoft.FSharp.Reflection.FSharpType: Boolean IsUnion(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpType: Microsoft.FSharp.Reflection.UnionCaseInfo[] GetUnionCases(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpType: System.Reflection.PropertyInfo[] GetExceptionFields(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpType: System.Reflection.PropertyInfo[] GetRecordFields(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpType: System.Tuple`2[System.Type,System.Type] GetFunctionElements(System.Type)
+Microsoft.FSharp.Reflection.FSharpType: System.Type MakeFunctionType(System.Type, System.Type)
+Microsoft.FSharp.Reflection.FSharpType: System.Type MakeStructTupleType(System.Reflection.Assembly, System.Type[])
+Microsoft.FSharp.Reflection.FSharpType: System.Type MakeTupleType(System.Reflection.Assembly, System.Type[])
+Microsoft.FSharp.Reflection.FSharpType: System.Type MakeTupleType(System.Type[])
+Microsoft.FSharp.Reflection.FSharpType: System.Type[] GetTupleElements(System.Type)
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Int32] PreComputeUnionTagReader(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] PreComputeRecordReader(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] PreComputeTupleReader(System.Type)
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] PreComputeUnionReader(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object] PreComputeRecordFieldReader(System.Reflection.PropertyInfo)
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] PreComputeRecordConstructor(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] PreComputeTupleConstructor(System.Type)
+Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] PreComputeUnionConstructor(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Object GetRecordField(System.Object, System.Reflection.PropertyInfo)
+Microsoft.FSharp.Reflection.FSharpValue: System.Object GetTupleField(System.Object, Int32)
+Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeFunction(System.Type, Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object])
+Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeRecord(System.Type, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeTuple(System.Object[], System.Type)
+Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeUnion(Microsoft.FSharp.Reflection.UnionCaseInfo, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Object[] GetExceptionFields(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Object[] GetRecordFields(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Object[] GetTupleFields(System.Object)
+Microsoft.FSharp.Reflection.FSharpValue: System.Reflection.ConstructorInfo PreComputeRecordConstructorInfo(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Reflection.MemberInfo PreComputeUnionTagMemberInfo(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Reflection.MethodInfo PreComputeUnionConstructorInfo(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Tuple`2[Microsoft.FSharp.Reflection.UnionCaseInfo,System.Object[]] GetUnionFields(System.Object, System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
+Microsoft.FSharp.Reflection.FSharpValue: System.Tuple`2[System.Reflection.ConstructorInfo,Microsoft.FSharp.Core.FSharpOption`1[System.Type]] PreComputeTupleConstructorInfo(System.Type)
+Microsoft.FSharp.Reflection.FSharpValue: System.Tuple`2[System.Reflection.PropertyInfo,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Type,System.Int32]]] PreComputeTuplePropertyInfo(System.Type, Int32)
+Microsoft.FSharp.Reflection.UnionCaseInfo: Boolean Equals(System.Object)
+Microsoft.FSharp.Reflection.UnionCaseInfo: Int32 GetHashCode()
+Microsoft.FSharp.Reflection.UnionCaseInfo: Int32 Tag
+Microsoft.FSharp.Reflection.UnionCaseInfo: Int32 get_Tag()
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Collections.Generic.IList`1[System.Reflection.CustomAttributeData] GetCustomAttributesData()
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Object[] GetCustomAttributes()
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Object[] GetCustomAttributes(System.Type)
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Reflection.PropertyInfo[] GetFields()
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.String Name
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.String ToString()
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.String get_Name()
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type DeclaringType
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type get_DeclaringType()
\ No newline at end of file
diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core.UnitTests.fsproj b/tests/FSharp.Core.UnitTests/FSharp.Core.UnitTests.fsproj
index eaa3a0c4165..9d0db234965 100644
--- a/tests/FSharp.Core.UnitTests/FSharp.Core.UnitTests.fsproj
+++ b/tests/FSharp.Core.UnitTests/FSharp.Core.UnitTests.fsproj
@@ -31,7 +31,6 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <Compile Include="..\fsharp\TestHelpers.fs" Link="TestHelpers.fs" />
     <Compile Include="TestFrameworkHelpers.fs" />
     <Compile Include="LibraryTestFx.fs" />
     <Compile Include="FSharp.Core\PrimTypes.fs" />
@@ -91,7 +90,6 @@
     <Compile Include="FSharp.Core\Microsoft.FSharp.Control\EventModule.fs" />
     <Compile Include="FSharp.Core\Microsoft.FSharp.Reflection\FSharpReflection.fs" />
     <Compile Include="FSharp.Core\Microsoft.FSharp.Quotations\FSharpQuotations.fs" />
-    <Compile Include="TypeForwarding.fs" />
     <Compile Include="StructTuples.fs" />
     <Compile Include="SurfaceArea.fs" />
   </ItemGroup>
@@ -103,6 +101,7 @@
 
   <ItemGroup>
     <ProjectReference Include="$(FSharpSourcesRoot)\FSharp.Core\FSharp.Core.fsproj" />
+    <ProjectReference Include="$(FSharpSourcesRoot)\..\tests\FSharp.Test.Utilities\FSharp.Test.Utilities.fsproj" />
     <PackageReference Include="FsCheck" Version="$(FsCheckVersion)" />
   </ItemGroup>
 </Project>
diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core/ComparersRegression.fs b/tests/FSharp.Core.UnitTests/FSharp.Core/ComparersRegression.fs
index 817d1fcc473..a0bb9eddb63 100644
--- a/tests/FSharp.Core.UnitTests/FSharp.Core/ComparersRegression.fs
+++ b/tests/FSharp.Core.UnitTests/FSharp.Core/ComparersRegression.fs
@@ -1628,114 +1628,114 @@ module ComparersRegression =
         static member I = inlinable
         static member N = noninlinable
 
-#if !NETSTANDARD1_6 && !NETCOREAPP
-    let create<'a,'b when 'b : equality> name operation (f:IOperation<'a>) (items:array<'a>) =
-        printf """ [<Fact>]
- member _.``%s %s``() =
-  validate (%s) %s """ name operation name operation
-
-        make_result_set f items None
-        |> Seq.iteri (fun n result ->
-            if n = 0 
-                then printf "[|"
-                else printf ";"
-            if n % 40 = 0 then printf "\n   "
-            printf "%d" result)
-        printfn "\n  |]\n"
-
-    let create_inequalities name (items:array<'a>) =
-        create name "C.I.equals"           C.I.equals           items
-        create name "C.I.equal"            C.I.equal            items
-        create name "C.I.not_equal"        C.I.not_equal        items
-        create name "C.I.compare"          C.I.compare          items
-        create name "C.I.less_than"        C.I.less_than        items
-        create name "C.I.less_or_equal"    C.I.less_or_equal    items
-        create name "C.I.greater_than"     C.I.greater_than     items
-        create name "C.I.greater_or_equal" C.I.greater_or_equal items
-        create name "C.N.equals"           C.N.equals           items
-        create name "C.N.equal"            C.N.equal            items
-        create name "C.N.not_equal"        C.N.not_equal        items
-        create name "C.N.compare"          C.N.compare          items
-        create name "C.N.less_than"        C.N.less_than        items
-        create name "C.N.less_or_equal"    C.N.less_or_equal    items
-        create name "C.N.greater_than"     C.N.greater_than     items
-        create name "C.N.greater_or_equal" C.N.greater_or_equal items
-
-    let create_equalities name (items:array<'a>) =
-        create name "E.I.equals"    E.I.equals    items
-        create name "E.I.equal"     E.I.equal     items
-        create name "E.I.not_equal" E.I.not_equal items
-        create name "E.N.equals"    E.N.equals    items
-        create name "E.N.equal"     E.N.equal     items
-        create name "E.N.not_equal" E.N.not_equal items
-
-    let create_collection_inequalities name (collection:Collection<_,_,_,_>) =
-        create_inequalities (name + ".Array")          collection.Array
-        create_inequalities (name + ".OptionArray")    collection.OptionArray
-        create_inequalities (name + ".RefArray")       collection.RefArray
-        create_inequalities (name + ".RefWrapArray")   collection.RefWrapArray
-        create_inequalities (name + ".UnionArray")     collection.UnionArray
-        create_inequalities (name + ".UnionWrapArray") collection.UnionWrapArray
-        create_inequalities (name + ".ValueArray")     collection.ValueArray
-        create_inequalities (name + ".ValueWrapArray") collection.ValueWrapArray
-        create_inequalities (name + ".ArrayArray")     collection.ArrayArray
-        create_inequalities (name + ".ListArray")      collection.ListArray
-        create_inequalities (name + ".ArrayArray |> Array.map Set.ofArray") (collection.ArrayArray |> Array.map Set.ofArray)
-
-    let create_tuples_tests name (collection:Collection<_,_,_,_>) =
-        create_inequalities (name + ".Array")          collection.Array
-
-    let create_collection_equalities name (collection:Collection<_,_,_,_>) =
-        create_equalities (name + ".Array")          collection.Array
-        create_equalities (name + ".OptionArray")    collection.OptionArray
-        create_equalities (name + ".RefArray")       collection.RefArray
-        create_equalities (name + ".RefWrapArray")   collection.RefWrapArray
-        create_equalities (name + ".UnionArray")     collection.UnionArray
-        create_equalities (name + ".UnionWrapArray") collection.UnionWrapArray
-        create_equalities (name + ".ValueArray")     collection.ValueArray
-        create_equalities (name + ".ValueWrapArray") collection.ValueWrapArray
-        create_equalities (name + ".ArrayArray")     collection.ArrayArray
-        create_equalities (name + ".ListArray")      collection.ListArray
-
-    let createData () =
-        create_collection_inequalities "Bools.Collection"               Bools.Collection
-        create_collection_equalities   "NullableBools.Collection"       NullableBools.Collection
-        create_collection_inequalities "SBytes.Collection"              SBytes.Collection
-        create_collection_equalities   "NullableSbytes.Collection"      NullableSbytes.Collection
-        create_collection_inequalities "Int16s.Collection"              Int16s.Collection
-        create_collection_equalities   "NullableInt16s.Collection"      NullableInt16s.Collection
-        create_collection_inequalities "Int32s.Collection"              Int32s.Collection
-        create_collection_equalities   "NullableInt32s.Collection"      NullableInt32s.Collection
-        create_collection_inequalities "Int64s.Collection"              Int64s.Collection
-        create_collection_equalities   "NullableInt64s.Collection"      NullableInt64s.Collection
-        create_collection_inequalities "NativeInts.Collection"          NativeInts.Collection
-        create_collection_equalities   "NullableNativeInts.Collection"  NullableNativeInts.Collection
-        create_collection_inequalities "Bytes.Collection"               Bytes.Collection
-        create_collection_equalities   "NullableBytes.Collection"       NullableBytes.Collection
-        create_collection_inequalities "Uint16s.Collection"             Uint16s.Collection
-        create_collection_equalities   "NullableUInt16s.Collection"     NullableUInt16s.Collection
-        create_collection_inequalities "UInt32s.Collection"             UInt32s.Collection
-        create_collection_equalities   "NullableUInt32s.Collection"     NullableUInt32s.Collection
-        create_collection_inequalities "UInt64s.Collection"             UInt64s.Collection
-        create_collection_equalities   "NullableUInt64s.Collection"     NullableUInt64s.Collection
-        create_collection_inequalities "UNativeInts.Collection"         UNativeInts.Collection
-        create_collection_equalities   "NullableUNativeInts.Collection" NullableUNativeInts.Collection
-        create_collection_inequalities "Chars.Collection"               Chars.Collection
-        create_collection_equalities   "NullableChars.Collection"       NullableChars.Collection
-        create_collection_inequalities "Strings.Collection"             Strings.Collection
-        create_collection_inequalities "Decimals.Collection"            Decimals.Collection
-        create_collection_equalities   "NullableDecimals.Collection"    NullableDecimals.Collection
-        create_collection_inequalities "Floats.Collection"              Floats.Collection
-        create_collection_equalities   "NullableFloats.Collection"      NullableFloats.Collection
-        create_collection_inequalities "Float32s.Collection"            Float32s.Collection
-        create_collection_equalities   "NullableFloat32s.Collection"    NullableFloat32s.Collection
-        create_collection_inequalities "DateTimes.Collection"           DateTimes.Collection
-        create_collection_equalities   "NullableDateTimes.Collection"   NullableDateTimes.Collection
-        create_collection_inequalities "Tuple2s.Collection"             Tuple2s.Collection
-        create_tuples_tests            "Tuple3s.Collection"             Tuple3s.Collection
-        create_tuples_tests            "Tuple4s.Collection"             Tuple4s.Collection
-        create_tuples_tests            "Tuple5s.Collection"             Tuple5s.Collection
-#endif
+    module TestGenerationMethods = 
+        let create<'a,'b when 'b : equality> name operation (f:IOperation<'a>) (items:array<'a>) =
+            printf """ [<Fact>]
+     member _.``%s %s``() =
+      validate (%s) %s """ name operation name operation
+
+            make_result_set f items None
+            |> Seq.iteri (fun n result ->
+                if n = 0 
+                    then printf "[|"
+                    else printf ";"
+                if n % 40 = 0 then printf "\n   "
+                printf "%d" result)
+            printfn "\n  |]\n"
+
+        let create_inequalities name (items:array<'a>) =
+            create name "C.I.equals"           C.I.equals           items
+            create name "C.I.equal"            C.I.equal            items
+            create name "C.I.not_equal"        C.I.not_equal        items
+            create name "C.I.compare"          C.I.compare          items
+            create name "C.I.less_than"        C.I.less_than        items
+            create name "C.I.less_or_equal"    C.I.less_or_equal    items
+            create name "C.I.greater_than"     C.I.greater_than     items
+            create name "C.I.greater_or_equal" C.I.greater_or_equal items
+            create name "C.N.equals"           C.N.equals           items
+            create name "C.N.equal"            C.N.equal            items
+            create name "C.N.not_equal"        C.N.not_equal        items
+            create name "C.N.compare"          C.N.compare          items
+            create name "C.N.less_than"        C.N.less_than        items
+            create name "C.N.less_or_equal"    C.N.less_or_equal    items
+            create name "C.N.greater_than"     C.N.greater_than     items
+            create name "C.N.greater_or_equal" C.N.greater_or_equal items
+
+        let create_equalities name (items:array<'a>) =
+            create name "E.I.equals"    E.I.equals    items
+            create name "E.I.equal"     E.I.equal     items
+            create name "E.I.not_equal" E.I.not_equal items
+            create name "E.N.equals"    E.N.equals    items
+            create name "E.N.equal"     E.N.equal     items
+            create name "E.N.not_equal" E.N.not_equal items
+
+        let create_collection_inequalities name (collection:Collection<_,_,_,_>) =
+            create_inequalities (name + ".Array")          collection.Array
+            create_inequalities (name + ".OptionArray")    collection.OptionArray
+            create_inequalities (name + ".RefArray")       collection.RefArray
+            create_inequalities (name + ".RefWrapArray")   collection.RefWrapArray
+            create_inequalities (name + ".UnionArray")     collection.UnionArray
+            create_inequalities (name + ".UnionWrapArray") collection.UnionWrapArray
+            create_inequalities (name + ".ValueArray")     collection.ValueArray
+            create_inequalities (name + ".ValueWrapArray") collection.ValueWrapArray
+            create_inequalities (name + ".ArrayArray")     collection.ArrayArray
+            create_inequalities (name + ".ListArray")      collection.ListArray
+            create_inequalities (name + ".ArrayArray |> Array.map Set.ofArray") (collection.ArrayArray |> Array.map Set.ofArray)
+
+        let create_tuples_tests name (collection:Collection<_,_,_,_>) =
+            create_inequalities (name + ".Array")          collection.Array
+
+        let create_collection_equalities name (collection:Collection<_,_,_,_>) =
+            create_equalities (name + ".Array")          collection.Array
+            create_equalities (name + ".OptionArray")    collection.OptionArray
+            create_equalities (name + ".RefArray")       collection.RefArray
+            create_equalities (name + ".RefWrapArray")   collection.RefWrapArray
+            create_equalities (name + ".UnionArray")     collection.UnionArray
+            create_equalities (name + ".UnionWrapArray") collection.UnionWrapArray
+            create_equalities (name + ".ValueArray")     collection.ValueArray
+            create_equalities (name + ".ValueWrapArray") collection.ValueWrapArray
+            create_equalities (name + ".ArrayArray")     collection.ArrayArray
+            create_equalities (name + ".ListArray")      collection.ListArray
+
+        let createData () =
+            create_collection_inequalities "Bools.Collection"               Bools.Collection
+            create_collection_equalities   "NullableBools.Collection"       NullableBools.Collection
+            create_collection_inequalities "SBytes.Collection"              SBytes.Collection
+            create_collection_equalities   "NullableSbytes.Collection"      NullableSbytes.Collection
+            create_collection_inequalities "Int16s.Collection"              Int16s.Collection
+            create_collection_equalities   "NullableInt16s.Collection"      NullableInt16s.Collection
+            create_collection_inequalities "Int32s.Collection"              Int32s.Collection
+            create_collection_equalities   "NullableInt32s.Collection"      NullableInt32s.Collection
+            create_collection_inequalities "Int64s.Collection"              Int64s.Collection
+            create_collection_equalities   "NullableInt64s.Collection"      NullableInt64s.Collection
+            create_collection_inequalities "NativeInts.Collection"          NativeInts.Collection
+            create_collection_equalities   "NullableNativeInts.Collection"  NullableNativeInts.Collection
+            create_collection_inequalities "Bytes.Collection"               Bytes.Collection
+            create_collection_equalities   "NullableBytes.Collection"       NullableBytes.Collection
+            create_collection_inequalities "Uint16s.Collection"             Uint16s.Collection
+            create_collection_equalities   "NullableUInt16s.Collection"     NullableUInt16s.Collection
+            create_collection_inequalities "UInt32s.Collection"             UInt32s.Collection
+            create_collection_equalities   "NullableUInt32s.Collection"     NullableUInt32s.Collection
+            create_collection_inequalities "UInt64s.Collection"             UInt64s.Collection
+            create_collection_equalities   "NullableUInt64s.Collection"     NullableUInt64s.Collection
+            create_collection_inequalities "UNativeInts.Collection"         UNativeInts.Collection
+            create_collection_equalities   "NullableUNativeInts.Collection" NullableUNativeInts.Collection
+            create_collection_inequalities "Chars.Collection"               Chars.Collection
+            create_collection_equalities   "NullableChars.Collection"       NullableChars.Collection
+            create_collection_inequalities "Strings.Collection"             Strings.Collection
+            create_collection_inequalities "Decimals.Collection"            Decimals.Collection
+            create_collection_equalities   "NullableDecimals.Collection"    NullableDecimals.Collection
+            create_collection_inequalities "Floats.Collection"              Floats.Collection
+            create_collection_equalities   "NullableFloats.Collection"      NullableFloats.Collection
+            create_collection_inequalities "Float32s.Collection"            Float32s.Collection
+            create_collection_equalities   "NullableFloat32s.Collection"    NullableFloat32s.Collection
+            create_collection_inequalities "DateTimes.Collection"           DateTimes.Collection
+            create_collection_equalities   "NullableDateTimes.Collection"   NullableDateTimes.Collection
+            create_collection_inequalities "Tuple2s.Collection"             Tuple2s.Collection
+            create_tuples_tests            "Tuple3s.Collection"             Tuple3s.Collection
+            create_tuples_tests            "Tuple4s.Collection"             Tuple4s.Collection
+            create_tuples_tests            "Tuple5s.Collection"             Tuple5s.Collection
+
 
     let validate (items:array<'a>) (f:IOperation<'a>) (expected:array<int>) =
         try
diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Collections/ListType.fs b/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Collections/ListType.fs
index fd78d5298f5..653f9b3a40b 100644
--- a/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Collections/ListType.fs
+++ b/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Collections/ListType.fs
@@ -120,6 +120,29 @@ type ListType() =
         Assert.AreEqual("[1; 2; 3]", [1; 2; 3].ToString())
         Assert.AreEqual("[]", [].ToString())
         Assert.AreEqual("[]", ([] : decimal list list).ToString())
+
+    [<Fact>]
+    member this.HashCodeNotThrowingStackOverflow() = 
+        let l = 1 :: 2 :: [0.. 35_000]
+        let hash = l.GetHashCode()
+
+        let l2 = [1;2] @ [0.. 35_000]
+        let hash2 = l.GetHashCode()
+
+        Assert.AreEqual(hash,hash2)
+
+    [<Fact>]
+    member this.HashCodeDoesNotThrowOnListOfNullStrings() = 
+        let l = ["1";"2";null;null]
+        Assert.AreEqual(l.GetHashCode(),l.GetHashCode())
+
+    [<Fact>]
+    member this.HashCodeIsDifferentForListsWithSamePrefix() = 
+        let sharedPrefix = [0..500]
+        let l1 = sharedPrefix @ [1]
+        let l2 = sharedPrefix @ [2]       
+
+        Assert.AreNotEqual(l1.GetHashCode(),l2.GetHashCode())
     
     [<Fact>]
     member this.ObjectEquals() =
diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Control/AsyncModule.fs b/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Control/AsyncModule.fs
index 2edf022ac75..a0ce3054224 100644
--- a/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Control/AsyncModule.fs
+++ b/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Control/AsyncModule.fs
@@ -453,15 +453,6 @@ type AsyncModule() =
     member _.``RaceBetweenCancellationAndError.Sleep``() =
         testErrorAndCancelRace "RaceBetweenCancellationAndError.Sleep" (Async.Sleep (-5))
 
-#if EXPENSIVE
-#if NET46
-    [<Test; Category("Expensive"); Explicit>] // takes 3 minutes!
-    member _.``Async.Choice specification test``() =
-        ThreadPool.SetMinThreads(100,100) |> ignore
-        Check.One ({Config.QuickThrowOnFailure with EndSize = 20}, normalize >> runChoice)
-#endif
-#endif
-
     [<Fact>]
     member _.``dispose should not throw when called on null``() =
         let result = async { use x = null in return () } |> Async.RunSynchronously
diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Control/Tasks.fs b/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Control/Tasks.fs
index 4af1df56d39..4ed91efb2fa 100644
--- a/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Control/Tasks.fs
+++ b/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Control/Tasks.fs
@@ -1160,6 +1160,22 @@ type Basics() =
         let result = t.Result
         require (result = 8) "something weird happened"
 
+    [<Fact>]
+    member _.testAsyncsMixedWithTasks_ShouldNotSwitchContext() =
+        let t = task {
+            let a = Thread.CurrentThread.ManagedThreadId
+            let! b = async {
+                return Thread.CurrentThread.ManagedThreadId
+            }
+            let c = Thread.CurrentThread.ManagedThreadId
+            return $"Before: {a}, in async: {b}, after async: {c}"
+        }
+        let d = Thread.CurrentThread.ManagedThreadId
+        let actual = $"{t.Result}, after task: {d}"
+
+        require (actual = $"Before: {d}, in async: {d}, after async: {d}, after task: {d}") actual
+        
+
     [<Fact>]
     // no need to call this, we just want to check that it compiles w/o warnings
     member _.testDefaultInferenceForReturnFrom() =
@@ -1390,5 +1406,4 @@ module Issue12184f =
             // The overload resolution for Bind commits to 'Task' via SRTP pattern since the type annotation is available
             let! result = t
             return result
-        }
-
+        }
\ No newline at end of file
diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Core/ExtraTopLevelOperatorsTests.fs b/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Core/ExtraTopLevelOperatorsTests.fs
index 147edbe1916..9c4379fd459 100644
--- a/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Core/ExtraTopLevelOperatorsTests.fs
+++ b/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Core/ExtraTopLevelOperatorsTests.fs
@@ -8,7 +8,7 @@ open System.Collections.Generic
 type DictTests () =
 
     [<Fact>]
-    member this.IEnumerable() =
+    member this.IEnumerableOnDict() =
         // Legit IE
         let ie = (dict [|(1,1);(2,4);(3,9)|]) :> IEnumerable
         let enum = ie.GetEnumerator()
@@ -38,7 +38,7 @@ type DictTests () =
         CheckThrowsInvalidOperationExn(fun () -> enum.Current |> ignore)
 
     [<Fact>]
-    member this.IEnumerable_T() =
+    member this.IEnumerable_T_OnDict() =
         // Legit IE
         let ie = (dict [|(1,1);(2,4);(3,9)|]) :> IEnumerable<KeyValuePair<_,_>>
         let enum = ie.GetEnumerator()
diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core/PrimTypes.fs b/tests/FSharp.Core.UnitTests/FSharp.Core/PrimTypes.fs
index ee2b662bfe5..018f7419c97 100644
--- a/tests/FSharp.Core.UnitTests/FSharp.Core/PrimTypes.fs
+++ b/tests/FSharp.Core.UnitTests/FSharp.Core/PrimTypes.fs
@@ -142,10 +142,6 @@ type LanguagePrimitivesModule() =
         let resultRef = LanguagePrimitives.GenericComparison "ABC" null
         Assert.AreEqual(1, resultRef)
 
-
-#if NETSTANDARD1_6 || NETCOREAPP
-// TODO named #define ?
-#else  
     [<Fact>]
     member this.GenericComparisonBiModal() =
         // value type
@@ -178,8 +174,6 @@ type LanguagePrimitivesModule() =
         let resultRef = LanguagePrimitives.GenericComparisonWithComparer System.Collections.Comparer.Default null "abc"
         Assert.AreEqual(-1, sign resultRef)
         
-#endif
-        
     [<Fact>]
     member this.GenericEquality() =
         // value type
@@ -202,6 +196,45 @@ type LanguagePrimitivesModule() =
 
         let resultNul = LanguagePrimitives.GenericEquality "ABC" null
         Assert.False(resultNul)
+
+    [<Fact>]
+    member _.GenericEqualityForNans() = 
+        Assert.DoesNotContain(true,
+            [| LanguagePrimitives.GenericEquality nan nan
+               LanguagePrimitives.GenericEquality [nan] [nan]
+               LanguagePrimitives.GenericEquality [|nan|] [|nan|]
+               LanguagePrimitives.GenericEquality (Set.ofList [nan]) (Set.ofList [nan])       
+               LanguagePrimitives.GenericEquality (Map.ofList [1,nan]) (Map.ofList [1,nan])
+               LanguagePrimitives.GenericEquality (Map.ofList [nan,1]) (Map.ofList [nan,1])
+               LanguagePrimitives.GenericEquality (Map.ofList [nan,nan]) (Map.ofList [nan,nan])
+               
+               LanguagePrimitives.GenericEquality nanf nanf
+               LanguagePrimitives.GenericEquality [nanf] [nanf]
+               LanguagePrimitives.GenericEquality [|nanf|] [|nanf|]
+               LanguagePrimitives.GenericEquality (Set.ofList [nanf]) (Set.ofList [nanf])          
+               LanguagePrimitives.GenericEquality (Map.ofList [1,nanf]) (Map.ofList [1,nanf])
+               LanguagePrimitives.GenericEquality (Map.ofList [nanf,1]) (Map.ofList [nanf,1])
+               LanguagePrimitives.GenericEquality (Map.ofList [nanf,nanf]) (Map.ofList [nanf,nanf])|])
+
+    [<Fact>]
+    member _.GenericEqualityER() = 
+        Assert.DoesNotContain(false,
+            [| LanguagePrimitives.GenericEqualityER nan nan
+               LanguagePrimitives.GenericEqualityER [nan] [nan]
+               LanguagePrimitives.GenericEqualityER [|nan|] [|nan|]
+               LanguagePrimitives.GenericEqualityER (Set.ofList [nan]) (Set.ofList [nan])        
+               LanguagePrimitives.GenericEqualityER (Map.ofList [1,nan]) (Map.ofList [1,nan])
+               LanguagePrimitives.GenericEqualityER (Map.ofList [nan,1]) (Map.ofList [nan,1])
+               LanguagePrimitives.GenericEqualityER (Map.ofList [nan,nan]) (Map.ofList [nan,nan])
+               
+               LanguagePrimitives.GenericEqualityER nanf nanf
+               LanguagePrimitives.GenericEqualityER [nanf] [nanf]
+               LanguagePrimitives.GenericEqualityER [|nanf|] [|nanf|]
+               LanguagePrimitives.GenericEqualityER (Set.ofList [nanf]) (Set.ofList [nanf])        
+               LanguagePrimitives.GenericEqualityER (Map.ofList [1,nanf]) (Map.ofList [1,nanf])
+               LanguagePrimitives.GenericEqualityER (Map.ofList [nanf,1]) (Map.ofList [nanf,1])
+               LanguagePrimitives.GenericEqualityER (Map.ofList [nanf,nanf]) (Map.ofList [nanf,nanf])|])
+        
         
     [<Fact>]
     member this.GenericGreaterOrEqual() =
@@ -696,9 +729,6 @@ type UnitType() =
         let u:Unit = ()
         CheckThrowsNullRefException(fun() ->u.Equals(null) |>ignore) 
 
-#if NETSTANDARD1_6 || NETCOREAPP
-// TODO named #define ?
-#else
 type SourceConstructFlagsEnum() =
 
     [<Fact>]
@@ -708,15 +738,12 @@ type SourceConstructFlagsEnum() =
                        "KindMask";"NonPublicRepresentation" |]
         Assert.AreEqual(names, SourceConstructFlags.GetNames(typeof<SourceConstructFlags>))
 
-
 type CompilationRepresentationFlagsEnum() =
 
     [<Fact>]
     member this.Getvalue() =
         let names = [| "None";"Static";"Instance";"ModuleSuffix";"UseNullAsTrueValue";"Event" |]
         Assert.AreEqual(names, SourceConstructFlags.GetNames(typeof<CompilationRepresentationFlags>))
-#endif
-
 
 type MiscStuff() =
 
diff --git a/tests/FSharp.Core.UnitTests/LibraryTestFx.fs b/tests/FSharp.Core.UnitTests/LibraryTestFx.fs
index 70697fb43e3..6137eb79d75 100644
--- a/tests/FSharp.Core.UnitTests/LibraryTestFx.fs
+++ b/tests/FSharp.Core.UnitTests/LibraryTestFx.fs
@@ -59,75 +59,3 @@ let VerifySeqsEqual (seq1 : seq<'T>) (seq2 : seq<'T>) =
 
 let sleep(n : int32) =
     System.Threading.Thread.Sleep(n)
-
-module SurfaceArea =
-    open System.Reflection
-    open System
-    open System.Text.RegularExpressions
-
-    // gets string form of public surface area for the currently-loaded FSharp.Core
-    let private getActual () =
-
-        // get current FSharp.Core
-        let asm = typeof<int list>.Assembly
-        let fsCoreFullName = asm.FullName
-
-        // public types only
-        let types = asm.ExportedTypes |> Seq.filter (fun ty -> let ti = ty.GetTypeInfo() in ti.IsPublic || ti.IsNestedPublic) |> Array.ofSeq
-
-        // extract canonical string form for every public member of every type
-        let getTypeMemberStrings (t : Type) =
-            // for System.Runtime-based profiles, need to do lots of manual work
-            let getMembers (t : Type) =
-                let ti = t.GetTypeInfo()
-                let cast (info: #MemberInfo) = (t, info :> MemberInfo)
-                let isDeclaredInFSharpCore (m:MemberInfo) = m.DeclaringType.Assembly.FullName = fsCoreFullName
-                seq {
-                    yield! ti.DeclaredEvents     |> Seq.filter (fun m -> m.AddMethod.IsPublic && m |> isDeclaredInFSharpCore) |> Seq.map cast
-                    yield! ti.DeclaredProperties |> Seq.filter (fun m -> m.GetMethod.IsPublic && m |> isDeclaredInFSharpCore) |> Seq.map cast
-                    yield! ti.DeclaredMethods    |> Seq.filter (fun m -> m.IsPublic && m |> isDeclaredInFSharpCore) |> Seq.map cast
-                    yield! ti.DeclaredFields     |> Seq.filter (fun m -> m.IsPublic && m |> isDeclaredInFSharpCore) |> Seq.map cast
-                    yield! ti.DeclaredConstructors  |> Seq.filter (fun m -> m.IsPublic) |> Seq.map cast
-                    yield! ti.DeclaredNestedTypes   |> Seq.filter (fun ty -> ty.IsNestedPublic) |> Seq.map cast
-                } |> Array.ofSeq
-
-
-            getMembers t
-            |> Array.map (fun (ty, m) -> sprintf "%s: %s" (ty.ToString()) (m.ToString()))
-
-        let actual =
-            types |> Array.collect getTypeMemberStrings
-
-        asm, actual
-
-    // verify public surface area matches expected
-    let verify expected platform (fileName : string) =
-        printfn "Verify"
-        let normalize (s:string) =
-            Regex.Replace(s, "(\\r\\n|\\n|\\r)+", "\r\n").Trim()
-
-        let asm, actualNotNormalized = getActual ()
-        let actual = 
-            actualNotNormalized 
-            |> Seq.map normalize 
-            |> Seq.filter (String.IsNullOrWhiteSpace >> not) 
-            |> String.concat Environment.NewLine
-        
-        let expected = normalize expected
-
-        match Tests.TestHelpers.assembleDiffMessage actual expected with
-        | None -> ()
-        | Some diff ->
-            let logFile =
-                let workDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)
-                sprintf "%s\\FSharp.Core.SurfaceArea.%s.txt" workDir platform
-            System.IO.File.WriteAllText(logFile, String.Join("\r\n", actual))
-
-            let msg = $"""Assembly: %A{asm}
-
-              Expected and actual surface area don't match. To see the delta, run:
-                  windiff %s{fileName} %s{logFile}
-
-              {diff}"""
-
-            failwith msg
diff --git a/tests/FSharp.Core.UnitTests/SurfaceArea.fs b/tests/FSharp.Core.UnitTests/SurfaceArea.fs
index fd0fe854332..cbc8367a113 100644
--- a/tests/FSharp.Core.UnitTests/SurfaceArea.fs
+++ b/tests/FSharp.Core.UnitTests/SurfaceArea.fs
@@ -3,2528 +3,41 @@
 namespace FSharp.Core.UnitTests.Portable.SurfaceArea
 
 open Xunit
-open FSharp.Core.UnitTests.LibraryTestFx
+open System
+open System.IO
+open FSharp.Test
 
 type SurfaceAreaTest() =
+
+    // This relies on a set of baselines to update the baseline set an environment variable before running the tests, then on failure the baselines will be updated
+    // Handled by SurfaceArea.verify
+    //
+    // CMD:
+    //    set TEST_UPDATE_BSL=1
+    // PowerShell:
+    //    $env:TEST_UPDATE_BSL=1
+    // Linux/macOS:
+    //    export TEST_UPDATE_BSL=1
     [<Fact>]
-    member this.VerifyArea() =
-        let expected = @"
-Microsoft.FSharp.Collections.Array2DModule: Int32 Base1[T](T[,])
-Microsoft.FSharp.Collections.Array2DModule: Int32 Base2[T](T[,])
-Microsoft.FSharp.Collections.Array2DModule: Int32 Length1[T](T[,])
-Microsoft.FSharp.Collections.Array2DModule: Int32 Length2[T](T[,])
-Microsoft.FSharp.Collections.Array2DModule: T Get[T](T[,], Int32, Int32)
-Microsoft.FSharp.Collections.Array2DModule: TResult[,] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]]], T[,])
-Microsoft.FSharp.Collections.Array2DModule: TResult[,] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[,])
-Microsoft.FSharp.Collections.Array2DModule: T[,] Copy[T](T[,])
-Microsoft.FSharp.Collections.Array2DModule: T[,] CreateBased[T](Int32, Int32, Int32, Int32, T)
-Microsoft.FSharp.Collections.Array2DModule: T[,] Create[T](Int32, Int32, T)
-Microsoft.FSharp.Collections.Array2DModule: T[,] InitializeBased[T](Int32, Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]])
-Microsoft.FSharp.Collections.Array2DModule: T[,] Initialize[T](Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]])
-Microsoft.FSharp.Collections.Array2DModule: T[,] Rebase[T](T[,])
-Microsoft.FSharp.Collections.Array2DModule: T[,] ZeroCreateBased[T](Int32, Int32, Int32, Int32)
-Microsoft.FSharp.Collections.Array2DModule: T[,] ZeroCreate[T](Int32, Int32)
-Microsoft.FSharp.Collections.Array2DModule: Void CopyTo[T](T[,], Int32, Int32, T[,], Int32, Int32, Int32, Int32)
-Microsoft.FSharp.Collections.Array2DModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]]], T[,])
-Microsoft.FSharp.Collections.Array2DModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[,])
-Microsoft.FSharp.Collections.Array2DModule: Void Set[T](T[,], Int32, Int32, T)
-Microsoft.FSharp.Collections.Array3DModule: Int32 Length1[T](T[,,])
-Microsoft.FSharp.Collections.Array3DModule: Int32 Length2[T](T[,,])
-Microsoft.FSharp.Collections.Array3DModule: Int32 Length3[T](T[,,])
-Microsoft.FSharp.Collections.Array3DModule: T Get[T](T[,,], Int32, Int32, Int32)
-Microsoft.FSharp.Collections.Array3DModule: TResult[,,] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]]]], T[,,])
-Microsoft.FSharp.Collections.Array3DModule: TResult[,,] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[,,])
-Microsoft.FSharp.Collections.Array3DModule: T[,,] Create[T](Int32, Int32, Int32, T)
-Microsoft.FSharp.Collections.Array3DModule: T[,,] Initialize[T](Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]]])
-Microsoft.FSharp.Collections.Array3DModule: T[,,] ZeroCreate[T](Int32, Int32, Int32)
-Microsoft.FSharp.Collections.Array3DModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]]]], T[,,])
-Microsoft.FSharp.Collections.Array3DModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[,,])
-Microsoft.FSharp.Collections.Array3DModule: Void Set[T](T[,,], Int32, Int32, Int32, T)
-Microsoft.FSharp.Collections.Array4DModule: Int32 Length1[T](T[,,,])
-Microsoft.FSharp.Collections.Array4DModule: Int32 Length2[T](T[,,,])
-Microsoft.FSharp.Collections.Array4DModule: Int32 Length3[T](T[,,,])
-Microsoft.FSharp.Collections.Array4DModule: Int32 Length4[T](T[,,,])
-Microsoft.FSharp.Collections.Array4DModule: T Get[T](T[,,,], Int32, Int32, Int32, Int32)
-Microsoft.FSharp.Collections.Array4DModule: T[,,,] Create[T](Int32, Int32, Int32, Int32, T)
-Microsoft.FSharp.Collections.Array4DModule: T[,,,] Initialize[T](Int32, Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]]]])
-Microsoft.FSharp.Collections.Array4DModule: T[,,,] ZeroCreate[T](Int32, Int32, Int32, Int32)
-Microsoft.FSharp.Collections.Array4DModule: Void Set[T](T[,,,], Int32, Int32, Int32, Int32, T)
-Microsoft.FSharp.Collections.ArrayModule+Parallel: System.Tuple`2[T[],T[]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
-Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[])
-Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] Collect[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult[]], T[])
-Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], T[])
-Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
-Microsoft.FSharp.Collections.ArrayModule+Parallel: T[] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T])
-Microsoft.FSharp.Collections.ArrayModule+Parallel: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], T[])
-Microsoft.FSharp.Collections.ArrayModule+Parallel: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[])
-Microsoft.FSharp.Collections.ArrayModule: Boolean Contains[T](T, T[])
-Microsoft.FSharp.Collections.ArrayModule: Boolean Exists2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], T1[], T2[])
-Microsoft.FSharp.Collections.ArrayModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
-Microsoft.FSharp.Collections.ArrayModule: Boolean ForAll2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], T1[], T2[])
-Microsoft.FSharp.Collections.ArrayModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
-Microsoft.FSharp.Collections.ArrayModule: Boolean IsEmpty[T](T[])
-Microsoft.FSharp.Collections.ArrayModule: Int32 CompareWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], T[], T[])
-Microsoft.FSharp.Collections.ArrayModule: Int32 FindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
-Microsoft.FSharp.Collections.ArrayModule: Int32 FindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
-Microsoft.FSharp.Collections.ArrayModule: Int32 Length[T](T[])
-Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Collections.ArrayModule+Parallel
-Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](T[])
-Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
-Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
-Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[])
-Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryExactlyOne[T](T[])
-Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
-Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
-Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryHead[T](T[])
-Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryItem[T](Int32, T[])
-Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryLast[T](T[])
-Microsoft.FSharp.Collections.ArrayModule: System.Collections.Generic.IEnumerable`1[T] ToSeq[T](T[])
-Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[System.Int32,T][] Indexed[T](T[])
-Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T,T][] Pairwise[T](T[])
-Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T1,T2][] AllPairs[T1,T2](T1[], T2[])
-Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T1,T2][] Zip[T1,T2](T1[], T2[])
-Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T1[],T2[]] Unzip[T1,T2](System.Tuple`2[T1,T2][])
-Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TKey,System.Int32][] CountBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
-Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TKey,T[]][] GroupBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
-Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TResult[],TState] MapFoldBack[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,System.Tuple`2[TResult,TState]]], T[], TState)
-Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TResult[],TState] MapFold[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Tuple`2[TResult,TState]]], TState, T[])
-Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T[],T[]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
-Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T[],T[]] SplitAt[T](Int32, T[])
-Microsoft.FSharp.Collections.ArrayModule: System.Tuple`3[T1,T2,T3][] Zip3[T1,T2,T3](T1[], T2[], T3[])
-Microsoft.FSharp.Collections.ArrayModule: System.Tuple`3[T1[],T2[],T3[]] Unzip3[T1,T2,T3](System.Tuple`3[T1,T2,T3][])
-Microsoft.FSharp.Collections.ArrayModule: T Average$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[])
-Microsoft.FSharp.Collections.ArrayModule: T Average[T](T[])
-Microsoft.FSharp.Collections.ArrayModule: T ExactlyOne[T](T[])
-Microsoft.FSharp.Collections.ArrayModule: T FindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
-Microsoft.FSharp.Collections.ArrayModule: T Find[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
-Microsoft.FSharp.Collections.ArrayModule: T Get[T](T[], Int32)
-Microsoft.FSharp.Collections.ArrayModule: T Head[T](T[])
-Microsoft.FSharp.Collections.ArrayModule: T Item[T](Int32, T[])
-Microsoft.FSharp.Collections.ArrayModule: T Last[T](T[])
-Microsoft.FSharp.Collections.ArrayModule: T MaxBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
-Microsoft.FSharp.Collections.ArrayModule: T Max[T](T[])
-Microsoft.FSharp.Collections.ArrayModule: T MinBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
-Microsoft.FSharp.Collections.ArrayModule: T Min[T](T[])
-Microsoft.FSharp.Collections.ArrayModule: T ReduceBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[])
-Microsoft.FSharp.Collections.ArrayModule: T Reduce[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[])
-Microsoft.FSharp.Collections.ArrayModule: T Sum$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[])
-Microsoft.FSharp.Collections.ArrayModule: T Sum[T](T[])
-Microsoft.FSharp.Collections.ArrayModule: TResult AverageBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
-Microsoft.FSharp.Collections.ArrayModule: TResult AverageBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
-Microsoft.FSharp.Collections.ArrayModule: TResult Pick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[])
-Microsoft.FSharp.Collections.ArrayModule: TResult SumBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
-Microsoft.FSharp.Collections.ArrayModule: TResult SumBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
-Microsoft.FSharp.Collections.ArrayModule: TResult[] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[])
-Microsoft.FSharp.Collections.ArrayModule: TResult[] Collect[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult[]], T[])
-Microsoft.FSharp.Collections.ArrayModule: TResult[] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], T1[], T2[])
-Microsoft.FSharp.Collections.ArrayModule: TResult[] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], T1[], T2[], T3[])
-Microsoft.FSharp.Collections.ArrayModule: TResult[] MapIndexed2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]]], T1[], T2[])
-Microsoft.FSharp.Collections.ArrayModule: TResult[] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], T[])
-Microsoft.FSharp.Collections.ArrayModule: TResult[] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[])
-Microsoft.FSharp.Collections.ArrayModule: TState Fold2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TState]]], TState, T1[], T2[])
-Microsoft.FSharp.Collections.ArrayModule: TState FoldBack2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], T1[], T2[], TState)
-Microsoft.FSharp.Collections.ArrayModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], T[], TState)
-Microsoft.FSharp.Collections.ArrayModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, T[])
-Microsoft.FSharp.Collections.ArrayModule: TState[] ScanBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], T[], TState)
-Microsoft.FSharp.Collections.ArrayModule: TState[] Scan[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] Append[T](T[], T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] Concat[T](System.Collections.Generic.IEnumerable`1[T[]])
-Microsoft.FSharp.Collections.ArrayModule: T[] Copy[T](T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] Create[T](Int32, T)
-Microsoft.FSharp.Collections.ArrayModule: T[] DistinctBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] Distinct[T](T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] Empty[T]()
-Microsoft.FSharp.Collections.ArrayModule: T[] Except[T](System.Collections.Generic.IEnumerable`1[T], T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] GetSubArray[T](T[], Int32, Int32)
-Microsoft.FSharp.Collections.ArrayModule: T[] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T])
-Microsoft.FSharp.Collections.ArrayModule: T[] OfList[T](Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ArrayModule: T[] OfSeq[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.ArrayModule: T[] Permute[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.Int32], T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] Replicate[T](Int32, T)
-Microsoft.FSharp.Collections.ArrayModule: T[] Reverse[T](T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] Singleton[T](T)
-Microsoft.FSharp.Collections.ArrayModule: T[] SkipWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] Skip[T](Int32, T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] SortByDescending[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] SortBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] SortDescending[T](T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] SortWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] Sort[T](T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] Tail[T](T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] TakeWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] Take[T](Int32, T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] Truncate[T](Int32, T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] Unfold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[T,TState]]], TState)
-Microsoft.FSharp.Collections.ArrayModule: T[] Where[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] ZeroCreate[T](Int32)
-Microsoft.FSharp.Collections.ArrayModule: T[][] ChunkBySize[T](Int32, T[])
-Microsoft.FSharp.Collections.ArrayModule: T[][] SplitInto[T](Int32, T[])
-Microsoft.FSharp.Collections.ArrayModule: T[][] Transpose[T](System.Collections.Generic.IEnumerable`1[T[]])
-Microsoft.FSharp.Collections.ArrayModule: T[][] Windowed[T](Int32, T[])
-Microsoft.FSharp.Collections.ArrayModule: Void CopyTo[T](T[], Int32, T[], Int32, Int32)
-Microsoft.FSharp.Collections.ArrayModule: Void Fill[T](T[], Int32, Int32, T)
-Microsoft.FSharp.Collections.ArrayModule: Void Iterate2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]], T1[], T2[])
-Microsoft.FSharp.Collections.ArrayModule: Void IterateIndexed2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]]], T1[], T2[])
-Microsoft.FSharp.Collections.ArrayModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], T[])
-Microsoft.FSharp.Collections.ArrayModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[])
-Microsoft.FSharp.Collections.ArrayModule: Void Set[T](T[], Int32, T)
-Microsoft.FSharp.Collections.ArrayModule: Void SortInPlaceBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[])
-Microsoft.FSharp.Collections.ArrayModule: Void SortInPlaceWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], T[])
-Microsoft.FSharp.Collections.ArrayModule: Void SortInPlace[T](T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] InsertAt[T](Int32, T, T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] InsertManyAt[T](Int32, System.Collections.Generic.IEnumerable`1[T], T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] RemoveAt[T](Int32, T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] RemoveManyAt[T](Int32, Int32, T[])
-Microsoft.FSharp.Collections.ArrayModule: T[] UpdateAt[T](Int32, T, T[])
-Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] FromFunction[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]])
-Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] NonStructural$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]])
-Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] NonStructural[T]()
-Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] Structural[T]()
-Microsoft.FSharp.Collections.FSharpList`1+Tags[T]: Int32 Cons
-Microsoft.FSharp.Collections.FSharpList`1+Tags[T]: Int32 Empty
-Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean Equals(Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean Equals(System.Object)
-Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
-Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean IsCons
-Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean IsEmpty
-Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean get_IsCons()
-Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean get_IsEmpty()
-Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 CompareTo(Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 CompareTo(System.Object)
-Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer)
-Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 GetHashCode()
-Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer)
-Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 GetReverseIndex(Int32, Int32)
-Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 Length
-Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 Tag
-Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 get_Length()
-Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 get_Tag()
-Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1+Tags[T]
-Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Cons(T, Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Empty
-Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] GetSlice(Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Tail
-Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] TailOrNull
-Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] get_Empty()
-Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] get_Tail()
-Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] get_TailOrNull()
-Microsoft.FSharp.Collections.FSharpList`1[T]: System.String ToString()
-Microsoft.FSharp.Collections.FSharpList`1[T]: T Head
-Microsoft.FSharp.Collections.FSharpList`1[T]: T HeadOrDefault
-Microsoft.FSharp.Collections.FSharpList`1[T]: T Item [Int32]
-Microsoft.FSharp.Collections.FSharpList`1[T]: T get_Head()
-Microsoft.FSharp.Collections.FSharpList`1[T]: T get_HeadOrDefault()
-Microsoft.FSharp.Collections.FSharpList`1[T]: T get_Item(Int32)
-Microsoft.FSharp.Collections.FSharpList`1[T]: Void .ctor(T, Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean ContainsKey(TKey)
-Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean Equals(System.Object)
-Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean IsEmpty
-Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean TryGetValue(TKey, TValue ByRef)
-Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean get_IsEmpty()
-Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Int32 Count
-Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Int32 GetHashCode()
-Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Int32 get_Count()
-Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Add(TKey, TValue)
-Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Change(TKey, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpOption`1[TValue],Microsoft.FSharp.Core.FSharpOption`1[TValue]])
-Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Remove(TKey)
-Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Core.FSharpOption`1[TValue] TryFind(TKey)
-Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.String ToString()
-Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: TValue Item [TKey]
-Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: TValue get_Item(TKey)
-Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Void .ctor(System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,TValue]])
-Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TKey] Keys
-Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TKey] get_Keys()
-Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TValue] Values
-Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TValue] get_Values()
-Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean Contains(T)
-Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean Equals(System.Object)
-Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsEmpty
-Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsProperSubsetOf(Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsProperSupersetOf(Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsSubsetOf(Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsSupersetOf(Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean get_IsEmpty()
-Microsoft.FSharp.Collections.FSharpSet`1[T]: Int32 Count
-Microsoft.FSharp.Collections.FSharpSet`1[T]: Int32 GetHashCode()
-Microsoft.FSharp.Collections.FSharpSet`1[T]: Int32 get_Count()
-Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] Add(T)
-Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] Remove(T)
-Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] op_Addition(Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] op_Subtraction(Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.FSharpSet`1[T]: System.String ToString()
-Microsoft.FSharp.Collections.FSharpSet`1[T]: T MaximumElement
-Microsoft.FSharp.Collections.FSharpSet`1[T]: T MinimumElement
-Microsoft.FSharp.Collections.FSharpSet`1[T]: T get_MaximumElement()
-Microsoft.FSharp.Collections.FSharpSet`1[T]: T get_MinimumElement()
-Microsoft.FSharp.Collections.FSharpSet`1[T]: Void .ctor(System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] FromFunctions[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]])
-Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] LimitedStructural[T](Int32)
-Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] NonStructural$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]])
-Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] NonStructural[T]()
-Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] Reference[T]()
-Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] Structural[T]()
-Microsoft.FSharp.Collections.ListModule: Boolean Contains[T](T, Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Boolean Exists2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
-Microsoft.FSharp.Collections.ListModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Boolean ForAll2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
-Microsoft.FSharp.Collections.ListModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Boolean IsEmpty[T](Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Int32 CompareWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], Microsoft.FSharp.Collections.FSharpList`1[T], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Int32 FindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Int32 FindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Int32 Length[T](Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] ChunkBySize[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] SplitInto[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] Transpose[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpList`1[T]])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] Windowed[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[System.Int32,T]] Indexed[T](Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T,T]] Pairwise[T](Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T1,T2]] AllPairs[T1,T2](Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T1,T2]] Zip[T1,T2](Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,Microsoft.FSharp.Collections.FSharpList`1[T]]] GroupBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,System.Int32]] CountBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[T1,T2,T3]] Zip3[T1,T2,T3](Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2], Microsoft.FSharp.Collections.FSharpList`1[T3])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Collect[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Collections.FSharpList`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2], Microsoft.FSharp.Collections.FSharpList`1[T3])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] MapIndexed2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TState] ScanBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Collections.FSharpList`1[T], TState)
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TState] Scan[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Append[T](Microsoft.FSharp.Collections.FSharpList`1[T], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Concat[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpList`1[T]])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] DistinctBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Distinct[T](Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Empty[T]()
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Except[T](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] OfArray[T](T[])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] OfSeq[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Permute[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.Int32], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Replicate[T](Int32, T)
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Reverse[T](Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Singleton[T](T)
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SkipWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Skip[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortByDescending[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortDescending[T](Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Sort[T](Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Tail[T](Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] TakeWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Take[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Truncate[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Unfold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[T,TState]]], TState)
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Where[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryExactlyOne[T](Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryHead[T](Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryItem[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryLast[T](Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: System.Collections.Generic.IEnumerable`1[T] ToSeq[T](Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[T1],Microsoft.FSharp.Collections.FSharpList`1[T2]] Unzip[T1,T2](Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T1,T2]])
-Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[TResult],TState] MapFoldBack[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,System.Tuple`2[TResult,TState]]], Microsoft.FSharp.Collections.FSharpList`1[T], TState)
-Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[TResult],TState] MapFold[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Tuple`2[TResult,TState]]], TState, Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[T],Microsoft.FSharp.Collections.FSharpList`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[T],Microsoft.FSharp.Collections.FSharpList`1[T]] SplitAt[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: System.Tuple`3[Microsoft.FSharp.Collections.FSharpList`1[T1],Microsoft.FSharp.Collections.FSharpList`1[T2],Microsoft.FSharp.Collections.FSharpList`1[T3]] Unzip3[T1,T2,T3](Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[T1,T2,T3]])
-Microsoft.FSharp.Collections.ListModule: T Average$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: T Average[T](Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: T ExactlyOne[T](Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: T FindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: T Find[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: T Get[T](Microsoft.FSharp.Collections.FSharpList`1[T], Int32)
-Microsoft.FSharp.Collections.ListModule: T Head[T](Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: T Item[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: T Last[T](Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: T MaxBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: T Max[T](Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: T MinBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: T Min[T](Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: T ReduceBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: T Reduce[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: T Sum$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: T Sum[T](Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: TResult AverageBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: TResult AverageBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: TResult Pick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: TResult SumBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: TResult SumBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: TState Fold2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TState]]], TState, Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
-Microsoft.FSharp.Collections.ListModule: TState FoldBack2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2], TState)
-Microsoft.FSharp.Collections.ListModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Collections.FSharpList`1[T], TState)
-Microsoft.FSharp.Collections.ListModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: T[] ToArray[T](Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Void Iterate2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
-Microsoft.FSharp.Collections.ListModule: Void IterateIndexed2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2])
-Microsoft.FSharp.Collections.ListModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] InsertAt[T](Int32, T, Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] InsertManyAt[T](Int32, System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RemoveAt[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RemoveManyAt[T](Int32, Int32, Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] UpdateAt[T](Int32, T, Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.MapModule: Boolean ContainsKey[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.MapModule: Boolean Exists[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.MapModule: Boolean ForAll[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.MapModule: Boolean IsEmpty[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.MapModule: Int32 Count[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,T]] ToList[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TResult] Map[TKey,T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Add[TKey,T](TKey, T, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Change[TKey,T](TKey, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpOption`1[T],Microsoft.FSharp.Core.FSharpOption`1[T]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Empty[TKey,T]()
-Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Filter[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] OfArray[TKey,T](System.Tuple`2[TKey,T][])
-Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] OfList[TKey,T](Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,T]])
-Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] OfSeq[TKey,T](System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,T]])
-Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Remove[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Core.FSharpOption`1[TKey] TryFindKey[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[TKey,T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.MapModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,T]] ToSeq[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.MapModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpMap`2[TKey,T],Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]] Partition[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.MapModule: System.Tuple`2[TKey,T][] ToArray[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.MapModule: T Find[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.MapModule: TKey FindKey[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.MapModule: TResult Pick[TKey,T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.MapModule: TState FoldBack[TKey,T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T], TState)
-Microsoft.FSharp.Collections.MapModule: TState Fold[TKey,T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]]], TState, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.MapModule: Void Iterate[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.MapModule: System.Collections.Generic.ICollection`1[TKey] Keys[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.MapModule: System.Collections.Generic.ICollection`1[T] Values[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.MapModule: System.Tuple`2[TKey,T] MaxKeyValue[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.MapModule: System.Tuple`2[TKey,T] MinKeyValue[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T])
-Microsoft.FSharp.Collections.SeqModule: Boolean Contains[T](T, System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: Boolean Exists2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
-Microsoft.FSharp.Collections.SeqModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: Boolean ForAll2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
-Microsoft.FSharp.Collections.SeqModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: Boolean IsEmpty[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: Int32 CompareWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: Int32 FindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: Int32 FindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: Int32 Length[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryExactlyOne[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryHead[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryItem[T](Int32, System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryLast[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Collections.Generic.IEnumerable`1[T]] Transpose[TCollection,T](System.Collections.Generic.IEnumerable`1[TCollection])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[System.Int32,T]] Indexed[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[T,T]] Pairwise[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[T1,T2]] AllPairs[T1,T2](System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[T1,T2]] Zip[T1,T2](System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,System.Collections.Generic.IEnumerable`1[T]]] GroupBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,System.Int32]] CountBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`3[T1,T2,T3]] Zip3[T1,T2,T3](System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2], System.Collections.Generic.IEnumerable`1[T3])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Collect[T,TCollection,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TCollection], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2], System.Collections.Generic.IEnumerable`1[T3])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] MapIndexed2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TState] ScanBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], System.Collections.Generic.IEnumerable`1[T], TState)
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TState] Scan[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T[]] ChunkBySize[T](Int32, System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T[]] SplitInto[T](Int32, System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T[]] Windowed[T](Int32, System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Append[T](System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Cache[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Cast[T](System.Collections.IEnumerable)
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Concat[TCollection,T](System.Collections.Generic.IEnumerable`1[TCollection])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Delay[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Collections.Generic.IEnumerable`1[T]])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] DistinctBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Distinct[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Empty[T]()
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Except[T](System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] InitializeInfinite[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] OfArray[T](T[])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] OfList[T](Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Permute[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.Int32], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] ReadOnly[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Replicate[T](Int32, T)
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Reverse[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Singleton[T](T)
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SkipWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Skip[T](Int32, System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortByDescending[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortDescending[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Sort[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Tail[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] TakeWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Take[T](Int32, System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Truncate[T](Int32, System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Unfold[TState,T](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[T,TState]]], TState)
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Where[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Tuple`2[System.Collections.Generic.IEnumerable`1[TResult],TState] MapFoldBack[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,System.Tuple`2[TResult,TState]]], System.Collections.Generic.IEnumerable`1[T], TState)
-Microsoft.FSharp.Collections.SeqModule: System.Tuple`2[System.Collections.Generic.IEnumerable`1[TResult],TState] MapFold[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Tuple`2[TResult,TState]]], TState, System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: T Average$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: T Average[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: T ExactlyOne[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: T FindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: T Find[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: T Get[T](Int32, System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: T Head[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: T Item[T](Int32, System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: T Last[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: T MaxBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: T Max[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: T MinBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: T Min[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: T ReduceBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: T Reduce[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: T Sum$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: T Sum[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: TResult AverageBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: TResult AverageBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: TResult Pick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: TResult SumBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: TResult SumBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: TState Fold2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TState]]], TState, System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
-Microsoft.FSharp.Collections.SeqModule: TState FoldBack2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2], TState)
-Microsoft.FSharp.Collections.SeqModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], System.Collections.Generic.IEnumerable`1[T], TState)
-Microsoft.FSharp.Collections.SeqModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: T[] ToArray[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: Void Iterate2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
-Microsoft.FSharp.Collections.SeqModule: Void IterateIndexed2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2])
-Microsoft.FSharp.Collections.SeqModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] InsertAt[T](Int32, T, System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] InsertManyAt[T](Int32, System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RemoveAt[T](Int32, System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RemoveManyAt[T](Int32, Int32, System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] UpdateAt[T](Int32, T, System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SetModule: Boolean Contains[T](T, Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: Boolean IsEmpty[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: Boolean IsProperSubset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: Boolean IsProperSuperset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: Boolean IsSubset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: Boolean IsSuperset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: Int32 Count[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Add[T](T, Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Difference[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Empty[T]()
-Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] IntersectMany[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpSet`1[T]])
-Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Intersect[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] OfArray[T](T[])
-Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] OfList[T](Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] OfSeq[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Remove[T](T, Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Singleton[T](T)
-Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] UnionMany[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpSet`1[T]])
-Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Union[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: System.Collections.Generic.IEnumerable`1[T] ToSeq[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpSet`1[T],Microsoft.FSharp.Collections.FSharpSet`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: T MaxElement[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: T MinElement[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Collections.FSharpSet`1[T], TState)
-Microsoft.FSharp.Collections.SetModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: T[] ToArray[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Control.AsyncActivation`1[T]: Boolean IsCancellationRequested
-Microsoft.FSharp.Control.AsyncActivation`1[T]: Boolean get_IsCancellationRequested()
-Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn OnCancellation()
-Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn OnSuccess(T)
-Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn Success(Microsoft.FSharp.Control.AsyncActivation`1[T], T)
-Microsoft.FSharp.Control.AsyncActivation`1[T]: Void OnExceptionRaised()
-Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn Bind[T,TResult](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Control.FSharpAsync`1[T]])
-Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn CallThenInvoke[T,TResult](Microsoft.FSharp.Control.AsyncActivation`1[T], TResult, Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Control.FSharpAsync`1[T]])
-Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn Invoke[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Control.AsyncActivation`1[T])
-Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn TryFinally[T](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn TryWith[T](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]])
-Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.FSharpAsync`1[T] MakeAsync[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.AsyncActivation`1[T],Microsoft.FSharp.Control.AsyncReturn])
-Microsoft.FSharp.Control.BackgroundTaskBuilder: System.Threading.Tasks.Task`1[T] RunDynamic[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
-Microsoft.FSharp.Control.BackgroundTaskBuilder: System.Threading.Tasks.Task`1[T] Run[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
-Microsoft.FSharp.Control.CommonExtensions: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AsyncWrite(System.IO.Stream, Byte[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Control.CommonExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Byte[]] AsyncReadBytes(System.IO.Stream, Int32)
-Microsoft.FSharp.Control.CommonExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Int32] AsyncRead(System.IO.Stream, Byte[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Control.CommonExtensions: System.IDisposable SubscribeToObservable[T](System.IObservable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Control.CommonExtensions: Void AddToObservable[T](System.IObservable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[System.Tuple`2[T,T]],System.Tuple`2[T,T]] Pairwise[TDel,T](Microsoft.FSharp.Control.IEvent`2[TDel,T])
-Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult],TResult] Choose[T,TResult,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Control.IEvent`2[TDel,T])
-Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult],TResult] Map[T,TResult,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Control.IEvent`2[TDel,T])
-Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult],TResult] Scan[TResult,T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], TResult, Microsoft.FSharp.Control.IEvent`2[TDel,T])
-Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] Filter[T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Control.IEvent`2[TDel,T])
-Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] Merge[TDel1,T,TDel2](Microsoft.FSharp.Control.IEvent`2[TDel1,T], Microsoft.FSharp.Control.IEvent`2[TDel2,T])
-Microsoft.FSharp.Control.EventModule: System.Tuple`2[Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult1],TResult1],Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult2],TResult2]] Split[T,TResult1,TResult2,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[TResult1,TResult2]], Microsoft.FSharp.Control.IEvent`2[TDel,T])
-Microsoft.FSharp.Control.EventModule: System.Tuple`2[Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T],Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T]] Partition[T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Control.IEvent`2[TDel,T])
-Microsoft.FSharp.Control.EventModule: Void Add[T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Control.IEvent`2[TDel,T])
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Control.FSharpAsync`1[T]] StartChild[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpChoice`2[T,System.Exception]] Catch[T](Microsoft.FSharp.Control.FSharpAsync`1[T])
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[T]] Choice[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[T]]])
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AwaitTask(System.Threading.Tasks.Task)
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Ignore[T](Microsoft.FSharp.Control.FSharpAsync`1[T])
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Sleep(Int32)
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Sleep(System.TimeSpan)
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] SwitchToContext(System.Threading.SynchronizationContext)
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] SwitchToNewThread()
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] SwitchToThreadPool()
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Boolean] AwaitIAsyncResult(System.IAsyncResult, Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Boolean] AwaitWaitHandle(System.Threading.WaitHandle, Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.IDisposable] OnCancel(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Threading.CancellationToken] CancellationToken
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Threading.CancellationToken] get_CancellationToken()
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Threading.Tasks.Task`1[T]] StartChildAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.Tasks.TaskCreationOptions])
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Parallel[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]])
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Parallel[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Sequential[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]])
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitEvent[TDel,T](Microsoft.FSharp.Control.IEvent`2[TDel,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]])
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitTask[T](System.Threading.Tasks.Task`1[T])
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,TArg2,TArg3,T](TArg1, TArg2, TArg3, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`5[TArg1,TArg2,TArg3,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]])
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,TArg2,T](TArg1, TArg2, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`4[TArg1,TArg2,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]])
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,T](TArg1, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[TArg1,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]])
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]])
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromContinuations[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit],Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.Unit],Microsoft.FSharp.Core.FSharpFunc`2[System.OperationCanceledException,Microsoft.FSharp.Core.Unit]],Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] TryCancelled[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.OperationCanceledException,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Control.FSharpAsync: System.Threading.CancellationToken DefaultCancellationToken
-Microsoft.FSharp.Control.FSharpAsync: System.Threading.CancellationToken get_DefaultCancellationToken()
-Microsoft.FSharp.Control.FSharpAsync: System.Threading.Tasks.Task`1[T] StartAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.Tasks.TaskCreationOptions], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
-Microsoft.FSharp.Control.FSharpAsync: System.Threading.Tasks.Task`1[T] StartImmediateAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
-Microsoft.FSharp.Control.FSharpAsync: System.Tuple`3[Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[TArg,System.AsyncCallback,System.Object],System.IAsyncResult],Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T],Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,Microsoft.FSharp.Core.Unit]] AsBeginEnd[TArg,T](Microsoft.FSharp.Core.FSharpFunc`2[TArg,Microsoft.FSharp.Control.FSharpAsync`1[T]])
-Microsoft.FSharp.Control.FSharpAsync: T RunSynchronously[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
-Microsoft.FSharp.Control.FSharpAsync: Void CancelDefaultToken()
-Microsoft.FSharp.Control.FSharpAsync: Void Start(Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
-Microsoft.FSharp.Control.FSharpAsync: Void StartImmediate(Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
-Microsoft.FSharp.Control.FSharpAsync: Void StartWithContinuations[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[System.OperationCanceledException,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
-Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] For[T](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]])
-Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] While(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Zero()
-Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Bind[T,TResult](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[TResult]])
-Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Using[T,TResult](T, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[TResult]])
-Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] Combine[T](Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Control.FSharpAsync`1[T])
-Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] Delay[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Control.FSharpAsync`1[T]])
-Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] ReturnFrom[T](Microsoft.FSharp.Control.FSharpAsync`1[T])
-Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] Return[T](T)
-Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] TryFinally[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] TryWith[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Control.FSharpAsync`1[T]])
-Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply]: Void Reply(TReply)
-Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate] Publish
-Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate] get_Publish()
-Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Void .ctor()
-Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Void Trigger(System.Object[])
-Microsoft.FSharp.Control.FSharpEvent`1[T]: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] Publish
-Microsoft.FSharp.Control.FSharpEvent`1[T]: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] get_Publish()
-Microsoft.FSharp.Control.FSharpEvent`1[T]: Void .ctor()
-Microsoft.FSharp.Control.FSharpEvent`1[T]: Void Trigger(T)
-Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Microsoft.FSharp.Control.IEvent`2[TDelegate,TArgs] Publish
-Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Microsoft.FSharp.Control.IEvent`2[TDelegate,TArgs] get_Publish()
-Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Void .ctor()
-Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Void Trigger(System.Object, TArgs)
-Microsoft.FSharp.Control.FSharpHandler`1[T]: System.IAsyncResult BeginInvoke(System.Object, T, System.AsyncCallback, System.Object)
-Microsoft.FSharp.Control.FSharpHandler`1[T]: Void .ctor(System.Object, IntPtr)
-Microsoft.FSharp.Control.FSharpHandler`1[T]: Void EndInvoke(System.IAsyncResult)
-Microsoft.FSharp.Control.FSharpHandler`1[T]: Void Invoke(System.Object, T)
-Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 CurrentQueueLength
-Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 DefaultTimeout
-Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 get_CurrentQueueLength()
-Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 get_DefaultTimeout()
-Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[TMsg]] TryReceive(Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[TReply]] PostAndTryAsyncReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[T]] TryScan[T](Microsoft.FSharp.Core.FSharpFunc`2[TMsg,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[TMsg] Receive(Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[TReply] PostAndAsyncReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[T] Scan[T](Microsoft.FSharp.Core.FSharpFunc`2[TMsg,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpHandler`1[System.Exception] Error
-Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg] Start(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg],Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
-Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Core.FSharpOption`1[TReply] TryPostAndReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: TReply PostAndReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void .ctor(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg],Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
-Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void Post(TMsg)
-Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void Start()
-Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void add_Error(Microsoft.FSharp.Control.FSharpHandler`1[System.Exception])
-Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void remove_Error(Microsoft.FSharp.Control.FSharpHandler`1[System.Exception])
-Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void set_DefaultTimeout(Int32)
-Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate]: Void AddHandler(TDelegate)
-Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate]: Void RemoveHandler(TDelegate)
-Microsoft.FSharp.Control.LazyExtensions: System.Lazy`1[T] CreateFromValue[T](T)
-Microsoft.FSharp.Control.LazyExtensions: System.Lazy`1[T] Create[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T])
-Microsoft.FSharp.Control.LazyExtensions: T Force[T](System.Lazy`1[T])
-Microsoft.FSharp.Control.ObservableModule: System.IDisposable Subscribe[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], System.IObservable`1[T])
-Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[System.Tuple`2[T,T]] Pairwise[T](System.IObservable`1[T])
-Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[TResult] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.IObservable`1[T])
-Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.IObservable`1[T])
-Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[TResult] Scan[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], TResult, System.IObservable`1[T])
-Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.IObservable`1[T])
-Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[T] Merge[T](System.IObservable`1[T], System.IObservable`1[T])
-Microsoft.FSharp.Control.ObservableModule: System.Tuple`2[System.IObservable`1[TResult1],System.IObservable`1[TResult2]] Split[T,TResult1,TResult2](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[TResult1,TResult2]], System.IObservable`1[T])
-Microsoft.FSharp.Control.ObservableModule: System.Tuple`2[System.IObservable`1[T],System.IObservable`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.IObservable`1[T])
-Microsoft.FSharp.Control.ObservableModule: Void Add[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], System.IObservable`1[T])
-Microsoft.FSharp.Control.TaskBuilder: System.Threading.Tasks.Task`1[T] RunDynamic[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
-Microsoft.FSharp.Control.TaskBuilder: System.Threading.Tasks.Task`1[T] Run[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
-Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit] For[T,TOverall](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit]])
-Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit] While[TOverall](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit] Zero[TOverall]()
-Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] Combine[TOverall,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T])
-Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] Delay[TOverall,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]])
-Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] TryFinally[TOverall,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] TryWith[TOverall,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]])
-Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] Return[T](T)
-Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority: Boolean TaskBuilderBase.BindDynamic.Static[TOverall,TResult1,TResult2](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall]] ByRef, System.Threading.Tasks.Task`1[TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
-Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind[TResult1,TOverall,TResult2](Microsoft.FSharp.Control.TaskBuilderBase, System.Threading.Tasks.Task`1[TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
-Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom[T](Microsoft.FSharp.Control.TaskBuilderBase, System.Threading.Tasks.Task`1[T])
-Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Boolean TaskBuilderBase.BindDynamic.Static$W[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike,TAwaiter], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall]] ByRef, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
-Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Boolean TaskBuilderBase.BindDynamic.Static[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall]] ByRef, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
-Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind$W[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike,TAwaiter], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,System.Boolean], Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
-Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
-Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] TaskBuilderBase.Using[TResource,TOverall,T](Microsoft.FSharp.Control.TaskBuilderBase, TResource, Microsoft.FSharp.Core.FSharpFunc`2[TResource,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]])
-Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom$W[TTaskLike,TAwaiter,T](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike,TAwaiter], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,T], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,System.Boolean], Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike)
-Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom[TTaskLike,TAwaiter,T](Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike)
-Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind[TResult1,TOverall,TResult2](Microsoft.FSharp.Control.TaskBuilderBase, Microsoft.FSharp.Control.FSharpAsync`1[TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]])
-Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom[T](Microsoft.FSharp.Control.TaskBuilderBase, Microsoft.FSharp.Control.FSharpAsync`1[T])
-Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.BackgroundTaskBuilder backgroundTask
-Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.BackgroundTaskBuilder get_backgroundTask()
-Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.TaskBuilder get_task()
-Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.TaskBuilder task
-Microsoft.FSharp.Control.TaskStateMachineData`1[T]: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1[T] MethodBuilder
-Microsoft.FSharp.Control.TaskStateMachineData`1[T]: T Result
-Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AsyncDownloadFile(System.Net.WebClient, System.Uri, System.String)
-Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Byte[]] AsyncDownloadData(System.Net.WebClient, System.Uri)
-Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Net.WebResponse] AsyncGetResponse(System.Net.WebRequest)
-Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.String] AsyncDownloadString(System.Net.WebClient, System.Uri)
-Microsoft.FSharp.Core.AbstractClassAttribute: Void .ctor()
-Microsoft.FSharp.Core.AllowNullLiteralAttribute: Boolean Value
-Microsoft.FSharp.Core.AllowNullLiteralAttribute: Boolean get_Value()
-Microsoft.FSharp.Core.AllowNullLiteralAttribute: Void .ctor()
-Microsoft.FSharp.Core.AllowNullLiteralAttribute: Void .ctor(Boolean)
-Microsoft.FSharp.Core.AutoOpenAttribute: System.String Path
-Microsoft.FSharp.Core.AutoOpenAttribute: System.String get_Path()
-Microsoft.FSharp.Core.AutoOpenAttribute: Void .ctor()
-Microsoft.FSharp.Core.AutoOpenAttribute: Void .ctor(System.String)
-Microsoft.FSharp.Core.AutoSerializableAttribute: Boolean Value
-Microsoft.FSharp.Core.AutoSerializableAttribute: Boolean get_Value()
-Microsoft.FSharp.Core.AutoSerializableAttribute: Void .ctor(Boolean)
-Microsoft.FSharp.Core.ByRefKinds: Microsoft.FSharp.Core.ByRefKinds+In
-Microsoft.FSharp.Core.ByRefKinds: Microsoft.FSharp.Core.ByRefKinds+InOut
-Microsoft.FSharp.Core.ByRefKinds: Microsoft.FSharp.Core.ByRefKinds+Out
-Microsoft.FSharp.Core.CLIEventAttribute: Void .ctor()
-Microsoft.FSharp.Core.CLIMutableAttribute: Void .ctor()
-Microsoft.FSharp.Core.ClassAttribute: Void .ctor()
-Microsoft.FSharp.Core.ComparisonConditionalOnAttribute: Void .ctor()
-Microsoft.FSharp.Core.CompilationArgumentCountsAttribute: System.Collections.Generic.IEnumerable`1[System.Int32] Counts
-Microsoft.FSharp.Core.CompilationArgumentCountsAttribute: System.Collections.Generic.IEnumerable`1[System.Int32] get_Counts()
-Microsoft.FSharp.Core.CompilationArgumentCountsAttribute: Void .ctor(Int32[])
-Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 SequenceNumber
-Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 VariantNumber
-Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 get_SequenceNumber()
-Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 get_VariantNumber()
-Microsoft.FSharp.Core.CompilationMappingAttribute: Microsoft.FSharp.Core.SourceConstructFlags SourceConstructFlags
-Microsoft.FSharp.Core.CompilationMappingAttribute: Microsoft.FSharp.Core.SourceConstructFlags get_SourceConstructFlags()
-Microsoft.FSharp.Core.CompilationMappingAttribute: System.String ResourceName
-Microsoft.FSharp.Core.CompilationMappingAttribute: System.String get_ResourceName()
-Microsoft.FSharp.Core.CompilationMappingAttribute: System.Type[] TypeDefinitions
-Microsoft.FSharp.Core.CompilationMappingAttribute: System.Type[] get_TypeDefinitions()
-Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(Microsoft.FSharp.Core.SourceConstructFlags)
-Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(Microsoft.FSharp.Core.SourceConstructFlags, Int32)
-Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(Microsoft.FSharp.Core.SourceConstructFlags, Int32, Int32)
-Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(System.String, System.Type[])
-Microsoft.FSharp.Core.CompilationRepresentationAttribute: Microsoft.FSharp.Core.CompilationRepresentationFlags Flags
-Microsoft.FSharp.Core.CompilationRepresentationAttribute: Microsoft.FSharp.Core.CompilationRepresentationFlags get_Flags()
-Microsoft.FSharp.Core.CompilationRepresentationAttribute: Void .ctor(Microsoft.FSharp.Core.CompilationRepresentationFlags)
-Microsoft.FSharp.Core.CompilationRepresentationFlags: Int32 value__
-Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags Event
-Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags Instance
-Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags ModuleSuffix
-Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags None
-Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags Static
-Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags UseNullAsTrueValue
-Microsoft.FSharp.Core.CompilationSourceNameAttribute: System.String SourceName
-Microsoft.FSharp.Core.CompilationSourceNameAttribute: System.String get_SourceName()
-Microsoft.FSharp.Core.CompilationSourceNameAttribute: Void .ctor(System.String)
-Microsoft.FSharp.Core.CompiledNameAttribute: System.String CompiledName
-Microsoft.FSharp.Core.CompiledNameAttribute: System.String get_CompiledName()
-Microsoft.FSharp.Core.CompiledNameAttribute: Void .ctor(System.String)
-Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean IsError
-Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean IsHidden
-Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean get_IsError()
-Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean get_IsHidden()
-Microsoft.FSharp.Core.CompilerMessageAttribute: Int32 MessageNumber
-Microsoft.FSharp.Core.CompilerMessageAttribute: Int32 get_MessageNumber()
-Microsoft.FSharp.Core.CompilerMessageAttribute: System.String Message
-Microsoft.FSharp.Core.CompilerMessageAttribute: System.String get_Message()
-Microsoft.FSharp.Core.CompilerMessageAttribute: Void .ctor(System.String, Int32)
-Microsoft.FSharp.Core.CompilerMessageAttribute: Void set_IsError(Boolean)
-Microsoft.FSharp.Core.CompilerMessageAttribute: Void set_IsHidden(Boolean)
-Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object)
-Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: TResult EndInvoke(System.IAsyncResult)
-Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: TResult Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
-Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: Void .ctor(System.Object, IntPtr)
-Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: T[] Close()
-Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: Void Add(T)
-Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: Void AddMany(System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: T[] AddManyAndClose(System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Close()
-Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Void Add(T)
-Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Void AddMany(System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] AddManyAndClose(System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Boolean CheckClose
-Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Boolean get_CheckClose()
-Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Int32 GenerateNext(System.Collections.Generic.IEnumerable`1[T] ByRef)
-Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: System.Collections.Generic.IEnumerator`1[T] GetFreshEnumerator()
-Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: T LastGenerated
-Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: T get_LastGenerated()
-Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Void .ctor()
-Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Void Close()
-Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace[] GetNestedNamespaces()
-Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.String NamespaceName
-Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.String get_NamespaceName()
-Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.Type ResolveTypeName(System.String)
-Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.Type[] GetTypes()
-Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: Int32 ResumptionPoint
-Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: Int32 get_ResumptionPoint()
-Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: TData Data
-Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: TData get_Data()
-Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: Void set_Data(TData)
-Microsoft.FSharp.Core.CompilerServices.ITypeProvider2: System.Reflection.MethodBase ApplyStaticArgumentsForMethod(System.Reflection.MethodBase, System.String, System.Object[])
-Microsoft.FSharp.Core.CompilerServices.ITypeProvider2: System.Reflection.ParameterInfo[] GetStaticParametersForMethod(System.Reflection.MethodBase)
-Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Byte[] GetGeneratedAssemblyContents(System.Reflection.Assembly)
-Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace[] GetNamespaces()
-Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Microsoft.FSharp.Quotations.FSharpExpr GetInvokerExpression(System.Reflection.MethodBase, Microsoft.FSharp.Quotations.FSharpExpr[])
-Microsoft.FSharp.Core.CompilerServices.ITypeProvider: System.EventHandler Invalidate
-Microsoft.FSharp.Core.CompilerServices.ITypeProvider: System.Reflection.ParameterInfo[] GetStaticParameters(System.Type)
-Microsoft.FSharp.Core.CompilerServices.ITypeProvider: System.Type ApplyStaticArguments(System.Type, System.String[], System.Object[])
-Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Void add_Invalidate(System.EventHandler)
-Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Void remove_Invalidate(System.EventHandler)
-Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object)
-Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: Void .ctor(System.Object, IntPtr)
-Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: Void EndInvoke(System.IAsyncResult)
-Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: Void Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
-Microsoft.FSharp.Core.CompilerServices.NoEagerConstraintApplicationAttribute: Void .ctor()
-Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean CombineDynamic[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T])
-Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean TryFinallyAsyncDynamic[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean TryWithDynamic[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]])
-Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean WhileDynamic[TData](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean YieldDynamic[TData](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
-Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] For[T,TData](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit]])
-Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] While[TData](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] Yield[TData]()
-Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] Zero[TData]()
-Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] Combine[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T])
-Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] Delay[TData,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]])
-Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] TryFinallyAsync[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] TryFinally[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] TryWith[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]])
-Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] Using[TResource,TData,T](TResource, Microsoft.FSharp.Core.FSharpFunc`2[TResource,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]])
-Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: Boolean EndInvoke(System.IAsyncResult)
-Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: Boolean Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
-Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object)
-Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: Void .ctor(System.Object, IntPtr)
-Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData]: Int32 ResumptionPoint
-Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData]: Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData] ResumptionDynamicInfo
-Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData]: TData Data
-Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData] ResumptionFunc
-Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData] get_ResumptionFunc()
-Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: System.Object ResumptionData
-Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: System.Object get_ResumptionData()
-Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void .ctor(Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData])
-Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void MoveNext(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
-Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void SetStateMachine(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine)
-Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void set_ResumptionData(System.Object)
-Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void set_ResumptionFunc(Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData])
-Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: Boolean EndInvoke(System.IAsyncResult)
-Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: Boolean Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef)
-Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object)
-Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: Void .ctor(System.Object, IntPtr)
-Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: Microsoft.FSharp.Control.IEvent`2[TDelegate,TArgs] CreateEvent[TDelegate,TArgs](Microsoft.FSharp.Core.FSharpFunc`2[TDelegate,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[TDelegate,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpFunc`2[System.Object,Microsoft.FSharp.Core.FSharpFunc`2[TArgs,Microsoft.FSharp.Core.Unit]],TDelegate])
-Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[TResult] EnumerateFromFunctions[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
-Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[TResult] EnumerateUsing[T,TCollection,TResult](T, Microsoft.FSharp.Core.FSharpFunc`2[T,TCollection])
-Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[T] EnumerateThenFinally[T](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[T] EnumerateWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine, System.AsyncCallback, System.Object)
-Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void .ctor(System.Object, IntPtr)
-Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void EndInvoke(System.IAsyncResult)
-Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine)
-Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Boolean __useResumableCode[T]()
-Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] __resumableEntry()
-Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: T __resumeAt[T](Int32)
-Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: TResult __stateMachine[TData,TResult](Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult])
-Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: System.String AssemblyName
-Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: System.String get_AssemblyName()
-Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: Void .ctor()
-Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: Void .ctor(System.String)
-Microsoft.FSharp.Core.CompilerServices.TypeProviderAttribute: Void .ctor()
-Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean IsHostedExecution
-Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean IsInvalidationSupported
-Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean SystemRuntimeContainsType(System.String)
-Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean get_IsHostedExecution()
-Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean get_IsInvalidationSupported()
-Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String ResolutionFolder
-Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String RuntimeAssembly
-Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String TemporaryFolder
-Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String get_ResolutionFolder()
-Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String get_RuntimeAssembly()
-Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String get_TemporaryFolder()
-Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String[] ReferencedAssemblies
-Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String[] get_ReferencedAssemblies()
-Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.Version SystemRuntimeAssemblyVersion
-Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.Version get_SystemRuntimeAssemblyVersion()
-Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void .ctor(Microsoft.FSharp.Core.FSharpFunc`2[System.String,System.Boolean])
-Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void .ctor(Microsoft.FSharp.Core.FSharpFunc`2[System.String,System.Boolean], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.String[]])
-Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_IsHostedExecution(Boolean)
-Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_IsInvalidationSupported(Boolean)
-Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_ReferencedAssemblies(System.String[])
-Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_ResolutionFolder(System.String)
-Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_RuntimeAssembly(System.String)
-Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_SystemRuntimeAssemblyVersion(System.Version)
-Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_TemporaryFolder(System.String)
-Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 Column
-Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 Line
-Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 get_Column()
-Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 get_Line()
-Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: System.String FilePath
-Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: System.String get_FilePath()
-Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void .ctor()
-Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void set_Column(Int32)
-Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void set_FilePath(System.String)
-Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void set_Line(Int32)
-Microsoft.FSharp.Core.CompilerServices.TypeProviderEditorHideMethodsAttribute: Void .ctor()
-Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes: Int32 value__
-Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes: Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes IsErased
-Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes: Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes SuppressRelocate
-Microsoft.FSharp.Core.CompilerServices.TypeProviderXmlDocAttribute: System.String CommentText
-Microsoft.FSharp.Core.CompilerServices.TypeProviderXmlDocAttribute: System.String get_CommentText()
-Microsoft.FSharp.Core.CompilerServices.TypeProviderXmlDocAttribute: Void .ctor(System.String)
-Microsoft.FSharp.Core.CustomComparisonAttribute: Void .ctor()
-Microsoft.FSharp.Core.CustomEqualityAttribute: Void .ctor()
-Microsoft.FSharp.Core.CustomOperationAttribute: Boolean AllowIntoPattern
-Microsoft.FSharp.Core.CustomOperationAttribute: Boolean IsLikeGroupJoin
-Microsoft.FSharp.Core.CustomOperationAttribute: Boolean IsLikeJoin
-Microsoft.FSharp.Core.CustomOperationAttribute: Boolean IsLikeZip
-Microsoft.FSharp.Core.CustomOperationAttribute: Boolean MaintainsVariableSpace
-Microsoft.FSharp.Core.CustomOperationAttribute: Boolean MaintainsVariableSpaceUsingBind
-Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_AllowIntoPattern()
-Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_IsLikeGroupJoin()
-Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_IsLikeJoin()
-Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_IsLikeZip()
-Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_MaintainsVariableSpace()
-Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_MaintainsVariableSpaceUsingBind()
-Microsoft.FSharp.Core.CustomOperationAttribute: System.String JoinConditionWord
-Microsoft.FSharp.Core.CustomOperationAttribute: System.String Name
-Microsoft.FSharp.Core.CustomOperationAttribute: System.String get_JoinConditionWord()
-Microsoft.FSharp.Core.CustomOperationAttribute: System.String get_Name()
-Microsoft.FSharp.Core.CustomOperationAttribute: Void .ctor(System.String)
-Microsoft.FSharp.Core.CustomOperationAttribute: Void set_AllowIntoPattern(Boolean)
-Microsoft.FSharp.Core.CustomOperationAttribute: Void set_IsLikeGroupJoin(Boolean)
-Microsoft.FSharp.Core.CustomOperationAttribute: Void set_IsLikeJoin(Boolean)
-Microsoft.FSharp.Core.CustomOperationAttribute: Void set_IsLikeZip(Boolean)
-Microsoft.FSharp.Core.CustomOperationAttribute: Void set_JoinConditionWord(System.String)
-Microsoft.FSharp.Core.CustomOperationAttribute: Void set_MaintainsVariableSpace(Boolean)
-Microsoft.FSharp.Core.CustomOperationAttribute: Void set_MaintainsVariableSpaceUsingBind(Boolean)
-Microsoft.FSharp.Core.DefaultAugmentationAttribute: Boolean Value
-Microsoft.FSharp.Core.DefaultAugmentationAttribute: Boolean get_Value()
-Microsoft.FSharp.Core.DefaultAugmentationAttribute: Void .ctor(Boolean)
-Microsoft.FSharp.Core.DefaultValueAttribute: Boolean Check
-Microsoft.FSharp.Core.DefaultValueAttribute: Boolean get_Check()
-Microsoft.FSharp.Core.DefaultValueAttribute: Void .ctor()
-Microsoft.FSharp.Core.DefaultValueAttribute: Void .ctor(Boolean)
-Microsoft.FSharp.Core.EntryPointAttribute: Void .ctor()
-Microsoft.FSharp.Core.EqualityConditionalOnAttribute: Void .ctor()
-Microsoft.FSharp.Core.ExperimentalAttribute: System.String Message
-Microsoft.FSharp.Core.ExperimentalAttribute: System.String get_Message()
-Microsoft.FSharp.Core.ExperimentalAttribute: Void .ctor(System.String)
-Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T)
-Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: Byte ToByte[T](T)
-Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T)
-Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: SByte ToSByte[T](T)
-Microsoft.FSharp.Core.ExtraTopLevelOperators: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T)
-Microsoft.FSharp.Core.ExtraTopLevelOperators: Byte ToByte[T](T)
-Microsoft.FSharp.Core.ExtraTopLevelOperators: Double ToDouble$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], T)
-Microsoft.FSharp.Core.ExtraTopLevelOperators: Double ToDouble[T](T)
-Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Collections.FSharpSet`1[T] CreateSet[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Control.FSharpAsyncBuilder DefaultAsyncBuilder
-Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Control.FSharpAsyncBuilder get_DefaultAsyncBuilder()
-Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked
-Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Linq.QueryBuilder get_query()
-Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Linq.QueryBuilder query
-Microsoft.FSharp.Core.ExtraTopLevelOperators: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T)
-Microsoft.FSharp.Core.ExtraTopLevelOperators: SByte ToSByte[T](T)
-Microsoft.FSharp.Core.ExtraTopLevelOperators: Single ToSingle$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], T)
-Microsoft.FSharp.Core.ExtraTopLevelOperators: Single ToSingle[T](T)
-Microsoft.FSharp.Core.ExtraTopLevelOperators: System.Collections.Generic.IDictionary`2[TKey,TValue] CreateDictionary[TKey,TValue](System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,TValue]])
-Microsoft.FSharp.Core.ExtraTopLevelOperators: System.Collections.Generic.IReadOnlyDictionary`2[TKey,TValue] CreateReadOnlyDictionary[TKey,TValue](System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,TValue]])
-Microsoft.FSharp.Core.ExtraTopLevelOperators: T LazyPattern[T](System.Lazy`1[T])
-Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatLineToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatLineToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatLine[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToStringThenFail[T,TResult](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult])
-Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToString[T](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,System.String])
-Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormat[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Core.ExtraTopLevelOperators: T SpliceExpression[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T])
-Microsoft.FSharp.Core.ExtraTopLevelOperators: T SpliceUntypedExpression[T](Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Core.ExtraTopLevelOperators: T[,] CreateArray2D[?,T](System.Collections.Generic.IEnumerable`1[?])
-Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]: T1 Item
-Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]: T1 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2]: T2 Item
-Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2]: T2 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`2+Tags[T1,T2]: Int32 Choice1Of2
-Microsoft.FSharp.Core.FSharpChoice`2+Tags[T1,T2]: Int32 Choice2Of2
-Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`2[T1,T2])
-Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean Equals(System.Object)
-Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
-Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean IsChoice1Of2
-Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean IsChoice2Of2
-Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean get_IsChoice1Of2()
-Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean get_IsChoice2Of2()
-Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`2[T1,T2])
-Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 CompareTo(System.Object)
-Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 CompareTo(System.Object, System.Collections.IComparer)
-Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 GetHashCode()
-Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 GetHashCode(System.Collections.IEqualityComparer)
-Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 Tag
-Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 get_Tag()
-Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]
-Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2]
-Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2+Tags[T1,T2]
-Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2[T1,T2] NewChoice1Of2(T1)
-Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2[T1,T2] NewChoice2Of2(T2)
-Microsoft.FSharp.Core.FSharpChoice`3+Choice1Of3[T1,T2,T3]: T1 Item
-Microsoft.FSharp.Core.FSharpChoice`3+Choice1Of3[T1,T2,T3]: T1 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`3+Choice2Of3[T1,T2,T3]: T2 Item
-Microsoft.FSharp.Core.FSharpChoice`3+Choice2Of3[T1,T2,T3]: T2 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`3+Choice3Of3[T1,T2,T3]: T3 Item
-Microsoft.FSharp.Core.FSharpChoice`3+Choice3Of3[T1,T2,T3]: T3 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]: Int32 Choice1Of3
-Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]: Int32 Choice2Of3
-Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]: Int32 Choice3Of3
-Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3])
-Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean Equals(System.Object)
-Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
-Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean IsChoice1Of3
-Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean IsChoice2Of3
-Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean IsChoice3Of3
-Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean get_IsChoice1Of3()
-Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean get_IsChoice2Of3()
-Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean get_IsChoice3Of3()
-Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3])
-Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 CompareTo(System.Object)
-Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 CompareTo(System.Object, System.Collections.IComparer)
-Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 GetHashCode()
-Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 GetHashCode(System.Collections.IEqualityComparer)
-Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 Tag
-Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 get_Tag()
-Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Choice1Of3[T1,T2,T3]
-Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Choice2Of3[T1,T2,T3]
-Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Choice3Of3[T1,T2,T3]
-Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]
-Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3] NewChoice1Of3(T1)
-Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3] NewChoice2Of3(T2)
-Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3] NewChoice3Of3(T3)
-Microsoft.FSharp.Core.FSharpChoice`4+Choice1Of4[T1,T2,T3,T4]: T1 Item
-Microsoft.FSharp.Core.FSharpChoice`4+Choice1Of4[T1,T2,T3,T4]: T1 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`4+Choice2Of4[T1,T2,T3,T4]: T2 Item
-Microsoft.FSharp.Core.FSharpChoice`4+Choice2Of4[T1,T2,T3,T4]: T2 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`4+Choice3Of4[T1,T2,T3,T4]: T3 Item
-Microsoft.FSharp.Core.FSharpChoice`4+Choice3Of4[T1,T2,T3,T4]: T3 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`4+Choice4Of4[T1,T2,T3,T4]: T4 Item
-Microsoft.FSharp.Core.FSharpChoice`4+Choice4Of4[T1,T2,T3,T4]: T4 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice1Of4
-Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice2Of4
-Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice3Of4
-Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice4Of4
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4])
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean Equals(System.Object)
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice1Of4
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice2Of4
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice3Of4
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice4Of4
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice1Of4()
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice2Of4()
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice3Of4()
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice4Of4()
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4])
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 CompareTo(System.Object)
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 CompareTo(System.Object, System.Collections.IComparer)
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 GetHashCode()
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 GetHashCode(System.Collections.IEqualityComparer)
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 Tag
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 get_Tag()
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice1Of4[T1,T2,T3,T4]
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice2Of4[T1,T2,T3,T4]
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice3Of4[T1,T2,T3,T4]
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice4Of4[T1,T2,T3,T4]
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice1Of4(T1)
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice2Of4(T2)
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice3Of4(T3)
-Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice4Of4(T4)
-Microsoft.FSharp.Core.FSharpChoice`5+Choice1Of5[T1,T2,T3,T4,T5]: T1 Item
-Microsoft.FSharp.Core.FSharpChoice`5+Choice1Of5[T1,T2,T3,T4,T5]: T1 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`5+Choice2Of5[T1,T2,T3,T4,T5]: T2 Item
-Microsoft.FSharp.Core.FSharpChoice`5+Choice2Of5[T1,T2,T3,T4,T5]: T2 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`5+Choice3Of5[T1,T2,T3,T4,T5]: T3 Item
-Microsoft.FSharp.Core.FSharpChoice`5+Choice3Of5[T1,T2,T3,T4,T5]: T3 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`5+Choice4Of5[T1,T2,T3,T4,T5]: T4 Item
-Microsoft.FSharp.Core.FSharpChoice`5+Choice4Of5[T1,T2,T3,T4,T5]: T4 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`5+Choice5Of5[T1,T2,T3,T4,T5]: T5 Item
-Microsoft.FSharp.Core.FSharpChoice`5+Choice5Of5[T1,T2,T3,T4,T5]: T5 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice1Of5
-Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice2Of5
-Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice3Of5
-Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice4Of5
-Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice5Of5
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5])
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean Equals(System.Object)
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice1Of5
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice2Of5
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice3Of5
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice4Of5
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice5Of5
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice1Of5()
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice2Of5()
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice3Of5()
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice4Of5()
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice5Of5()
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5])
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 CompareTo(System.Object)
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 CompareTo(System.Object, System.Collections.IComparer)
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 GetHashCode()
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 GetHashCode(System.Collections.IEqualityComparer)
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 Tag
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 get_Tag()
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice1Of5[T1,T2,T3,T4,T5]
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice2Of5[T1,T2,T3,T4,T5]
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice3Of5[T1,T2,T3,T4,T5]
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice4Of5[T1,T2,T3,T4,T5]
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice5Of5[T1,T2,T3,T4,T5]
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice1Of5(T1)
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice2Of5(T2)
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice3Of5(T3)
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice4Of5(T4)
-Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice5Of5(T5)
-Microsoft.FSharp.Core.FSharpChoice`6+Choice1Of6[T1,T2,T3,T4,T5,T6]: T1 Item
-Microsoft.FSharp.Core.FSharpChoice`6+Choice1Of6[T1,T2,T3,T4,T5,T6]: T1 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`6+Choice2Of6[T1,T2,T3,T4,T5,T6]: T2 Item
-Microsoft.FSharp.Core.FSharpChoice`6+Choice2Of6[T1,T2,T3,T4,T5,T6]: T2 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`6+Choice3Of6[T1,T2,T3,T4,T5,T6]: T3 Item
-Microsoft.FSharp.Core.FSharpChoice`6+Choice3Of6[T1,T2,T3,T4,T5,T6]: T3 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`6+Choice4Of6[T1,T2,T3,T4,T5,T6]: T4 Item
-Microsoft.FSharp.Core.FSharpChoice`6+Choice4Of6[T1,T2,T3,T4,T5,T6]: T4 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`6+Choice5Of6[T1,T2,T3,T4,T5,T6]: T5 Item
-Microsoft.FSharp.Core.FSharpChoice`6+Choice5Of6[T1,T2,T3,T4,T5,T6]: T5 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`6+Choice6Of6[T1,T2,T3,T4,T5,T6]: T6 Item
-Microsoft.FSharp.Core.FSharpChoice`6+Choice6Of6[T1,T2,T3,T4,T5,T6]: T6 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice1Of6
-Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice2Of6
-Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice3Of6
-Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice4Of6
-Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice5Of6
-Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice6Of6
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6])
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean Equals(System.Object)
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice1Of6
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice2Of6
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice3Of6
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice4Of6
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice5Of6
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice6Of6
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice1Of6()
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice2Of6()
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice3Of6()
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice4Of6()
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice5Of6()
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice6Of6()
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6])
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 CompareTo(System.Object)
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 CompareTo(System.Object, System.Collections.IComparer)
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 GetHashCode()
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 GetHashCode(System.Collections.IEqualityComparer)
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 Tag
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 get_Tag()
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice1Of6[T1,T2,T3,T4,T5,T6]
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice2Of6[T1,T2,T3,T4,T5,T6]
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice3Of6[T1,T2,T3,T4,T5,T6]
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice4Of6[T1,T2,T3,T4,T5,T6]
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice5Of6[T1,T2,T3,T4,T5,T6]
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice6Of6[T1,T2,T3,T4,T5,T6]
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice1Of6(T1)
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice2Of6(T2)
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice3Of6(T3)
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice4Of6(T4)
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice5Of6(T5)
-Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice6Of6(T6)
-Microsoft.FSharp.Core.FSharpChoice`7+Choice1Of7[T1,T2,T3,T4,T5,T6,T7]: T1 Item
-Microsoft.FSharp.Core.FSharpChoice`7+Choice1Of7[T1,T2,T3,T4,T5,T6,T7]: T1 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`7+Choice2Of7[T1,T2,T3,T4,T5,T6,T7]: T2 Item
-Microsoft.FSharp.Core.FSharpChoice`7+Choice2Of7[T1,T2,T3,T4,T5,T6,T7]: T2 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`7+Choice3Of7[T1,T2,T3,T4,T5,T6,T7]: T3 Item
-Microsoft.FSharp.Core.FSharpChoice`7+Choice3Of7[T1,T2,T3,T4,T5,T6,T7]: T3 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`7+Choice4Of7[T1,T2,T3,T4,T5,T6,T7]: T4 Item
-Microsoft.FSharp.Core.FSharpChoice`7+Choice4Of7[T1,T2,T3,T4,T5,T6,T7]: T4 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`7+Choice5Of7[T1,T2,T3,T4,T5,T6,T7]: T5 Item
-Microsoft.FSharp.Core.FSharpChoice`7+Choice5Of7[T1,T2,T3,T4,T5,T6,T7]: T5 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`7+Choice6Of7[T1,T2,T3,T4,T5,T6,T7]: T6 Item
-Microsoft.FSharp.Core.FSharpChoice`7+Choice6Of7[T1,T2,T3,T4,T5,T6,T7]: T6 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`7+Choice7Of7[T1,T2,T3,T4,T5,T6,T7]: T7 Item
-Microsoft.FSharp.Core.FSharpChoice`7+Choice7Of7[T1,T2,T3,T4,T5,T6,T7]: T7 get_Item()
-Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice1Of7
-Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice2Of7
-Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice3Of7
-Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice4Of7
-Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice5Of7
-Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice6Of7
-Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice7Of7
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7])
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean Equals(System.Object)
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice1Of7
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice2Of7
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice3Of7
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice4Of7
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice5Of7
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice6Of7
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice7Of7
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice1Of7()
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice2Of7()
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice3Of7()
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice4Of7()
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice5Of7()
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice6Of7()
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice7Of7()
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7])
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 CompareTo(System.Object)
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 CompareTo(System.Object, System.Collections.IComparer)
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 GetHashCode()
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 GetHashCode(System.Collections.IEqualityComparer)
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 Tag
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 get_Tag()
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice1Of7[T1,T2,T3,T4,T5,T6,T7]
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice2Of7[T1,T2,T3,T4,T5,T6,T7]
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice3Of7[T1,T2,T3,T4,T5,T6,T7]
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice4Of7[T1,T2,T3,T4,T5,T6,T7]
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice5Of7[T1,T2,T3,T4,T5,T6,T7]
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice6Of7[T1,T2,T3,T4,T5,T6,T7]
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice7Of7[T1,T2,T3,T4,T5,T6,T7]
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice1Of7(T1)
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice2Of7(T2)
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice3Of7(T3)
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice4Of7(T4)
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice5Of7(T5)
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice6Of7(T6)
-Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice7Of7(T7)
-Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] FromConverter(System.Converter`2[T,TResult])
-Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] op_Implicit(System.Converter`2[T,TResult])
-Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: System.Converter`2[T,TResult] ToConverter(Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
-Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: System.Converter`2[T,TResult] op_Implicit(Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
-Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: TResult Invoke(T)
-Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: V InvokeFast[V](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,V]], T, TResult)
-Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Void .ctor()
-Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: W InvokeFast[V,W](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[V,W]]], T, TResult, V)
-Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: X InvokeFast[V,W,X](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[V,Microsoft.FSharp.Core.FSharpFunc`2[W,X]]]], T, TResult, V, W)
-Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Y InvokeFast[V,W,X,Y](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[V,Microsoft.FSharp.Core.FSharpFunc`2[W,Microsoft.FSharp.Core.FSharpFunc`2[X,Y]]]]], T, TResult, V, W, X)
-Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 Major
-Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 Minor
-Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 Release
-Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 get_Major()
-Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 get_Minor()
-Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 get_Release()
-Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Void .ctor(Int32, Int32, Int32)
-Microsoft.FSharp.Core.FSharpOption`1+Tags[T]: Int32 None
-Microsoft.FSharp.Core.FSharpOption`1+Tags[T]: Int32 Some
-Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpOption`1[T])
-Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean Equals(System.Object)
-Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
-Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean IsNone
-Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean IsSome
-Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean get_IsNone(Microsoft.FSharp.Core.FSharpOption`1[T])
-Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean get_IsSome(Microsoft.FSharp.Core.FSharpOption`1[T])
-Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpOption`1[T])
-Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 CompareTo(System.Object)
-Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer)
-Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 GetHashCode()
-Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer)
-Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 GetTag(Microsoft.FSharp.Core.FSharpOption`1[T])
-Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1+Tags[T]
-Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] None
-Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] Some(T)
-Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] get_None()
-Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] op_Implicit(T)
-Microsoft.FSharp.Core.FSharpOption`1[T]: System.String ToString()
-Microsoft.FSharp.Core.FSharpOption`1[T]: T Value
-Microsoft.FSharp.Core.FSharpOption`1[T]: T get_Value()
-Microsoft.FSharp.Core.FSharpOption`1[T]: Void .ctor(T)
-Microsoft.FSharp.Core.FSharpRef`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpRef`1[T])
-Microsoft.FSharp.Core.FSharpRef`1[T]: Boolean Equals(System.Object)
-Microsoft.FSharp.Core.FSharpRef`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
-Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpRef`1[T])
-Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 CompareTo(System.Object)
-Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer)
-Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 GetHashCode()
-Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer)
-Microsoft.FSharp.Core.FSharpRef`1[T]: T Value
-Microsoft.FSharp.Core.FSharpRef`1[T]: T contents
-Microsoft.FSharp.Core.FSharpRef`1[T]: T contents@
-Microsoft.FSharp.Core.FSharpRef`1[T]: T get_Value()
-Microsoft.FSharp.Core.FSharpRef`1[T]: T get_contents()
-Microsoft.FSharp.Core.FSharpRef`1[T]: Void .ctor(T)
-Microsoft.FSharp.Core.FSharpRef`1[T]: Void set_Value(T)
-Microsoft.FSharp.Core.FSharpRef`1[T]: Void set_contents(T)
-Microsoft.FSharp.Core.FSharpResult`2+Tags[T,TError]: Int32 Error
-Microsoft.FSharp.Core.FSharpResult`2+Tags[T,TError]: Int32 Ok
-Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean Equals(Microsoft.FSharp.Core.FSharpResult`2[T,TError])
-Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean Equals(System.Object)
-Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
-Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean IsError
-Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean IsOk
-Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean get_IsError()
-Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean get_IsOk()
-Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpResult`2[T,TError])
-Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 CompareTo(System.Object)
-Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 CompareTo(System.Object, System.Collections.IComparer)
-Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 GetHashCode()
-Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 GetHashCode(System.Collections.IEqualityComparer)
-Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 Tag
-Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 get_Tag()
-Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Microsoft.FSharp.Core.FSharpResult`2+Tags[T,TError]
-Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Microsoft.FSharp.Core.FSharpResult`2[T,TError] NewError(TError)
-Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Microsoft.FSharp.Core.FSharpResult`2[T,TError] NewOk(T)
-Microsoft.FSharp.Core.FSharpResult`2[T,TError]: T ResultValue
-Microsoft.FSharp.Core.FSharpResult`2[T,TError]: T get_ResultValue()
-Microsoft.FSharp.Core.FSharpResult`2[T,TError]: TError ErrorValue
-Microsoft.FSharp.Core.FSharpResult`2[T,TError]: TError get_ErrorValue()
-Microsoft.FSharp.Core.FSharpTypeFunc: System.Object Specialize[T]()
-Microsoft.FSharp.Core.FSharpTypeFunc: Void .ctor()
-Microsoft.FSharp.Core.FSharpValueOption`1+Tags[T]: Int32 ValueNone
-Microsoft.FSharp.Core.FSharpValueOption`1+Tags[T]: Int32 ValueSome
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpValueOption`1[T])
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean Equals(System.Object)
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsNone
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsSome
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsValueNone
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsValueSome
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsNone()
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsSome()
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsValueNone()
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsValueSome()
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpValueOption`1[T])
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 CompareTo(System.Object)
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer)
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 GetHashCode()
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer)
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 Tag
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 get_Tag()
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1+Tags[T]
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] NewValueSome(T)
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] None
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] Some(T)
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] ValueNone
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] get_None()
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] get_ValueNone()
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] op_Implicit(T)
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: System.String ToString()
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: T Item
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: T Value
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: T get_Item()
-Microsoft.FSharp.Core.FSharpValueOption`1[T]: T get_Value()
-Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit] FromAction(System.Action)
-Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T] FromFunc[T](System.Func`1[T])
-Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit] FromAction[T](System.Action`1[T])
-Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit] ToFSharpFunc[T](System.Action`1[T])
-Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] FromFunc[T,TResult](System.Func`2[T,TResult])
-Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] ToFSharpFunc[T,TResult](System.Converter`2[T,TResult])
-Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,Microsoft.FSharp.Core.Unit]]]]] FromAction[T1,T2,T3,T4,T5](System.Action`5[T1,T2,T3,T4,T5])
-Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]]] FromFunc[T1,T2,T3,T4,T5,TResult](System.Func`6[T1,T2,T3,T4,T5,TResult])
-Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]]] FuncFromTupled[T1,T2,T3,T4,T5,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`5[T1,T2,T3,T4,T5],TResult])
-Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.Unit]]]] FromAction[T1,T2,T3,T4](System.Action`4[T1,T2,T3,T4])
-Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]]] FromFunc[T1,T2,T3,T4,TResult](System.Func`5[T1,T2,T3,T4,TResult])
-Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]]] FuncFromTupled[T1,T2,T3,T4,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`4[T1,T2,T3,T4],TResult])
-Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.Unit]]] FromAction[T1,T2,T3](System.Action`3[T1,T2,T3])
-Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]] FromFunc[T1,T2,T3,TResult](System.Func`4[T1,T2,T3,TResult])
-Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]] FuncFromTupled[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[T1,T2,T3],TResult])
-Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]] FromAction[T1,T2](System.Action`2[T1,T2])
-Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]] FromFunc[T1,T2,TResult](System.Func`3[T1,T2,TResult])
-Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]] FuncFromTupled[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[T1,T2],TResult])
-Microsoft.FSharp.Core.GeneralizableValueAttribute: Void .ctor()
-Microsoft.FSharp.Core.InlineIfLambdaAttribute: Void .ctor()
-Microsoft.FSharp.Core.InterfaceAttribute: Void .ctor()
-Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String AddressOpNotFirstClassString
-Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String InputArrayEmptyString
-Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String InputMustBeNonNegativeString
-Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String InputSequenceEmptyString
-Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String NoNegateMinValueString
-Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_AddressOpNotFirstClassString()
-Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_InputArrayEmptyString()
-Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_InputMustBeNonNegativeString()
-Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_InputSequenceEmptyString()
-Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_NoNegateMinValueString()
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple2[T1,T2](System.Collections.IEqualityComparer, System.Tuple`2[T1,T2], System.Tuple`2[T1,T2])
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple3[T1,T2,T3](System.Collections.IEqualityComparer, System.Tuple`3[T1,T2,T3], System.Tuple`3[T1,T2,T3])
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple4[T1,T2,T3,T4](System.Collections.IEqualityComparer, System.Tuple`4[T1,T2,T3,T4], System.Tuple`4[T1,T2,T3,T4])
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple5[T1,T2,T3,T4,T5](System.Collections.IEqualityComparer, System.Tuple`5[T1,T2,T3,T4,T5], System.Tuple`5[T1,T2,T3,T4,T5])
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericEqualityERIntrinsic[T](T, T)
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericEqualityIntrinsic[T](T, T)
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericEqualityWithComparerIntrinsic[T](System.Collections.IEqualityComparer, T, T)
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericGreaterOrEqualIntrinsic[T](T, T)
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericGreaterThanIntrinsic[T](T, T)
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericLessOrEqualIntrinsic[T](T, T)
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericLessThanIntrinsic[T](T, T)
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean PhysicalEqualityIntrinsic[T](T, T)
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple2[T1,T2](System.Collections.IComparer, System.Tuple`2[T1,T2], System.Tuple`2[T1,T2])
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple3[T1,T2,T3](System.Collections.IComparer, System.Tuple`3[T1,T2,T3], System.Tuple`3[T1,T2,T3])
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple4[T1,T2,T3,T4](System.Collections.IComparer, System.Tuple`4[T1,T2,T3,T4], System.Tuple`4[T1,T2,T3,T4])
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple5[T1,T2,T3,T4,T5](System.Collections.IComparer, System.Tuple`5[T1,T2,T3,T4,T5], System.Tuple`5[T1,T2,T3,T4,T5])
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple2[T1,T2](System.Collections.IEqualityComparer, System.Tuple`2[T1,T2])
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple3[T1,T2,T3](System.Collections.IEqualityComparer, System.Tuple`3[T1,T2,T3])
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple4[T1,T2,T3,T4](System.Collections.IEqualityComparer, System.Tuple`4[T1,T2,T3,T4])
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple5[T1,T2,T3,T4,T5](System.Collections.IEqualityComparer, System.Tuple`5[T1,T2,T3,T4,T5])
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericComparisonIntrinsic[T](T, T)
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericComparisonWithComparerIntrinsic[T](System.Collections.IComparer, T, T)
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericHashIntrinsic[T](T)
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericHashWithComparerIntrinsic[T](System.Collections.IEqualityComparer, T)
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 LimitedGenericHashIntrinsic[T](Int32, T)
-Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 PhysicalHashIntrinsic[T](T)
-Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Boolean TypeTestFast[T](System.Object)
-Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Boolean TypeTestGeneric[T](System.Object)
-Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Char GetString(System.String, Int32)
-Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: System.Decimal MakeDecimal(Int32, Int32, Int32, Boolean, Byte)
-Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T CheckThis[T](T)
-Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T CreateInstance[T]()
-Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray2D[T](T[,], Int32, Int32)
-Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray3D[T](T[,,], Int32, Int32, Int32)
-Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray4D[T](T[,,,], Int32, Int32, Int32, Int32)
-Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray[T](T[], Int32)
-Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T UnboxFast[T](System.Object)
-Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T UnboxGeneric[T](System.Object)
-Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void Dispose[T](T)
-Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void FailInit()
-Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void FailStaticInit()
-Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray2D[T](T[,], Int32, Int32, T)
-Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray3D[T](T[,,], Int32, Int32, Int32, T)
-Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray4D[T](T[,,,], Int32, Int32, Int32, Int32, T)
-Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray[T](T[], Int32, T)
-Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean Or(Boolean, Boolean)
-Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean op_Amp(Boolean, Boolean)
-Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean op_BooleanAnd(Boolean, Boolean)
-Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean op_BooleanOr(Boolean, Boolean)
-Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: IntPtr op_IntegerAddressOf[T](T)
-Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: T& op_AddressOf[T](T)
-Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericEqualityER[T](T, T)
-Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericEqualityWithComparer[T](System.Collections.IEqualityComparer, T, T)
-Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericEquality[T](T, T)
-Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericGreaterOrEqual[T](T, T)
-Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericGreaterThan[T](T, T)
-Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericLessOrEqual[T](T, T)
-Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericLessThan[T](T, T)
-Microsoft.FSharp.Core.LanguagePrimitives: Boolean PhysicalEquality[T](T, T)
-Microsoft.FSharp.Core.LanguagePrimitives: Byte ByteWithMeasure(Byte)
-Microsoft.FSharp.Core.LanguagePrimitives: Double FloatWithMeasure(Double)
-Microsoft.FSharp.Core.LanguagePrimitives: Int16 Int16WithMeasure(Int16)
-Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericComparisonWithComparer[T](System.Collections.IComparer, T, T)
-Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericComparison[T](T, T)
-Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericHashWithComparer[T](System.Collections.IEqualityComparer, T)
-Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericHash[T](T)
-Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericLimitedHash[T](Int32, T)
-Microsoft.FSharp.Core.LanguagePrimitives: Int32 Int32WithMeasure(Int32)
-Microsoft.FSharp.Core.LanguagePrimitives: Int32 ParseInt32(System.String)
-Microsoft.FSharp.Core.LanguagePrimitives: Int32 PhysicalHash[T](T)
-Microsoft.FSharp.Core.LanguagePrimitives: Int64 Int64WithMeasure(Int64)
-Microsoft.FSharp.Core.LanguagePrimitives: Int64 ParseInt64(System.String)
-Microsoft.FSharp.Core.LanguagePrimitives: IntPtr IntPtrWithMeasure(IntPtr)
-Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings
-Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+HashCompare
-Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions
-Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators
-Microsoft.FSharp.Core.LanguagePrimitives: SByte SByteWithMeasure(SByte)
-Microsoft.FSharp.Core.LanguagePrimitives: Single Float32WithMeasure(Single)
-Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IComparer`1[T] FastGenericComparerFromTable[T]()
-Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IComparer`1[T] FastGenericComparer[T]()
-Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IEqualityComparer`1[T] FastGenericEqualityComparerFromTable[T]()
-Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IEqualityComparer`1[T] FastGenericEqualityComparer[T]()
-Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IEqualityComparer`1[T] FastLimitedGenericEqualityComparer[T](Int32)
-Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IComparer GenericComparer
-Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IComparer get_GenericComparer()
-Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer GenericEqualityComparer
-Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer GenericEqualityERComparer
-Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer get_GenericEqualityComparer()
-Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer get_GenericEqualityERComparer()
-Microsoft.FSharp.Core.LanguagePrimitives: System.Decimal DecimalWithMeasure(System.Decimal)
-Microsoft.FSharp.Core.LanguagePrimitives: T DivideByInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], T, Int32)
-Microsoft.FSharp.Core.LanguagePrimitives: T DivideByIntDynamic[T](T, Int32)
-Microsoft.FSharp.Core.LanguagePrimitives: T DivideByInt[T](T, Int32)
-Microsoft.FSharp.Core.LanguagePrimitives: T EnumToValue[TEnum,T](TEnum)
-Microsoft.FSharp.Core.LanguagePrimitives: T GenericMaximum[T](T, T)
-Microsoft.FSharp.Core.LanguagePrimitives: T GenericMinimum[T](T, T)
-Microsoft.FSharp.Core.LanguagePrimitives: T GenericOne$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T])
-Microsoft.FSharp.Core.LanguagePrimitives: T GenericOneDynamic[T]()
-Microsoft.FSharp.Core.LanguagePrimitives: T GenericOne[T]()
-Microsoft.FSharp.Core.LanguagePrimitives: T GenericZero$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T])
-Microsoft.FSharp.Core.LanguagePrimitives: T GenericZeroDynamic[T]()
-Microsoft.FSharp.Core.LanguagePrimitives: T GenericZero[T]()
-Microsoft.FSharp.Core.LanguagePrimitives: TEnum EnumOfValue[T,TEnum](T)
-Microsoft.FSharp.Core.LanguagePrimitives: TResult AdditionDynamic[T1,T2,TResult](T1, T2)
-Microsoft.FSharp.Core.LanguagePrimitives: TResult BitwiseAndDynamic[T1,T2,TResult](T1, T2)
-Microsoft.FSharp.Core.LanguagePrimitives: TResult BitwiseOrDynamic[T1,T2,TResult](T1, T2)
-Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedAdditionDynamic[T1,T2,TResult](T1, T2)
-Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedExplicitDynamic[T,TResult](T)
-Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedMultiplyDynamic[T1,T2,TResult](T1, T2)
-Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedSubtractionDynamic[T1,T2,TResult](T1, T2)
-Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedUnaryNegationDynamic[T,TResult](T)
-Microsoft.FSharp.Core.LanguagePrimitives: TResult DivisionDynamic[T1,T2,TResult](T1, T2)
-Microsoft.FSharp.Core.LanguagePrimitives: TResult EqualityDynamic[T1,T2,TResult](T1, T2)
-Microsoft.FSharp.Core.LanguagePrimitives: TResult ExclusiveOrDynamic[T1,T2,TResult](T1, T2)
-Microsoft.FSharp.Core.LanguagePrimitives: TResult ExplicitDynamic[T,TResult](T)
-Microsoft.FSharp.Core.LanguagePrimitives: TResult GreaterThanDynamic[T1,T2,TResult](T1, T2)
-Microsoft.FSharp.Core.LanguagePrimitives: TResult GreaterThanOrEqualDynamic[T1,T2,TResult](T1, T2)
-Microsoft.FSharp.Core.LanguagePrimitives: TResult InequalityDynamic[T1,T2,TResult](T1, T2)
-Microsoft.FSharp.Core.LanguagePrimitives: TResult LeftShiftDynamic[T1,T2,TResult](T1, T2)
-Microsoft.FSharp.Core.LanguagePrimitives: TResult LessThanDynamic[T1,T2,TResult](T1, T2)
-Microsoft.FSharp.Core.LanguagePrimitives: TResult LessThanOrEqualDynamic[T1,T2,TResult](T1, T2)
-Microsoft.FSharp.Core.LanguagePrimitives: TResult LogicalNotDynamic[T,TResult](T)
-Microsoft.FSharp.Core.LanguagePrimitives: TResult ModulusDynamic[T1,T2,TResult](T1, T2)
-Microsoft.FSharp.Core.LanguagePrimitives: TResult MultiplyDynamic[T1,T2,TResult](T1, T2)
-Microsoft.FSharp.Core.LanguagePrimitives: TResult RightShiftDynamic[T1,T2,TResult](T1, T2)
-Microsoft.FSharp.Core.LanguagePrimitives: TResult SubtractionDynamic[T1,T2,TResult](T1, T2)
-Microsoft.FSharp.Core.LanguagePrimitives: TResult UnaryNegationDynamic[T,TResult](T)
-Microsoft.FSharp.Core.LanguagePrimitives: UInt16 UInt16WithMeasure(UInt16)
-Microsoft.FSharp.Core.LanguagePrimitives: UInt32 ParseUInt32(System.String)
-Microsoft.FSharp.Core.LanguagePrimitives: UInt32 UInt32WithMeasure(UInt32)
-Microsoft.FSharp.Core.LanguagePrimitives: UInt64 ParseUInt64(System.String)
-Microsoft.FSharp.Core.LanguagePrimitives: UInt64 UInt64WithMeasure(UInt64)
-Microsoft.FSharp.Core.LanguagePrimitives: UIntPtr UIntPtrWithMeasure(UIntPtr)
-Microsoft.FSharp.Core.LiteralAttribute: Void .ctor()
-Microsoft.FSharp.Core.MatchFailureException: Boolean Equals(System.Object)
-Microsoft.FSharp.Core.MatchFailureException: Boolean Equals(System.Object, System.Collections.IEqualityComparer)
-Microsoft.FSharp.Core.MatchFailureException: Int32 Data1
-Microsoft.FSharp.Core.MatchFailureException: Int32 Data2
-Microsoft.FSharp.Core.MatchFailureException: Int32 GetHashCode()
-Microsoft.FSharp.Core.MatchFailureException: Int32 GetHashCode(System.Collections.IEqualityComparer)
-Microsoft.FSharp.Core.MatchFailureException: Int32 get_Data1()
-Microsoft.FSharp.Core.MatchFailureException: Int32 get_Data2()
-Microsoft.FSharp.Core.MatchFailureException: System.String Data0
-Microsoft.FSharp.Core.MatchFailureException: System.String Message
-Microsoft.FSharp.Core.MatchFailureException: System.String get_Data0()
-Microsoft.FSharp.Core.MatchFailureException: System.String get_Message()
-Microsoft.FSharp.Core.MatchFailureException: Void .ctor()
-Microsoft.FSharp.Core.MatchFailureException: Void .ctor(System.String, Int32, Int32)
-Microsoft.FSharp.Core.MeasureAnnotatedAbbreviationAttribute: Void .ctor()
-Microsoft.FSharp.Core.MeasureAttribute: Void .ctor()
-Microsoft.FSharp.Core.NoComparisonAttribute: Void .ctor()
-Microsoft.FSharp.Core.NoDynamicInvocationAttribute: Void .ctor()
-Microsoft.FSharp.Core.NoEqualityAttribute: Void .ctor()
-Microsoft.FSharp.Core.NoCompilerInliningAttribute: Void .ctor()
-Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: System.Object FromInt64Dynamic(Int64)
-Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: System.Object FromStringDynamic(System.String)
-Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromInt32[T](Int32)
-Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromInt64[T](Int64)
-Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromOne[T]()
-Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromString[T](System.String)
-Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromZero[T]()
-Microsoft.FSharp.Core.NumericLiterals: Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI
-Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 String.GetReverseIndex(System.String, Int32, Int32)
-Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 [,,,]`1.GetReverseIndex[T](T[,,,], Int32, Int32)
-Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 [,,]`1.GetReverseIndex[T](T[,,], Int32, Int32)
-Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 [,]`1.GetReverseIndex[T](T[,], Int32, Int32)
-Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 []`1.GetReverseIndex[T](T[], Int32, Int32)
-Microsoft.FSharp.Core.Operators+Checked: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T)
-Microsoft.FSharp.Core.Operators+Checked: Byte ToByte[T](T)
-Microsoft.FSharp.Core.Operators+Checked: Char ToChar$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Char], T)
-Microsoft.FSharp.Core.Operators+Checked: Char ToChar[T](T)
-Microsoft.FSharp.Core.Operators+Checked: Int16 ToInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int16], T)
-Microsoft.FSharp.Core.Operators+Checked: Int16 ToInt16[T](T)
-Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T)
-Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T)
-Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt32[T](T)
-Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt[T](T)
-Microsoft.FSharp.Core.Operators+Checked: Int64 ToInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int64], T)
-Microsoft.FSharp.Core.Operators+Checked: Int64 ToInt64[T](T)
-Microsoft.FSharp.Core.Operators+Checked: IntPtr ToIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.IntPtr], T)
-Microsoft.FSharp.Core.Operators+Checked: IntPtr ToIntPtr[T](T)
-Microsoft.FSharp.Core.Operators+Checked: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T)
-Microsoft.FSharp.Core.Operators+Checked: SByte ToSByte[T](T)
-Microsoft.FSharp.Core.Operators+Checked: T op_UnaryNegation$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
-Microsoft.FSharp.Core.Operators+Checked: T op_UnaryNegation[T](T)
-Microsoft.FSharp.Core.Operators+Checked: T3 op_Addition$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
-Microsoft.FSharp.Core.Operators+Checked: T3 op_Addition[T1,T2,T3](T1, T2)
-Microsoft.FSharp.Core.Operators+Checked: T3 op_Multiply$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
-Microsoft.FSharp.Core.Operators+Checked: T3 op_Multiply[T1,T2,T3](T1, T2)
-Microsoft.FSharp.Core.Operators+Checked: T3 op_Subtraction$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
-Microsoft.FSharp.Core.Operators+Checked: T3 op_Subtraction[T1,T2,T3](T1, T2)
-Microsoft.FSharp.Core.Operators+Checked: UInt16 ToUInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt16], T)
-Microsoft.FSharp.Core.Operators+Checked: UInt16 ToUInt16[T](T)
-Microsoft.FSharp.Core.Operators+Checked: UInt32 ToUInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], T)
-Microsoft.FSharp.Core.Operators+Checked: UInt32 ToUInt32[T](T)
-Microsoft.FSharp.Core.Operators+Checked: UInt64 ToUInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt64], T)
-Microsoft.FSharp.Core.Operators+Checked: UInt64 ToUInt64[T](T)
-Microsoft.FSharp.Core.Operators+Checked: UIntPtr ToUIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UIntPtr], T)
-Microsoft.FSharp.Core.Operators+Checked: UIntPtr ToUIntPtr[T](T)
-Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Equality$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T)
-Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Equality[T](T, T)
-Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThan$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult)
-Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThanOrEqual$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult)
-Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThanOrEqual[T,TResult](T, TResult)
-Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThan[T,TResult](T, TResult)
-Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Inequality$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T)
-Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Inequality[T](T, T)
-Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThan$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult)
-Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThanOrEqual$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult)
-Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThanOrEqual[T,TResult](T, TResult)
-Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThan[T,TResult](T, TResult)
-Microsoft.FSharp.Core.Operators+NonStructuralComparison: Int32 Compare$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T)
-Microsoft.FSharp.Core.Operators+NonStructuralComparison: Int32 Compare[T](T, T)
-Microsoft.FSharp.Core.Operators+NonStructuralComparison: Int32 Hash[T](T)
-Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Max$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T)
-Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Max[T](T, T)
-Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Min$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T)
-Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Min[T](T, T)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Byte PowByte(Byte, Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Double PowDouble(Double, Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int16 PowInt16(Int16, Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int32 PowInt32(Int32, Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int32 SignDynamic[T](T)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int64 PowInt64(Int64, Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: IntPtr PowIntPtr(IntPtr, Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: SByte PowSByte(SByte, Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Single PowSingle(Single, Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Byte] RangeByte(Byte, Byte, Byte)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Char] RangeChar(Char, Char)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Double] RangeDouble(Double, Double, Double)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Int16] RangeInt16(Int16, Int16, Int16)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Int32] RangeInt32(Int32, Int32, Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Int64] RangeInt64(Int64, Int64, Int64)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.IntPtr] RangeIntPtr(IntPtr, IntPtr, IntPtr)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.SByte] RangeSByte(SByte, SByte, SByte)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Single] RangeSingle(Single, Single, Single)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UInt16] RangeUInt16(UInt16, UInt16, UInt16)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UInt32] RangeUInt32(UInt32, UInt32, UInt32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UInt64] RangeUInt64(UInt64, UInt64, UInt64)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UIntPtr] RangeUIntPtr(UIntPtr, UIntPtr, UIntPtr)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[T] RangeGeneric[T](T, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[T] RangeStepGeneric[TStep,T](TStep, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TStep,T]], T, TStep, T)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Decimal PowDecimal(System.Decimal, Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.String GetStringSlice(System.String, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AbsDynamic[T](T)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AcosDynamic[T](T)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AsinDynamic[T](T)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AtanDynamic[T](T)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T CeilingDynamic[T](T)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T CosDynamic[T](T)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T CoshDynamic[T](T)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T ExpDynamic[T](T)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T FloorDynamic[T](T)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T Log10Dynamic[T](T)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T LogDynamic[T](T)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T PowDynamic[T,TResult](T, TResult)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T PowGeneric[T](T, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T RoundDynamic[T](T)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T SinDynamic[T](T)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T SinhDynamic[T](T)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T TanDynamic[T](T)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T TanhDynamic[T](T)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T TruncateDynamic[T](T)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T2 Atan2Dynamic[T1,T2](T1, T1)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T2 SqrtDynamic[T1,T2](T1)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,,] GetArraySlice4D[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice3D[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle1[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle2[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle3[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice2D[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice3DFixedSingle1[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice3DFixedSingle2[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice3DFixedSingle3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble1[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble3[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble5[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble6[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice2DFixed1[T](T[,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice2DFixed2[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice3DFixedDouble1[T](T[,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice3DFixedDouble2[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice3DFixedDouble3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple1[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple3[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple4[T](T[,,,], Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice[T](T[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UInt16 PowUInt16(UInt16, Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UInt32 PowUInt32(UInt32, Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UInt64 PowUInt64(UInt64, Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UIntPtr PowUIntPtr(UIntPtr, Int32)
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice2DFixed1[T](T[,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice2DFixed2[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice2D[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedDouble1[T](T[,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedDouble2[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedDouble3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, T[])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedSingle1[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedSingle2[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedSingle3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3D[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble1[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble3[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble5[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble6[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, T[,])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle1[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle2[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle3[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,,])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple1[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Int32, T[])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, T[])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple3[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple4[T](T[,,,], Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4D[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,,])
-Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice[T](T[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[])
-Microsoft.FSharp.Core.Operators+Unchecked: Boolean Equals[T](T, T)
-Microsoft.FSharp.Core.Operators+Unchecked: Int32 Compare[T](T, T)
-Microsoft.FSharp.Core.Operators+Unchecked: Int32 Hash[T](T)
-Microsoft.FSharp.Core.Operators+Unchecked: T DefaultOf[T]()
-Microsoft.FSharp.Core.Operators+Unchecked: T Unbox[T](System.Object)
-Microsoft.FSharp.Core.Operators: Boolean IsNull[T](T)
-Microsoft.FSharp.Core.Operators: Boolean Not(Boolean)
-Microsoft.FSharp.Core.Operators: Boolean op_Equality[T](T, T)
-Microsoft.FSharp.Core.Operators: Boolean op_GreaterThanOrEqual[T](T, T)
-Microsoft.FSharp.Core.Operators: Boolean op_GreaterThan[T](T, T)
-Microsoft.FSharp.Core.Operators: Boolean op_Inequality[T](T, T)
-Microsoft.FSharp.Core.Operators: Boolean op_LessThanOrEqual[T](T, T)
-Microsoft.FSharp.Core.Operators: Boolean op_LessThan[T](T, T)
-Microsoft.FSharp.Core.Operators: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T)
-Microsoft.FSharp.Core.Operators: Byte ToByte[T](T)
-Microsoft.FSharp.Core.Operators: Char ToChar$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Char], T)
-Microsoft.FSharp.Core.Operators: Char ToChar[T](T)
-Microsoft.FSharp.Core.Operators: Double Infinity
-Microsoft.FSharp.Core.Operators: Double NaN
-Microsoft.FSharp.Core.Operators: Double ToDouble$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], T)
-Microsoft.FSharp.Core.Operators: Double ToDouble[T](T)
-Microsoft.FSharp.Core.Operators: Double get_Infinity()
-Microsoft.FSharp.Core.Operators: Double get_NaN()
-Microsoft.FSharp.Core.Operators: Int16 ToInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int16], T)
-Microsoft.FSharp.Core.Operators: Int16 ToInt16[T](T)
-Microsoft.FSharp.Core.Operators: Int32 Compare[T](T, T)
-Microsoft.FSharp.Core.Operators: Int32 Hash[T](T)
-Microsoft.FSharp.Core.Operators: Int32 Sign$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T)
-Microsoft.FSharp.Core.Operators: Int32 Sign[T](T)
-Microsoft.FSharp.Core.Operators: Int32 SizeOf[T]()
-Microsoft.FSharp.Core.Operators: Int32 ToInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T)
-Microsoft.FSharp.Core.Operators: Int32 ToInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T)
-Microsoft.FSharp.Core.Operators: Int32 ToInt32[T](T)
-Microsoft.FSharp.Core.Operators: Int32 ToInt[T](T)
-Microsoft.FSharp.Core.Operators: Int32 limitedHash[T](Int32, T)
-Microsoft.FSharp.Core.Operators: Int64 ToInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int64], T)
-Microsoft.FSharp.Core.Operators: Int64 ToInt64[T](T)
-Microsoft.FSharp.Core.Operators: IntPtr ToIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.IntPtr], T)
-Microsoft.FSharp.Core.Operators: IntPtr ToIntPtr[T](T)
-Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Collections.FSharpList`1[T] op_Append[T](Microsoft.FSharp.Collections.FSharpList`1[T], Microsoft.FSharp.Collections.FSharpList`1[T])
-Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpFunc`2[T1,T3] op_ComposeLeft[T2,T3,T1](Microsoft.FSharp.Core.FSharpFunc`2[T2,T3], Microsoft.FSharp.Core.FSharpFunc`2[T1,T2])
-Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpFunc`2[T1,T3] op_ComposeRight[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,T2], Microsoft.FSharp.Core.FSharpFunc`2[T2,T3])
-Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpOption`1[System.String] FailurePattern(System.Exception)
-Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpOption`1[T] TryUnbox[T](System.Object)
-Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpRef`1[T] Ref[T](T)
-Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+ArrayExtensions
-Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+Checked
-Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+NonStructuralComparison
-Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+OperatorIntrinsics
-Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+Unchecked
-Microsoft.FSharp.Core.Operators: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T)
-Microsoft.FSharp.Core.Operators: SByte ToSByte[T](T)
-Microsoft.FSharp.Core.Operators: Single InfinitySingle
-Microsoft.FSharp.Core.Operators: Single NaNSingle
-Microsoft.FSharp.Core.Operators: Single ToSingle$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], T)
-Microsoft.FSharp.Core.Operators: Single ToSingle[T](T)
-Microsoft.FSharp.Core.Operators: Single get_InfinitySingle()
-Microsoft.FSharp.Core.Operators: Single get_NaNSingle()
-Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] CreateSequence[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_Range$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T)
-Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_RangeStep$W[T,TStep](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TStep], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TStep,T]], T, TStep, T)
-Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_RangeStep[T,TStep](T, TStep, T)
-Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_Range[T](T, T)
-Microsoft.FSharp.Core.Operators: System.Decimal ToDecimal$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Decimal], T)
-Microsoft.FSharp.Core.Operators: System.Decimal ToDecimal[T](T)
-Microsoft.FSharp.Core.Operators: System.Exception Failure(System.String)
-Microsoft.FSharp.Core.Operators: System.IO.TextReader ConsoleIn[T]()
-Microsoft.FSharp.Core.Operators: System.IO.TextWriter ConsoleError[T]()
-Microsoft.FSharp.Core.Operators: System.IO.TextWriter ConsoleOut[T]()
-Microsoft.FSharp.Core.Operators: System.Object Box[T](T)
-Microsoft.FSharp.Core.Operators: System.String NameOf[T](T)
-Microsoft.FSharp.Core.Operators: System.String ToString[T](T)
-Microsoft.FSharp.Core.Operators: System.String op_Concatenate(System.String, System.String)
-Microsoft.FSharp.Core.Operators: System.Tuple`2[TKey,TValue] KeyValuePattern[TKey,TValue](System.Collections.Generic.KeyValuePair`2[TKey,TValue])
-Microsoft.FSharp.Core.Operators: System.Type TypeDefOf[T]()
-Microsoft.FSharp.Core.Operators: System.Type TypeOf[T]()
-Microsoft.FSharp.Core.Operators: T Abs$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
-Microsoft.FSharp.Core.Operators: T Abs[T](T)
-Microsoft.FSharp.Core.Operators: T Acos$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
-Microsoft.FSharp.Core.Operators: T Acos[T](T)
-Microsoft.FSharp.Core.Operators: T Asin$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
-Microsoft.FSharp.Core.Operators: T Asin[T](T)
-Microsoft.FSharp.Core.Operators: T Atan$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
-Microsoft.FSharp.Core.Operators: T Atan[T](T)
-Microsoft.FSharp.Core.Operators: T Ceiling$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
-Microsoft.FSharp.Core.Operators: T Ceiling[T](T)
-Microsoft.FSharp.Core.Operators: T Cos$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
-Microsoft.FSharp.Core.Operators: T Cos[T](T)
-Microsoft.FSharp.Core.Operators: T Cosh$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
-Microsoft.FSharp.Core.Operators: T Cosh[T](T)
-Microsoft.FSharp.Core.Operators: T DefaultArg[T](Microsoft.FSharp.Core.FSharpOption`1[T], T)
-Microsoft.FSharp.Core.Operators: T DefaultValueArg[T](Microsoft.FSharp.Core.FSharpValueOption`1[T], T)
-Microsoft.FSharp.Core.Operators: T Exit[T](Int32)
-Microsoft.FSharp.Core.Operators: T Exp$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
-Microsoft.FSharp.Core.Operators: T Exp[T](T)
-Microsoft.FSharp.Core.Operators: T FailWith[T](System.String)
-Microsoft.FSharp.Core.Operators: T Floor$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
-Microsoft.FSharp.Core.Operators: T Floor[T](T)
-Microsoft.FSharp.Core.Operators: T Identity[T](T)
-Microsoft.FSharp.Core.Operators: T InvalidArg[T](System.String, System.String)
-Microsoft.FSharp.Core.Operators: T InvalidOp[T](System.String)
-Microsoft.FSharp.Core.Operators: T Lock[TLock,T](TLock, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T])
-Microsoft.FSharp.Core.Operators: T Log$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
-Microsoft.FSharp.Core.Operators: T Log10$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
-Microsoft.FSharp.Core.Operators: T Log10[T](T)
-Microsoft.FSharp.Core.Operators: T Log[T](T)
-Microsoft.FSharp.Core.Operators: T Max[T](T, T)
-Microsoft.FSharp.Core.Operators: T Min[T](T, T)
-Microsoft.FSharp.Core.Operators: T NullArg[T](System.String)
-Microsoft.FSharp.Core.Operators: T PowInteger$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, Int32)
-Microsoft.FSharp.Core.Operators: T PowInteger[T](T, Int32)
-Microsoft.FSharp.Core.Operators: T Raise[T](System.Exception)
-Microsoft.FSharp.Core.Operators: T Reraise[T]()
-Microsoft.FSharp.Core.Operators: T Rethrow[T]()
-Microsoft.FSharp.Core.Operators: T Round$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
-Microsoft.FSharp.Core.Operators: T Round[T](T)
-Microsoft.FSharp.Core.Operators: T Sin$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
-Microsoft.FSharp.Core.Operators: T Sin[T](T)
-Microsoft.FSharp.Core.Operators: T Sinh$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
-Microsoft.FSharp.Core.Operators: T Sinh[T](T)
-Microsoft.FSharp.Core.Operators: T Tan$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
-Microsoft.FSharp.Core.Operators: T Tan[T](T)
-Microsoft.FSharp.Core.Operators: T Tanh$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
-Microsoft.FSharp.Core.Operators: T Tanh[T](T)
-Microsoft.FSharp.Core.Operators: T Truncate$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
-Microsoft.FSharp.Core.Operators: T Truncate[T](T)
-Microsoft.FSharp.Core.Operators: T Unbox[T](System.Object)
-Microsoft.FSharp.Core.Operators: T op_BitwiseAnd$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T)
-Microsoft.FSharp.Core.Operators: T op_BitwiseAnd[T](T, T)
-Microsoft.FSharp.Core.Operators: T op_BitwiseOr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T)
-Microsoft.FSharp.Core.Operators: T op_BitwiseOr[T](T, T)
-Microsoft.FSharp.Core.Operators: T op_Dereference[T](Microsoft.FSharp.Core.FSharpRef`1[T])
-Microsoft.FSharp.Core.Operators: T op_ExclusiveOr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T)
-Microsoft.FSharp.Core.Operators: T op_ExclusiveOr[T](T, T)
-Microsoft.FSharp.Core.Operators: T op_Exponentiation$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,T]], T, TResult)
-Microsoft.FSharp.Core.Operators: T op_Exponentiation[T,TResult](T, TResult)
-Microsoft.FSharp.Core.Operators: T op_LeftShift$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], T, Int32)
-Microsoft.FSharp.Core.Operators: T op_LeftShift[T](T, Int32)
-Microsoft.FSharp.Core.Operators: T op_LogicalNot$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
-Microsoft.FSharp.Core.Operators: T op_LogicalNot[T](T)
-Microsoft.FSharp.Core.Operators: T op_RightShift$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], T, Int32)
-Microsoft.FSharp.Core.Operators: T op_RightShift[T](T, Int32)
-Microsoft.FSharp.Core.Operators: T op_UnaryNegation$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
-Microsoft.FSharp.Core.Operators: T op_UnaryNegation[T](T)
-Microsoft.FSharp.Core.Operators: T op_UnaryPlus$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T)
-Microsoft.FSharp.Core.Operators: T op_UnaryPlus[T](T)
-Microsoft.FSharp.Core.Operators: T1 Fst[T1,T2](System.Tuple`2[T1,T2])
-Microsoft.FSharp.Core.Operators: T2 Atan2$W[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T1,T2]], T1, T1)
-Microsoft.FSharp.Core.Operators: T2 Atan2[T1,T2](T1, T1)
-Microsoft.FSharp.Core.Operators: T2 Snd[T1,T2](System.Tuple`2[T1,T2])
-Microsoft.FSharp.Core.Operators: T3 op_Addition$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
-Microsoft.FSharp.Core.Operators: T3 op_Addition[T1,T2,T3](T1, T2)
-Microsoft.FSharp.Core.Operators: T3 op_Division$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
-Microsoft.FSharp.Core.Operators: T3 op_Division[T1,T2,T3](T1, T2)
-Microsoft.FSharp.Core.Operators: T3 op_Modulus$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
-Microsoft.FSharp.Core.Operators: T3 op_Modulus[T1,T2,T3](T1, T2)
-Microsoft.FSharp.Core.Operators: T3 op_Multiply$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
-Microsoft.FSharp.Core.Operators: T3 op_Multiply[T1,T2,T3](T1, T2)
-Microsoft.FSharp.Core.Operators: T3 op_Subtraction$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2)
-Microsoft.FSharp.Core.Operators: T3 op_Subtraction[T1,T2,T3](T1, T2)
-Microsoft.FSharp.Core.Operators: TResult Sqrt$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T)
-Microsoft.FSharp.Core.Operators: TResult Sqrt[T,TResult](T)
-Microsoft.FSharp.Core.Operators: TResult ToEnum[TResult](Int32)
-Microsoft.FSharp.Core.Operators: TResult Using[T,TResult](T, Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
-Microsoft.FSharp.Core.Operators: TResult op_PipeLeft2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], T1, T2)
-Microsoft.FSharp.Core.Operators: TResult op_PipeLeft3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], T1, T2, T3)
-Microsoft.FSharp.Core.Operators: TResult op_PipeLeft[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T)
-Microsoft.FSharp.Core.Operators: TResult op_PipeRight2[T1,T2,TResult](T1, T2, Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]])
-Microsoft.FSharp.Core.Operators: TResult op_PipeRight3[T1,T2,T3,TResult](T1, T2, T3, Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]])
-Microsoft.FSharp.Core.Operators: TResult op_PipeRight[T1,TResult](T1, Microsoft.FSharp.Core.FSharpFunc`2[T1,TResult])
-Microsoft.FSharp.Core.Operators: UInt16 ToUInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt16], T)
-Microsoft.FSharp.Core.Operators: UInt16 ToUInt16[T](T)
-Microsoft.FSharp.Core.Operators: UInt32 ToUInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], T)
-Microsoft.FSharp.Core.Operators: UInt32 ToUInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], T)
-Microsoft.FSharp.Core.Operators: UInt32 ToUInt32[T](T)
-Microsoft.FSharp.Core.Operators: UInt32 ToUInt[T](T)
-Microsoft.FSharp.Core.Operators: UInt64 ToUInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt64], T)
-Microsoft.FSharp.Core.Operators: UInt64 ToUInt64[T](T)
-Microsoft.FSharp.Core.Operators: UIntPtr ToUIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UIntPtr], T)
-Microsoft.FSharp.Core.Operators: UIntPtr ToUIntPtr[T](T)
-Microsoft.FSharp.Core.Operators: Void Decrement(Microsoft.FSharp.Core.FSharpRef`1[System.Int32])
-Microsoft.FSharp.Core.Operators: Void Ignore[T](T)
-Microsoft.FSharp.Core.Operators: Void Increment(Microsoft.FSharp.Core.FSharpRef`1[System.Int32])
-Microsoft.FSharp.Core.Operators: Void op_ColonEquals[T](Microsoft.FSharp.Core.FSharpRef`1[T], T)
-Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: FSharpFunc`3 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]])
-Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult] Invoke(T1)
-Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: TResult Invoke(T1, T2)
-Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: Void .ctor()
-Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: FSharpFunc`4 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]])
-Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]] Invoke(T1)
-Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: TResult Invoke(T1, T2, T3)
-Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: Void .ctor()
-Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: FSharpFunc`5 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]]])
-Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]] Invoke(T1)
-Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: TResult Invoke(T1, T2, T3, T4)
-Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: Void .ctor()
-Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: FSharpFunc`6 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]]])
-Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]] Invoke(T1)
-Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: TResult Invoke(T1, T2, T3, T4, T5)
-Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: Void .ctor()
-Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]
-Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]
-Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]
-Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]
-Microsoft.FSharp.Core.OptionModule: Boolean Contains[T](T, Microsoft.FSharp.Core.FSharpOption`1[T])
-Microsoft.FSharp.Core.OptionModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[T])
-Microsoft.FSharp.Core.OptionModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[T])
-Microsoft.FSharp.Core.OptionModule: Boolean IsNone[T](Microsoft.FSharp.Core.FSharpOption`1[T])
-Microsoft.FSharp.Core.OptionModule: Boolean IsSome[T](Microsoft.FSharp.Core.FSharpOption`1[T])
-Microsoft.FSharp.Core.OptionModule: Int32 Count[T](Microsoft.FSharp.Core.FSharpOption`1[T])
-Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](Microsoft.FSharp.Core.FSharpOption`1[T])
-Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Core.FSharpOption`1[T])
-Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], Microsoft.FSharp.Core.FSharpOption`1[T1], Microsoft.FSharp.Core.FSharpOption`1[T2])
-Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], Microsoft.FSharp.Core.FSharpOption`1[T1], Microsoft.FSharp.Core.FSharpOption`1[T2], Microsoft.FSharp.Core.FSharpOption`1[T3])
-Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Core.FSharpOption`1[T])
-Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[T])
-Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] Flatten[T](Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpOption`1[T]])
-Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OfNullable[T](System.Nullable`1[T])
-Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OfObj[T](T)
-Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OrElseWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.FSharpOption`1[T]], Microsoft.FSharp.Core.FSharpOption`1[T])
-Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OrElse[T](Microsoft.FSharp.Core.FSharpOption`1[T], Microsoft.FSharp.Core.FSharpOption`1[T])
-Microsoft.FSharp.Core.OptionModule: System.Nullable`1[T] ToNullable[T](Microsoft.FSharp.Core.FSharpOption`1[T])
-Microsoft.FSharp.Core.OptionModule: T DefaultValue[T](T, Microsoft.FSharp.Core.FSharpOption`1[T])
-Microsoft.FSharp.Core.OptionModule: T DefaultWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpOption`1[T])
-Microsoft.FSharp.Core.OptionModule: T GetValue[T](Microsoft.FSharp.Core.FSharpOption`1[T])
-Microsoft.FSharp.Core.OptionModule: T ToObj[T](Microsoft.FSharp.Core.FSharpOption`1[T])
-Microsoft.FSharp.Core.OptionModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Core.FSharpOption`1[T], TState)
-Microsoft.FSharp.Core.OptionModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Core.FSharpOption`1[T])
-Microsoft.FSharp.Core.OptionModule: T[] ToArray[T](Microsoft.FSharp.Core.FSharpOption`1[T])
-Microsoft.FSharp.Core.OptionModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[T])
-Microsoft.FSharp.Core.OptionalArgumentAttribute: Void .ctor()
-Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Object[] Captures
-Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Object[] get_Captures()
-Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.String ToString()
-Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.String Value
-Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.String get_Value()
-Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Type[] CaptureTypes
-Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Type[] get_CaptureTypes()
-Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: Void .ctor(System.String)
-Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: Void .ctor(System.String, System.Object[], System.Type[])
-Microsoft.FSharp.Core.PrintfFormat`5[TPrinter,TState,TResidue,TResult,TTuple]: Void .ctor(System.String)
-Microsoft.FSharp.Core.PrintfFormat`5[TPrinter,TState,TResidue,TResult,TTuple]: Void .ctor(System.String, System.Object[], System.Type[])
-Microsoft.FSharp.Core.PrintfModule: T PrintFormatLineToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Core.PrintfModule: T PrintFormatLineToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Core.PrintfModule: T PrintFormatLine[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Core.PrintfModule: T PrintFormatThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[System.String,TResult], Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult])
-Microsoft.FSharp.Core.PrintfModule: T PrintFormatToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringBuilderThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], System.Text.StringBuilder, Microsoft.FSharp.Core.PrintfFormat`4[T,System.Text.StringBuilder,Microsoft.FSharp.Core.Unit,TResult])
-Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringBuilder[T](System.Text.StringBuilder, Microsoft.FSharp.Core.PrintfFormat`4[T,System.Text.StringBuilder,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringThenFail[T,TResult](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult])
-Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[System.String,TResult], Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult])
-Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringThen[T](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,System.String])
-Microsoft.FSharp.Core.PrintfModule: T PrintFormatToTextWriterThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,TResult])
-Microsoft.FSharp.Core.PrintfModule: T PrintFormatToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Core.PrintfModule: T PrintFormat[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
-Microsoft.FSharp.Core.ProjectionParameterAttribute: Void .ctor()
-Microsoft.FSharp.Core.ReferenceEqualityAttribute: Void .ctor()
-Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Boolean IncludeValue
-Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Boolean get_IncludeValue()
-Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Void .ctor()
-Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Void .ctor(Boolean)
-Microsoft.FSharp.Core.RequireQualifiedAccessAttribute: Void .ctor()
-Microsoft.FSharp.Core.RequiresExplicitTypeArgumentsAttribute: Void .ctor()
-Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpResult`2[T,TResult] MapError[TError,TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[TError,TResult], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
-Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpResult`2[TResult,TError] Bind[T,TResult,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpResult`2[TResult,TError]], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
-Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpResult`2[TResult,TError] Map[T,TResult,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
-Microsoft.FSharp.Core.ResultModule: Boolean Contains[T,TError](T, Microsoft.FSharp.Core.FSharpResult`2[T,TError])
-Microsoft.FSharp.Core.ResultModule: Boolean Exists[T,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
-Microsoft.FSharp.Core.ResultModule: Boolean ForAll[T,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
-Microsoft.FSharp.Core.ResultModule: Boolean IsError[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
-Microsoft.FSharp.Core.ResultModule: Boolean IsOk[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
-Microsoft.FSharp.Core.ResultModule: Int32 Count[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
-Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
-Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpOption`1[T] ToOption[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
-Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpValueOption`1[T] ToValueOption[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
-Microsoft.FSharp.Core.ResultModule: T DefaultValue[T,TError](T, Microsoft.FSharp.Core.FSharpResult`2[T,TError])
-Microsoft.FSharp.Core.ResultModule: T DefaultWith[TError,T](Microsoft.FSharp.Core.FSharpFunc`2[TError,T], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
-Microsoft.FSharp.Core.ResultModule: TState FoldBack[T,TError,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Core.FSharpResult`2[T,TError], TState)
-Microsoft.FSharp.Core.ResultModule: TState Fold[T,TError,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Core.FSharpResult`2[T,TError])
-Microsoft.FSharp.Core.ResultModule: T[] ToArray[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError])
-Microsoft.FSharp.Core.ResultModule: Void Iterate[T,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpResult`2[T,TError])
-Microsoft.FSharp.Core.SealedAttribute: Boolean Value
-Microsoft.FSharp.Core.SealedAttribute: Boolean get_Value()
-Microsoft.FSharp.Core.SealedAttribute: Void .ctor()
-Microsoft.FSharp.Core.SealedAttribute: Void .ctor(Boolean)
-Microsoft.FSharp.Core.SourceConstructFlags: Int32 value__
-Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Closure
-Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Exception
-Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Field
-Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags KindMask
-Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Module
-Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags NonPublicRepresentation
-Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags None
-Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags ObjectType
-Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags RecordType
-Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags SumType
-Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags UnionCase
-Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Value
-Microsoft.FSharp.Core.StringModule: Boolean Exists(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Boolean], System.String)
-Microsoft.FSharp.Core.StringModule: Boolean ForAll(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Boolean], System.String)
-Microsoft.FSharp.Core.StringModule: Int32 Length(System.String)
-Microsoft.FSharp.Core.StringModule: System.String Collect(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.String], System.String)
-Microsoft.FSharp.Core.StringModule: System.String Concat(System.String, System.Collections.Generic.IEnumerable`1[System.String])
-Microsoft.FSharp.Core.StringModule: System.String Filter(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Boolean], System.String)
-Microsoft.FSharp.Core.StringModule: System.String Initialize(Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.String])
-Microsoft.FSharp.Core.StringModule: System.String Map(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Char], System.String)
-Microsoft.FSharp.Core.StringModule: System.String MapIndexed(Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Char]], System.String)
-Microsoft.FSharp.Core.StringModule: System.String Replicate(Int32, System.String)
-Microsoft.FSharp.Core.StringModule: Void Iterate(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,Microsoft.FSharp.Core.Unit], System.String)
-Microsoft.FSharp.Core.StringModule: Void IterateIndexed(Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Char,Microsoft.FSharp.Core.Unit]], System.String)
-Microsoft.FSharp.Core.StructAttribute: Void .ctor()
-Microsoft.FSharp.Core.StructuralComparisonAttribute: Void .ctor()
-Microsoft.FSharp.Core.StructuralEqualityAttribute: Void .ctor()
-Microsoft.FSharp.Core.StructuredFormatDisplayAttribute: System.String Value
-Microsoft.FSharp.Core.StructuredFormatDisplayAttribute: System.String get_Value()
-Microsoft.FSharp.Core.StructuredFormatDisplayAttribute: Void .ctor(System.String)
-Microsoft.FSharp.Core.Unit: Boolean Equals(System.Object)
-Microsoft.FSharp.Core.Unit: Int32 GetHashCode()
-Microsoft.FSharp.Core.UnverifiableAttribute: Void .ctor()
-Microsoft.FSharp.Core.ValueOption: Boolean Contains[T](T, Microsoft.FSharp.Core.FSharpValueOption`1[T])
-Microsoft.FSharp.Core.ValueOption: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpValueOption`1[T])
-Microsoft.FSharp.Core.ValueOption: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpValueOption`1[T])
-Microsoft.FSharp.Core.ValueOption: Boolean IsNone[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
-Microsoft.FSharp.Core.ValueOption: Boolean IsSome[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
-Microsoft.FSharp.Core.ValueOption: Int32 Count[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
-Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
-Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpValueOption`1[TResult]], Microsoft.FSharp.Core.FSharpValueOption`1[T])
-Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], Microsoft.FSharp.Core.FSharpValueOption`1[T1], Microsoft.FSharp.Core.FSharpValueOption`1[T2])
-Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], Microsoft.FSharp.Core.FSharpValueOption`1[T1], Microsoft.FSharp.Core.FSharpValueOption`1[T2], Microsoft.FSharp.Core.FSharpValueOption`1[T3])
-Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Core.FSharpValueOption`1[T])
-Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpValueOption`1[T])
-Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] Flatten[T](Microsoft.FSharp.Core.FSharpValueOption`1[Microsoft.FSharp.Core.FSharpValueOption`1[T]])
-Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OfNullable[T](System.Nullable`1[T])
-Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OfObj[T](T)
-Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OrElseWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.FSharpValueOption`1[T]], Microsoft.FSharp.Core.FSharpValueOption`1[T])
-Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OrElse[T](Microsoft.FSharp.Core.FSharpValueOption`1[T], Microsoft.FSharp.Core.FSharpValueOption`1[T])
-Microsoft.FSharp.Core.ValueOption: System.Nullable`1[T] ToNullable[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
-Microsoft.FSharp.Core.ValueOption: T DefaultValue[T](T, Microsoft.FSharp.Core.FSharpValueOption`1[T])
-Microsoft.FSharp.Core.ValueOption: T DefaultWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpValueOption`1[T])
-Microsoft.FSharp.Core.ValueOption: T GetValue[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
-Microsoft.FSharp.Core.ValueOption: T ToObj[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
-Microsoft.FSharp.Core.ValueOption: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Core.FSharpValueOption`1[T], TState)
-Microsoft.FSharp.Core.ValueOption: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Core.FSharpValueOption`1[T])
-Microsoft.FSharp.Core.ValueOption: T[] ToArray[T](Microsoft.FSharp.Core.FSharpValueOption`1[T])
-Microsoft.FSharp.Core.ValueOption: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpValueOption`1[T])
-Microsoft.FSharp.Core.VolatileFieldAttribute: Void .ctor()
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToByte[T](System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToUInt8$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToUInt8[T](System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Char] ToChar$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Char], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Char] ToChar[T](System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Decimal] ToDecimal$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Decimal], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Decimal] ToDecimal[T](System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToDouble$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToDouble[T](System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToFloat$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToFloat[T](System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int16] ToInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int16], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int16] ToInt16[T](System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt32[T](System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt[T](System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int64] ToInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int64], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int64] ToInt64[T](System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.IntPtr] ToIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.IntPtr], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.IntPtr] ToIntPtr[T](System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToInt8$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToInt8[T](System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToSByte[T](System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToFloat32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToFloat32[T](System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToSingle$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToSingle[T](System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt16] ToUInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt16], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt16] ToUInt16[T](System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt32[T](System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt[T](System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt64] ToUInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt64], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt64] ToUInt64[T](System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UIntPtr] ToUIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UIntPtr], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UIntPtr] ToUIntPtr[T](System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[TResult] ToEnum[TResult](System.Nullable`1[System.Int32])
-Microsoft.FSharp.Linq.NullableOperators: Boolean op_EqualsQmark[T](T, System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableOperators: Boolean op_GreaterEqualsQmark[T](T, System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableOperators: Boolean op_GreaterQmark[T](T, System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableOperators: Boolean op_LessEqualsQmark[T](T, System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableOperators: Boolean op_LessGreaterQmark[T](T, System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableOperators: Boolean op_LessQmark[T](T, System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkEqualsQmark[T](System.Nullable`1[T], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkEquals[T](System.Nullable`1[T], T)
-Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreaterEqualsQmark[T](System.Nullable`1[T], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreaterEquals[T](System.Nullable`1[T], T)
-Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreaterQmark[T](System.Nullable`1[T], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreater[T](System.Nullable`1[T], T)
-Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessEqualsQmark[T](System.Nullable`1[T], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessEquals[T](System.Nullable`1[T], T)
-Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessGreaterQmark[T](System.Nullable`1[T], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessGreater[T](System.Nullable`1[T], T)
-Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessQmark[T](System.Nullable`1[T], System.Nullable`1[T])
-Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLess[T](System.Nullable`1[T], T)
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_DivideQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2])
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_DivideQmark[T1,T2,T3](T1, System.Nullable`1[T2])
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MinusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2])
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MinusQmark[T1,T2,T3](T1, System.Nullable`1[T2])
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MultiplyQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2])
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MultiplyQmark[T1,T2,T3](T1, System.Nullable`1[T2])
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PercentQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2])
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PercentQmark[T1,T2,T3](T1, System.Nullable`1[T2])
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PlusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2])
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PlusQmark[T1,T2,T3](T1, System.Nullable`1[T2])
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivide$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2)
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivideQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2])
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivideQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2])
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivide[T1,T2,T3](System.Nullable`1[T1], T2)
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinus$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2)
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2])
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinusQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2])
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinus[T1,T2,T3](System.Nullable`1[T1], T2)
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiply$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2)
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiplyQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2])
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiplyQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2])
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiply[T1,T2,T3](System.Nullable`1[T1], T2)
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercent$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2)
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercentQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2])
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercentQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2])
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercent[T1,T2,T3](System.Nullable`1[T1], T2)
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlus$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2)
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2])
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlusQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2])
-Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlus[T1,T2,T3](System.Nullable`1[T1], T2)
-Microsoft.FSharp.Linq.QueryBuilder: Boolean All[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
-Microsoft.FSharp.Linq.QueryBuilder: Boolean Contains[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], T)
-Microsoft.FSharp.Linq.QueryBuilder: Boolean Exists[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
-Microsoft.FSharp.Linq.QueryBuilder: Int32 Count[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[System.Linq.IGrouping`2[TKey,TValue],Q] GroupValBy[T,TKey,TValue,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[System.Linq.IGrouping`2[TKey,T],Q] GroupBy[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Distinct[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SkipWhile[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Skip[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Int32)
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortByDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortByNullableDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]])
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortByNullable[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]])
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortBy[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Source[T,Q](System.Linq.IQueryable`1[T])
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] TakeWhile[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Take[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Int32)
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenByDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenByNullableDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]])
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenByNullable[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]])
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenBy[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey])
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Where[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] YieldFrom[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Yield[T,Q](T)
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Zero[T,Q]()
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,System.Collections.IEnumerable] Source[T](System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] For[T,Q,TResult,Q2](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Linq.QuerySource`2[TResult,Q2]])
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] GroupJoin[TOuter,Q,TInner,TKey,TResult](Microsoft.FSharp.Linq.QuerySource`2[TOuter,Q], Microsoft.FSharp.Linq.QuerySource`2[TInner,Q], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TInner,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,Microsoft.FSharp.Core.FSharpFunc`2[System.Collections.Generic.IEnumerable`1[TInner],TResult]])
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] Join[TOuter,Q,TInner,TKey,TResult](Microsoft.FSharp.Linq.QuerySource`2[TOuter,Q], Microsoft.FSharp.Linq.QuerySource`2[TInner,Q], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TInner,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,Microsoft.FSharp.Core.FSharpFunc`2[TInner,TResult]])
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] LeftOuterJoin[TOuter,Q,TInner,TKey,TResult](Microsoft.FSharp.Linq.QuerySource`2[TOuter,Q], Microsoft.FSharp.Linq.QuerySource`2[TInner,Q], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TInner,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,Microsoft.FSharp.Core.FSharpFunc`2[System.Collections.Generic.IEnumerable`1[TInner],TResult]])
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] Select[T,Q,TResult](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])
-Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Quotations.FSharpExpr`1[T] Quote[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T])
-Microsoft.FSharp.Linq.QueryBuilder: System.Linq.IQueryable`1[T] Run[T](Microsoft.FSharp.Quotations.FSharpExpr`1[Microsoft.FSharp.Linq.QuerySource`2[T,System.Linq.IQueryable]])
-Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] AverageByNullable$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TValue]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
-Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] AverageByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
-Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] MaxByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
-Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] MinByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
-Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] SumByNullable$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
-Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] SumByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]])
-Microsoft.FSharp.Linq.QueryBuilder: T ExactlyOneOrDefault[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
-Microsoft.FSharp.Linq.QueryBuilder: T ExactlyOne[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
-Microsoft.FSharp.Linq.QueryBuilder: T Find[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean])
-Microsoft.FSharp.Linq.QueryBuilder: T HeadOrDefault[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
-Microsoft.FSharp.Linq.QueryBuilder: T Head[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
-Microsoft.FSharp.Linq.QueryBuilder: T LastOrDefault[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
-Microsoft.FSharp.Linq.QueryBuilder: T Last[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q])
-Microsoft.FSharp.Linq.QueryBuilder: T Nth[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Int32)
-Microsoft.FSharp.Linq.QueryBuilder: TValue AverageBy$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TValue]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
-Microsoft.FSharp.Linq.QueryBuilder: TValue AverageBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
-Microsoft.FSharp.Linq.QueryBuilder: TValue MaxBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
-Microsoft.FSharp.Linq.QueryBuilder: TValue MinBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
-Microsoft.FSharp.Linq.QueryBuilder: TValue SumBy$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
-Microsoft.FSharp.Linq.QueryBuilder: TValue SumBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue])
-Microsoft.FSharp.Linq.QueryBuilder: Void .ctor()
-Microsoft.FSharp.Linq.QueryRunExtensions.HighPriority: System.Collections.Generic.IEnumerable`1[T] RunQueryAsEnumerable[T](Microsoft.FSharp.Linq.QueryBuilder, Microsoft.FSharp.Quotations.FSharpExpr`1[Microsoft.FSharp.Linq.QuerySource`2[T,System.Collections.IEnumerable]])
-Microsoft.FSharp.Linq.QueryRunExtensions.LowPriority: T RunQueryAsValue[T](Microsoft.FSharp.Linq.QueryBuilder, Microsoft.FSharp.Quotations.FSharpExpr`1[T])
-Microsoft.FSharp.Linq.QuerySource`2[T,Q]: System.Collections.Generic.IEnumerable`1[T] Source
-Microsoft.FSharp.Linq.QuerySource`2[T,Q]: System.Collections.Generic.IEnumerable`1[T] get_Source()
-Microsoft.FSharp.Linq.QuerySource`2[T,Q]: Void .ctor(System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`1[T1]: T1 Item1
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`1[T1]: T1 get_Item1()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`1[T1]: Void .ctor(T1)
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T1 Item1
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T1 get_Item1()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T2 Item2
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T2 get_Item2()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: Void .ctor(T1, T2)
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T1 Item1
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T1 get_Item1()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T2 Item2
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T2 get_Item2()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T3 Item3
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T3 get_Item3()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: Void .ctor(T1, T2, T3)
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T1 Item1
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T1 get_Item1()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T2 Item2
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T2 get_Item2()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T3 Item3
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T3 get_Item3()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T4 Item4
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T4 get_Item4()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: Void .ctor(T1, T2, T3, T4)
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T1 Item1
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T1 get_Item1()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T2 Item2
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T2 get_Item2()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T3 Item3
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T3 get_Item3()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T4 Item4
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T4 get_Item4()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T5 Item5
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T5 get_Item5()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: Void .ctor(T1, T2, T3, T4, T5)
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T1 Item1
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T1 get_Item1()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T2 Item2
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T2 get_Item2()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T3 Item3
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T3 get_Item3()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T4 Item4
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T4 get_Item4()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T5 Item5
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T5 get_Item5()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T6 Item6
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T6 get_Item6()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: Void .ctor(T1, T2, T3, T4, T5, T6)
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T1 Item1
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T1 get_Item1()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T2 Item2
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T2 get_Item2()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T3 Item3
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T3 get_Item3()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T4 Item4
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T4 get_Item4()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T5 Item5
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T5 get_Item5()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T6 Item6
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T6 get_Item6()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T7 Item7
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T7 get_Item7()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: Void .ctor(T1, T2, T3, T4, T5, T6, T7)
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T1 Item1
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T1 get_Item1()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T2 Item2
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T2 get_Item2()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T3 Item3
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T3 get_Item3()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T4 Item4
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T4 get_Item4()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T5 Item5
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T5 get_Item5()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T6 Item6
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T6 get_Item6()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T7 Item7
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T7 get_Item7()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T8 Item8
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T8 get_Item8()
-Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: Void .ctor(T1, T2, T3, T4, T5, T6, T7, T8)
-Microsoft.FSharp.Linq.RuntimeHelpers.Grouping`2[K,T]: Void .ctor(K, System.Collections.Generic.IEnumerable`1[T])
-Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: Microsoft.FSharp.Quotations.FSharpExpr SubstHelperRaw(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar[], System.Object[])
-Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: Microsoft.FSharp.Quotations.FSharpExpr`1[T] SubstHelper[T](Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar[], System.Object[])
-Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Linq.Expressions.Expression QuotationToExpression(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Linq.Expressions.Expression`1[T] ImplicitExpressionConversionHelper[T](T)
-Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Linq.Expressions.Expression`1[T] QuotationToLambdaExpression[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T])
-Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Object EvaluateQuotation(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: T MemberInitializationHelper[T](T)
-Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: T NewAnonymousObjectHelper[T](T)
-Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr AddPointerInlined[T](IntPtr, Int32)
-Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr OfNativeIntInlined[T](IntPtr)
-Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr OfVoidPtrInlined[T](Void*)
-Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr StackAllocate[T](Int32)
-Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr ToNativeIntInlined[T](IntPtr)
-Microsoft.FSharp.NativeInterop.NativePtrModule: T GetPointerInlined[T](IntPtr, Int32)
-Microsoft.FSharp.NativeInterop.NativePtrModule: T ReadPointerInlined[T](IntPtr)
-Microsoft.FSharp.NativeInterop.NativePtrModule: T& ToByRefInlined[T](IntPtr)
-Microsoft.FSharp.NativeInterop.NativePtrModule: Void SetPointerInlined[T](IntPtr, Int32, T)
-Microsoft.FSharp.NativeInterop.NativePtrModule: Void WritePointerInlined[T](IntPtr, T)
-Microsoft.FSharp.NativeInterop.NativePtrModule: Void* ToVoidPtrInlined[T](IntPtr)
-Microsoft.FSharp.NativeInterop.NativePtrModule: Boolean IsNullPointer[T](IntPtr)
-Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr NullPointer[T]()
-Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr OfILSigPtrInlined[T](T*)
-Microsoft.FSharp.NativeInterop.NativePtrModule: T* ToILSigPtrInlined[T](IntPtr)
-Microsoft.FSharp.NativeInterop.NativePtrModule: Void ClearPointerInlined[T](IntPtr)
-Microsoft.FSharp.NativeInterop.NativePtrModule: Void CopyBlockInlined[T](IntPtr, IntPtr, Int32)
-Microsoft.FSharp.NativeInterop.NativePtrModule: Void CopyPointerInlined[T](IntPtr, IntPtr)
-Microsoft.FSharp.NativeInterop.NativePtrModule: Void InitializeBlockInlined[T](IntPtr, Byte, UInt32)
-Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],Microsoft.FSharp.Collections.FSharpList`1[System.Type],Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]]] SpecificCallPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] UnitPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] MethodWithReflectedDefinitionPattern(System.Reflection.MethodBase)
-Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] PropertyGetterWithReflectedDefinitionPattern(System.Reflection.PropertyInfo)
-Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] PropertySetterWithReflectedDefinitionPattern(System.Reflection.PropertyInfo)
-Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Boolean] BoolPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Byte] BytePattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Char] CharPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Decimal] DecimalPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Double] DoublePattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int16] Int16Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] Int32Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int64] Int64Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.SByte] SBytePattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Single] SinglePattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.String] StringPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpVar]],Microsoft.FSharp.Quotations.FSharpExpr]] LambdasPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]]] ApplicationsPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] AndAlsoPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] OrElsePattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.UInt16] UInt16Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.UInt32] UInt32Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.UInt64] UInt64Pattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.ExprShapeModule: Microsoft.FSharp.Core.FSharpChoice`3[Microsoft.FSharp.Quotations.FSharpVar,System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr],System.Tuple`2[System.Object,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] ShapePattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.ExprShapeModule: Microsoft.FSharp.Quotations.FSharpExpr RebuildShapeCombination(System.Object, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
-Microsoft.FSharp.Quotations.FSharpExpr: Boolean Equals(System.Object)
-Microsoft.FSharp.Quotations.FSharpExpr: Int32 GetHashCode()
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr] CustomAttributes
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr] get_CustomAttributes()
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] TryGetReflectedDefinition(System.Reflection.MethodBase)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr AddressOf(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr AddressSet(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Application(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Applications(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]])
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Call(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Call(System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr CallWithWitnesses(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.MethodInfo, System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr], Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr CallWithWitnesses(System.Reflection.MethodInfo, System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr], Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Coerce(Microsoft.FSharp.Quotations.FSharpExpr, System.Type)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr DefaultValue(System.Type)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Deserialize(System.Type, Microsoft.FSharp.Collections.FSharpList`1[System.Type], Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr], Byte[])
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Deserialize40(System.Type, System.Type[], System.Type[], Microsoft.FSharp.Quotations.FSharpExpr[], Byte[])
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldGet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.FieldInfo)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldGet(System.Reflection.FieldInfo)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldSet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.FieldInfo, Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldSet(System.Reflection.FieldInfo, Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr ForIntegerRangeLoop(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr IfThenElse(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Lambda(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Let(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr LetRecursive(Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]], Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewArray(System.Type, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewDelegate(System.Type, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpVar], Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewObject(System.Reflection.ConstructorInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewRecord(System.Type, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewStructTuple(System.Reflection.Assembly, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewTuple(Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewUnionCase(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr])
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertyGet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.PropertyInfo, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]])
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertyGet(System.Reflection.PropertyInfo, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]])
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertySet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.PropertyInfo, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]])
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertySet(System.Reflection.PropertyInfo, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]])
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Quote(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr QuoteRaw(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr QuoteTyped(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Sequential(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Substitute(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr]])
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TryFinally(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TryWith(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TupleGet(Microsoft.FSharp.Quotations.FSharpExpr, Int32)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TypeTest(Microsoft.FSharp.Quotations.FSharpExpr, System.Type)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr UnionCaseTest(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Reflection.UnionCaseInfo)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Value(System.Object, System.Type)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr ValueWithName(System.Object, System.Type, System.String)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr ValueWithName[T](T, System.String)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Value[T](T)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Var(Microsoft.FSharp.Quotations.FSharpVar)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr VarSet(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr WhileLoop(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr WithValue(System.Object, System.Type, Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr`1[T] Cast[T](Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr`1[T] GlobalVar[T](System.String)
-Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr`1[T] WithValue[T](T, Microsoft.FSharp.Quotations.FSharpExpr`1[T])
-Microsoft.FSharp.Quotations.FSharpExpr: System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Quotations.FSharpVar] GetFreeVars()
-Microsoft.FSharp.Quotations.FSharpExpr: System.String ToString()
-Microsoft.FSharp.Quotations.FSharpExpr: System.String ToString(Boolean)
-Microsoft.FSharp.Quotations.FSharpExpr: System.Type Type
-Microsoft.FSharp.Quotations.FSharpExpr: System.Type get_Type()
-Microsoft.FSharp.Quotations.FSharpExpr: Void RegisterReflectedDefinitions(System.Reflection.Assembly, System.String, Byte[])
-Microsoft.FSharp.Quotations.FSharpExpr: Void RegisterReflectedDefinitions(System.Reflection.Assembly, System.String, Byte[], System.Type[])
-Microsoft.FSharp.Quotations.FSharpExpr`1[T]: Microsoft.FSharp.Quotations.FSharpExpr Raw
-Microsoft.FSharp.Quotations.FSharpExpr`1[T]: Microsoft.FSharp.Quotations.FSharpExpr get_Raw()
-Microsoft.FSharp.Quotations.FSharpVar: Boolean Equals(System.Object)
-Microsoft.FSharp.Quotations.FSharpVar: Boolean IsMutable
-Microsoft.FSharp.Quotations.FSharpVar: Boolean get_IsMutable()
-Microsoft.FSharp.Quotations.FSharpVar: Int32 GetHashCode()
-Microsoft.FSharp.Quotations.FSharpVar: Microsoft.FSharp.Quotations.FSharpVar Global(System.String, System.Type)
-Microsoft.FSharp.Quotations.FSharpVar: System.String Name
-Microsoft.FSharp.Quotations.FSharpVar: System.String ToString()
-Microsoft.FSharp.Quotations.FSharpVar: System.String get_Name()
-Microsoft.FSharp.Quotations.FSharpVar: System.Type Type
-Microsoft.FSharp.Quotations.FSharpVar: System.Type get_Type()
-Microsoft.FSharp.Quotations.FSharpVar: Void .ctor(System.String, System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]] NewStructTuplePattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]] NewTuplePattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] AddressOfPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] QuotePattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] QuoteRawPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] QuoteTypedPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpVar] VarPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]],Microsoft.FSharp.Quotations.FSharpExpr]] LetRecursivePattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.FieldInfo]] FieldGetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] AddressSetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] ApplicationPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] SequentialPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] TryFinallyPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] WhileLoopPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Reflection.UnionCaseInfo]] UnionCaseTestPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,System.Int32]] TupleGetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,System.Type]] CoercePattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,System.Type]] TypeTestPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]] LambdaPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]] VarSetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Reflection.UnionCaseInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewUnionCasePattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Object,System.Type]] ValuePattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Reflection.ConstructorInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewObjectPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Type,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewArrayPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Type,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewRecordPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.FieldInfo,Microsoft.FSharp.Quotations.FSharpExpr]] FieldSetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.MethodInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] CallPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.PropertyInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] PropertyGetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] IfThenElsePattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] LetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Object,System.Type,Microsoft.FSharp.Quotations.FSharpExpr]] WithValuePattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Object,System.Type,System.String]] ValueWithNamePattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Type,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpVar],Microsoft.FSharp.Quotations.FSharpExpr]] NewDelegatePattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`4[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.PropertyInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr],Microsoft.FSharp.Quotations.FSharpExpr]] PropertySetPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`4[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] ForIntegerRangeLoopPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`5[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.MethodInfo,System.Reflection.MethodInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr],Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] CallWithWitnessesPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`5[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]] TryWithPattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Type] DefaultValuePattern(Microsoft.FSharp.Quotations.FSharpExpr)
-Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Boolean FSharpType.IsExceptionRepresentation.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
-Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Boolean FSharpType.IsRecord.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
-Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Boolean FSharpType.IsUnion.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
-Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Int32] FSharpValue.PreComputeUnionTagReader.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
-Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] FSharpValue.PreComputeRecordReader.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
-Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] FSharpValue.PreComputeUnionReader.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
-Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] FSharpValue.PreComputeRecordConstructor.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
-Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] FSharpValue.PreComputeUnionConstructor.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
-Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Reflection.UnionCaseInfo[] FSharpType.GetUnionCases.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
-Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object FSharpValue.MakeRecord.Static(System.Type, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
-Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object FSharpValue.MakeUnion.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
-Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object[] FSharpValue.GetExceptionFields.Static(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
-Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object[] FSharpValue.GetRecordFields.Static(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
-Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.ConstructorInfo FSharpValue.PreComputeRecordConstructorInfo.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
-Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.MemberInfo FSharpValue.PreComputeUnionTagMemberInfo.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
-Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.MethodInfo FSharpValue.PreComputeUnionConstructorInfo.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
-Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.PropertyInfo[] FSharpType.GetExceptionFields.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
-Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.PropertyInfo[] FSharpType.GetRecordFields.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
-Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Tuple`2[Microsoft.FSharp.Reflection.UnionCaseInfo,System.Object[]] FSharpValue.GetUnionFields.Static(System.Object, System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean])
-Microsoft.FSharp.Reflection.FSharpType: Boolean IsExceptionRepresentation(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
-Microsoft.FSharp.Reflection.FSharpType: Boolean IsFunction(System.Type)
-Microsoft.FSharp.Reflection.FSharpType: Boolean IsModule(System.Type)
-Microsoft.FSharp.Reflection.FSharpType: Boolean IsRecord(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
-Microsoft.FSharp.Reflection.FSharpType: Boolean IsTuple(System.Type)
-Microsoft.FSharp.Reflection.FSharpType: Boolean IsUnion(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
-Microsoft.FSharp.Reflection.FSharpType: Microsoft.FSharp.Reflection.UnionCaseInfo[] GetUnionCases(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
-Microsoft.FSharp.Reflection.FSharpType: System.Reflection.PropertyInfo[] GetExceptionFields(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
-Microsoft.FSharp.Reflection.FSharpType: System.Reflection.PropertyInfo[] GetRecordFields(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
-Microsoft.FSharp.Reflection.FSharpType: System.Tuple`2[System.Type,System.Type] GetFunctionElements(System.Type)
-Microsoft.FSharp.Reflection.FSharpType: System.Type MakeFunctionType(System.Type, System.Type)
-Microsoft.FSharp.Reflection.FSharpType: System.Type MakeStructTupleType(System.Reflection.Assembly, System.Type[])
-Microsoft.FSharp.Reflection.FSharpType: System.Type MakeTupleType(System.Reflection.Assembly, System.Type[])
-Microsoft.FSharp.Reflection.FSharpType: System.Type MakeTupleType(System.Type[])
-Microsoft.FSharp.Reflection.FSharpType: System.Type[] GetTupleElements(System.Type)
-Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Int32] PreComputeUnionTagReader(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
-Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] PreComputeRecordReader(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
-Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] PreComputeTupleReader(System.Type)
-Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] PreComputeUnionReader(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
-Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object] PreComputeRecordFieldReader(System.Reflection.PropertyInfo)
-Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] PreComputeRecordConstructor(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
-Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] PreComputeTupleConstructor(System.Type)
-Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] PreComputeUnionConstructor(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
-Microsoft.FSharp.Reflection.FSharpValue: System.Object GetRecordField(System.Object, System.Reflection.PropertyInfo)
-Microsoft.FSharp.Reflection.FSharpValue: System.Object GetTupleField(System.Object, Int32)
-Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeFunction(System.Type, Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object])
-Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeRecord(System.Type, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
-Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeTuple(System.Object[], System.Type)
-Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeUnion(Microsoft.FSharp.Reflection.UnionCaseInfo, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
-Microsoft.FSharp.Reflection.FSharpValue: System.Object[] GetExceptionFields(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
-Microsoft.FSharp.Reflection.FSharpValue: System.Object[] GetRecordFields(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
-Microsoft.FSharp.Reflection.FSharpValue: System.Object[] GetTupleFields(System.Object)
-Microsoft.FSharp.Reflection.FSharpValue: System.Reflection.ConstructorInfo PreComputeRecordConstructorInfo(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
-Microsoft.FSharp.Reflection.FSharpValue: System.Reflection.MemberInfo PreComputeUnionTagMemberInfo(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
-Microsoft.FSharp.Reflection.FSharpValue: System.Reflection.MethodInfo PreComputeUnionConstructorInfo(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
-Microsoft.FSharp.Reflection.FSharpValue: System.Tuple`2[Microsoft.FSharp.Reflection.UnionCaseInfo,System.Object[]] GetUnionFields(System.Object, System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags])
-Microsoft.FSharp.Reflection.FSharpValue: System.Tuple`2[System.Reflection.ConstructorInfo,Microsoft.FSharp.Core.FSharpOption`1[System.Type]] PreComputeTupleConstructorInfo(System.Type)
-Microsoft.FSharp.Reflection.FSharpValue: System.Tuple`2[System.Reflection.PropertyInfo,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Type,System.Int32]]] PreComputeTuplePropertyInfo(System.Type, Int32)
-Microsoft.FSharp.Reflection.UnionCaseInfo: Boolean Equals(System.Object)
-Microsoft.FSharp.Reflection.UnionCaseInfo: Int32 GetHashCode()
-Microsoft.FSharp.Reflection.UnionCaseInfo: Int32 Tag
-Microsoft.FSharp.Reflection.UnionCaseInfo: Int32 get_Tag()
-Microsoft.FSharp.Reflection.UnionCaseInfo: System.Collections.Generic.IList`1[System.Reflection.CustomAttributeData] GetCustomAttributesData()
-Microsoft.FSharp.Reflection.UnionCaseInfo: System.Object[] GetCustomAttributes()
-Microsoft.FSharp.Reflection.UnionCaseInfo: System.Object[] GetCustomAttributes(System.Type)
-Microsoft.FSharp.Reflection.UnionCaseInfo: System.Reflection.PropertyInfo[] GetFields()
-Microsoft.FSharp.Reflection.UnionCaseInfo: System.String Name
-Microsoft.FSharp.Reflection.UnionCaseInfo: System.String ToString()
-Microsoft.FSharp.Reflection.UnionCaseInfo: System.String get_Name()
-Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type DeclaringType
-Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type get_DeclaringType()
-Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Void __debugPoint(System.String)
-"
+    member this.VerifySurfaceAreaFSharpCore () : unit =
+        let platform =
+
+// We are testing the surface area of the FSharp.Core assembly.
+// NETCOREAPP builds with netstandard2.1
+// Net472 builds with netstandard1.0
+//
 #if NETCOREAPP
-// This is in netstandard 2.1
-        let expected =
-            expected +
-            """Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] Using[TResource,TOverall,T](TResource, Microsoft.FSharp.Core.FSharpFunc`2[TResource,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]])
-"""
+            "netstandard21"
+#else
+            "netstandard20"
 #endif
+        let flavor =
 #if DEBUG
-        let expected =
-            expected +
-            @"Microsoft.FSharp.Core.Operators: System.RuntimeMethodHandle MethodHandleOf[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult])"
+            "debug"
+#else
+            "release"
 #endif
-        SurfaceArea.verify expected "coreclr" (System.IO.Path.Combine(__SOURCE_DIRECTORY__,__SOURCE_FILE__))
+        let assembly = typeof<int list>.Assembly
+        let baseline = Path.Combine(__SOURCE_DIRECTORY__, $"FSharp.Core.SurfaceArea.{platform}.{flavor}.bsl")
+        let outFileName = $"FSharp.Core.SurfaceArea.{platform}.{flavor}.out"
+        FSharp.Test.SurfaceArea.verify assembly baseline outFileName
diff --git a/tests/FSharp.Core.UnitTests/TypeForwarding.fs b/tests/FSharp.Core.UnitTests/TypeForwarding.fs
deleted file mode 100644
index 524d62e65ee..00000000000
--- a/tests/FSharp.Core.UnitTests/TypeForwarding.fs
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
-
-// Various tests for Microsoft.FSharp.Core type forwarding
-
-namespace FSharp.Core.UnitTests.Type_Forwarding
-
-open System
-open FSharp.Core.UnitTests.LibraryTestFx
-open Xunit
-
-#if NET46
-[<TestFixture>]
-type TypeForwardingModule() =
-    [<Fact>]
-    member this.TypeForwarding() =
-        let currentRuntimeVersion = System.Runtime.InteropServices.RuntimeEnvironment.GetSystemVersion()
-        let currentFSharpCoreTargetRuntime = typeof<int list>.Assembly.ImageRuntimeVersion
-        let tupleAssemblyName = typeof<System.Tuple<int,int>>.Assembly.FullName
-
-        let mscorlib4AssemblyName = "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"
-        let fsharpCore2AssemblyName = "FSharp.Core, Version=2.3.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"
-
-        printfn "currentRuntimeVersion = %s; currentFSharpCoreTargetRuntime=%s tupleAssemblyName=%s" currentRuntimeVersion currentFSharpCoreTargetRuntime tupleAssemblyName
-        match (currentRuntimeVersion, currentFSharpCoreTargetRuntime) with
-        | ("v2.0.50727", _)           
-        | ("v4.0.30319", "v2.0.50727") ->
-           Assert.AreEqual(tupleAssemblyName, fsharpCore2AssemblyName)
-        | ("v4.0.30319", "v4.0.30319") ->
-            Assert.AreEqual(tupleAssemblyName, mscorlib4AssemblyName)
-        | _ -> failwith "Unknown scenario."
-        ()
-#else
-// TODO named #define ?
-#endif
\ No newline at end of file
diff --git a/tests/FSharp.Test.Utilities/Compiler.fs b/tests/FSharp.Test.Utilities/Compiler.fs
index 97808b58591..8ea26ea602b 100644
--- a/tests/FSharp.Test.Utilities/Compiler.fs
+++ b/tests/FSharp.Test.Utilities/Compiler.fs
@@ -193,7 +193,7 @@ module rec Compiler =
     // Load the source file from the path
     let loadSourceFromFile path = getSource(TestType.Path path)
 
-    let private fsFromString (source: SourceCodeFileKind): FSharpCompilationSource =
+    let fsFromString (source: SourceCodeFileKind): FSharpCompilationSource =
         {
             Source            = source
             AdditionalSources = []
@@ -321,6 +321,7 @@ module rec Compiler =
 
     let asFs (cUnit: CompilationUnit) : CompilationUnit =
         match cUnit with
+        | FS { Source = SourceCodeFileKind.Fsi _} -> cUnit
         | FS src -> FS {src with Source=SourceCodeFileKind.Fs({FileName=src.Source.GetSourceFileName; SourceText=src.Source.GetSourceText})}
         | _ -> failwith "Only F# compilation can be of type Fs."
 
@@ -391,8 +392,14 @@ module rec Compiler =
     let withLangVersion70 (cUnit: CompilationUnit) : CompilationUnit =
         withOptionsHelper [ "--langversion:7.0" ] "withLangVersion70 is only supported on F#" cUnit
 
+    let withLangVersion80 (cUnit: CompilationUnit) : CompilationUnit =
+        withOptionsHelper [ "--langversion:8.0" ] "withLangVersion80 is only supported on F#" cUnit
+
     let withLangVersionPreview (cUnit: CompilationUnit) : CompilationUnit =
         withOptionsHelper [ "--langversion:preview" ] "withLangVersionPreview is only supported on F#" cUnit
+        
+    let withLangVersion (version: string) (cUnit: CompilationUnit) : CompilationUnit =
+        withOptionsHelper [ $"--langversion:{version}" ] "withLangVersion is only supported on F#" cUnit
 
     let withAssemblyVersion (version:string) (cUnit: CompilationUnit) : CompilationUnit =
         withOptionsHelper [ $"--version:{version}" ] "withAssemblyVersion is only supported on F#" cUnit
diff --git a/tests/FSharp.Test.Utilities/FSharp.Test.Utilities.fsproj b/tests/FSharp.Test.Utilities/FSharp.Test.Utilities.fsproj
index a219a73c7fa..0e656339974 100644
--- a/tests/FSharp.Test.Utilities/FSharp.Test.Utilities.fsproj
+++ b/tests/FSharp.Test.Utilities/FSharp.Test.Utilities.fsproj
@@ -28,6 +28,7 @@
     <Compile Include="Peverifier.fs" />
     <Compile Include="DirectoryAttribute.fs" />
     <Compile Include="ReflectionHelper.fs" />
+    <Compile Include="SurfaceArea.fs" />
   </ItemGroup>
 
   <ItemGroup>
@@ -59,6 +60,7 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="System.Reflection.Metadata" Version="$(SystemReflectionMetadataVersion)" />
+    <PackageReference Include="Microsoft.CodeAnalysis.Workspaces.Common" Version="$(MicrosoftCodeAnalysisVersion)" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="$(MicrosoftCodeAnalysisCSharpVersion)" />
     <PackageReference Include="Microsoft.CodeAnalysis.Test.Resources.Proprietary" Version="$(MicrosoftCodeAnalysisTestResourcesProprietaryVersion)" />
     <PackageReference Include="Microsoft.NETCore.App.Ref" Version="6.0.0" IncludeAssets="none" PrivateAssets="all" GeneratePathProperty="true" />
diff --git a/tests/FSharp.Test.Utilities/ProjectGeneration.fs b/tests/FSharp.Test.Utilities/ProjectGeneration.fs
index 19de5910387..c9b21c4e4fa 100644
--- a/tests/FSharp.Test.Utilities/ProjectGeneration.fs
+++ b/tests/FSharp.Test.Utilities/ProjectGeneration.fs
@@ -21,7 +21,9 @@ open FSharp.Compiler.CodeAnalysis
 open FSharp.Compiler.Diagnostics
 open FSharp.Compiler.Text
 open Xunit
+open System.Collections.Concurrent
 
+#nowarn "57" // Experimental feature use
 
 let private projectRoot = "test-projects"
 
@@ -71,6 +73,10 @@ let sourceFile fileId deps =
       ExtraSource = ""
       EntryPoint = false }
 
+
+let OptionsCache = ConcurrentDictionary()
+
+
 type SyntheticProject =
     { Name: string
       ProjectDir: string
@@ -114,33 +120,52 @@ type SyntheticProject =
     member this.OutputFilename = this.ProjectDir ++ $"{this.Name}.dll"
 
     member this.GetProjectOptions(checker: FSharpChecker) =
-        let baseOptions, _ =
-            checker.GetProjectOptionsFromScript("file.fs", SourceText.ofString "", assumeDotNetFramework = false)
-            |> Async.RunSynchronously
 
-        { baseOptions with
-            ProjectFileName = this.ProjectFileName
-            ProjectId = None
-            SourceFiles =
-                [| for f in this.SourceFiles do
-                       if f.HasSignatureFile then
-                           this.ProjectDir ++ f.SignatureFileName
-
-                       this.ProjectDir ++ f.FileName |]
-            OtherOptions =
-                [| yield! baseOptions.OtherOptions
-                   "--optimize+"
-                   for p in this.DependsOn do
-                       $"-r:{p.OutputFilename}" |]
-            ReferencedProjects =
-                [| for p in this.DependsOn do
-                       FSharpReferencedProject.CreateFSharp(p.OutputFilename, p.GetProjectOptions checker) |]
-            IsIncompleteTypeCheckEnvironment = false
-            UseScriptResolutionRules = false
-            LoadTime = DateTime()
-            UnresolvedReferences = None
-            OriginalLoadReferences = []
-            Stamp = None }
+        let cacheKey =
+            this.GetAllFiles()
+            |> List.collect (fun (p, f) ->
+                [ p.Name
+                  f.Id
+                  if f.HasSignatureFile then
+                      "s" ])
+
+        if not (OptionsCache.ContainsKey cacheKey) then
+            OptionsCache[cacheKey] <-
+                use _ = Activity.start "SyntheticProject.GetProjectOptions" [ "project", this.Name ]
+
+                let baseOptions, _ =
+                    checker.GetProjectOptionsFromScript(
+                        "file.fs",
+                        SourceText.ofString "",
+                        assumeDotNetFramework = false
+                    )
+                    |> Async.RunSynchronously
+
+                { baseOptions with
+                    ProjectFileName = this.ProjectFileName
+                    ProjectId = None
+                    SourceFiles =
+                        [| for f in this.SourceFiles do
+                               if f.HasSignatureFile then
+                                   this.ProjectDir ++ f.SignatureFileName
+
+                               this.ProjectDir ++ f.FileName |]
+                    OtherOptions =
+                        [| yield! baseOptions.OtherOptions
+                           "--optimize+"
+                           for p in this.DependsOn do
+                               $"-r:{p.OutputFilename}" |]
+                    ReferencedProjects =
+                        [| for p in this.DependsOn do
+                               FSharpReferencedProject.CreateFSharp(p.OutputFilename, p.GetProjectOptions checker) |]
+                    IsIncompleteTypeCheckEnvironment = false
+                    UseScriptResolutionRules = false
+                    LoadTime = DateTime()
+                    UnresolvedReferences = None
+                    OriginalLoadReferences = []
+                    Stamp = None }
+
+        OptionsCache[cacheKey]
 
     member this.GetAllFiles() =
         [ for f in this.SourceFiles do
@@ -148,7 +173,6 @@ type SyntheticProject =
           for p in this.DependsOn do
               yield! p.GetAllFiles() ]
 
-
 module Internal =
 
     let renderSourceFile (project: SyntheticProject) (f: SyntheticSourceFile) =
@@ -222,18 +246,8 @@ module Internal =
         let content = renderSourceFile p f
         writeFileIfChanged fileName content
 
-    let validateFileIdsAreUnique (project: SyntheticProject) =
-        let ids = [ for _, f in project.GetAllFiles() -> f.Id ]
-        let duplicates = ids |> List.groupBy id |> List.filter (fun (_, g) -> g.Length > 1)
-
-        if duplicates.Length > 0 then
-            failwith
-                $"""Source file IDs have to be unique across the project and all referenced projects. Found duplicates: {String.Join(", ", duplicates |> List.map fst)}"""
-
-
 open Internal
 
-
 [<AutoOpen>]
 module ProjectOperations =
 
@@ -246,10 +260,7 @@ module ProjectOperations =
                 |> List.updateAt index (updateFunction project.SourceFiles[index]) }
 
     let updateFileInAnyProject fileId updateFunction (rootProject: SyntheticProject) =
-        let project, _ =
-            rootProject.GetAllFiles()
-            |> List.tryFind (fun (_, f) -> f.Id = fileId)
-            |> Option.defaultWith (fun () -> failwith $"File with ID '{fileId}' not found in any project")
+        let project, _ = rootProject.FindInAllProjects fileId
 
         if project = rootProject then
             updateFile fileId updateFunction project
@@ -261,7 +272,7 @@ module ProjectOperations =
                     rootProject.DependsOn
                     |> List.updateAt index (updateFile fileId updateFunction project) }
 
-    let private counter = (Seq.initInfinite id).GetEnumerator()
+    let private counter = (Seq.initInfinite ((+) 2)).GetEnumerator()
 
     let updatePublicSurface f =
         counter.MoveNext() |> ignore
@@ -311,6 +322,21 @@ module ProjectOperations =
         if checkResult.Diagnostics.Length > 0 then
             failwith $"Expected no errors, but there were some: \n%A{checkResult.Diagnostics}"
 
+    let expectSingleWarningAndNoErrors (warningSubString:string) parseAndCheckResults _  = 
+        let checkResult = getTypeCheckResult parseAndCheckResults
+        let errors = checkResult.Diagnostics|> Array.filter (fun d -> d.Severity = FSharpDiagnosticSeverity.Error)
+        if errors.Length > 0 then
+            failwith $"Expected no errors, but there were some: \n%A{errors}"
+
+        let warnings = checkResult.Diagnostics|> Array.filter (fun d -> d.Severity = FSharpDiagnosticSeverity.Warning)
+        match warnings |> Array.tryExactlyOne with
+        | None -> failwith $"Expected 1 warning, but got {warnings.Length} instead: \n%A{warnings}"
+        | Some w -> 
+            if w.Message.Contains warningSubString then
+                ()
+            else 
+                failwith $"Expected 1 warning with substring '{warningSubString}' but got %A{w}"
+
     let expectErrors parseAndCheckResults _ =
         let checkResult = getTypeCheckResult parseAndCheckResults
 
@@ -343,6 +369,7 @@ module ProjectOperations =
             |> Seq.map (fun r -> Path.GetFileName(r.FileName), r.StartLine, r.StartColumn, r.EndColumn)
             |> Seq.sortBy (fun (file, _, _, _) -> file)
             |> Seq.toArray
+
         Assert.Equal<(string * int * int * int)[]>(expected |> Seq.toArray, actual)
 
     let rec saveProject (p: SyntheticProject) generateSignatureFiles checker =
@@ -378,7 +405,6 @@ type WorkflowContext =
 
 let SaveAndCheckProject project checker =
     async {
-        validateFileIdsAreUnique project
 
         do! saveProject project true checker
 
@@ -402,7 +428,26 @@ let SaveAndCheckProject project checker =
               Cursor = None }
     }
 
-type ProjectWorkflowBuilder(initialProject: SyntheticProject, ?checker: FSharpChecker) =
+type ProjectWorkflowBuilder
+    (
+        initialProject: SyntheticProject,
+        ?initialContext,
+        ?checker: FSharpChecker,
+        ?useGetSource,
+        ?useChangeNotifications
+    ) =
+
+    let useGetSource = defaultArg useGetSource false
+    let useChangeNotifications = defaultArg useChangeNotifications false
+
+    let mutable latestProject = initialProject
+
+    let getSource filePath =
+        filePath
+        |> latestProject.FindByPath
+        |> renderSourceFile latestProject
+        |> SourceText.ofString
+        |> Some
 
     let checker =
         defaultArg
@@ -410,19 +455,40 @@ type ProjectWorkflowBuilder(initialProject: SyntheticProject, ?checker: FSharpCh
             (FSharpChecker.Create(
                 keepAllBackgroundSymbolUses = false,
                 enableBackgroundItemKeyStoreAndSemanticClassification = true,
-                enablePartialTypeChecking = true
+                enablePartialTypeChecking = true,
+                captureIdentifiersWhenParsing = true,
+                documentSource = (if useGetSource then DocumentSource.Custom getSource else DocumentSource.FileSystem)
             ))
 
-    let mapProject f workflow =
+    let mapProjectAsync f workflow =
         async {
             let! ctx = workflow
-            return { ctx with Project = f ctx.Project }
+            let! project = f ctx.Project
+            latestProject <- project
+            return { ctx with Project = project }
         }
 
+    let mapProject f = mapProjectAsync (f >> async.Return)
+
+    /// Creates a ProjectWorkflowBuilder which will already have the project
+    /// saved and checked so time won't be spent on that.
+    /// Also the project won't be deleted after the computation expression is evaluated
+    member this.CreateBenchmarkBuilder() =
+        let ctx = this.Yield() |> Async.RunSynchronously
+
+        ProjectWorkflowBuilder(
+            ctx.Project,
+            ctx,
+            useGetSource = useGetSource,
+            useChangeNotifications = useChangeNotifications
+        )
+
     member this.Checker = checker
 
     member this.Yield _ =
-        SaveAndCheckProject initialProject checker
+        match initialContext with
+        | Some ctx -> async.Return ctx
+        | _ -> SaveAndCheckProject initialProject checker
 
     member this.DeleteProjectDir() =
         if Directory.Exists initialProject.ProjectDir then
@@ -432,13 +498,27 @@ type ProjectWorkflowBuilder(initialProject: SyntheticProject, ?checker: FSharpCh
         try
             Async.RunSynchronously workflow
         finally
-            this.DeleteProjectDir()
+            if initialContext.IsNone then
+                this.DeleteProjectDir()
 
     /// Change contents of given file using `processFile` function.
     /// Does not save the file to disk.
     [<CustomOperation "updateFile">]
     member this.UpdateFile(workflow: Async<WorkflowContext>, fileId: string, processFile) =
-        workflow |> mapProject (updateFileInAnyProject fileId processFile)
+        workflow
+        |> mapProject (updateFileInAnyProject fileId processFile)
+        |> mapProjectAsync (fun project ->
+            async {
+                use _ =
+                    Activity.start "ProjectWorkflowBuilder.UpdateFile" [ Activity.Tags.project, project.Name; "fileId", fileId ]
+
+                if useChangeNotifications then
+                    let project, file = project.FindInAllProjects fileId
+                    let filePath = project.ProjectDir ++ file.FileName
+                    do! checker.NotifyFileChanged(filePath, project.GetProjectOptions checker)
+
+                return project
+            })
 
     /// Add a file above given file in the project.
     [<CustomOperation "addFileAbove">]
@@ -463,6 +543,9 @@ type ProjectWorkflowBuilder(initialProject: SyntheticProject, ?checker: FSharpCh
     [<CustomOperation "checkFile">]
     member this.CheckFile(workflow: Async<WorkflowContext>, fileId: string, processResults) =
         async {
+            use _ =
+                Activity.start "ProjectWorkflowBuilder.CheckFile" [ Activity.Tags.project, initialProject.Name; "fileId", fileId ]
+
             let! ctx = workflow
             let! results = checkFile fileId ctx.Project checker
 
@@ -476,6 +559,9 @@ type ProjectWorkflowBuilder(initialProject: SyntheticProject, ?checker: FSharpCh
 
     member this.CheckFile(workflow: Async<WorkflowContext>, fileId: string, processResults) =
         async {
+            use _ =
+                Activity.start "ProjectWorkflowBuilder.CheckFile" [ Activity.Tags.project, initialProject.Name; "fileId", fileId ]
+
             let! ctx = workflow
             let! results = checkFile fileId ctx.Project checker
             let typeCheckResults = getTypeCheckResult results
@@ -500,7 +586,9 @@ type ProjectWorkflowBuilder(initialProject: SyntheticProject, ?checker: FSharpCh
 
             if su.IsNone then
                 let file = ctx.Project.Find fileId
-                failwith $"No symbol found in {file.FileName} at {line}:{colAtEndOfNames}\nFile contents:\n\n{renderSourceFile ctx.Project file}\n"
+
+                failwith
+                    $"No symbol found in {file.FileName} at {line}:{colAtEndOfNames}\nFile contents:\n\n{renderSourceFile ctx.Project file}\n"
 
             return { ctx with Cursor = su }
         }
@@ -519,7 +607,9 @@ type ProjectWorkflowBuilder(initialProject: SyntheticProject, ?checker: FSharpCh
 
             let file = ctx.Project.Find fileId
             let absFileName = ctx.Project.ProjectDir ++ file.FileName
-            let! results = checker.FindBackgroundReferencesInFile(absFileName, options, symbolUse.Symbol, fastCheck = true)
+
+            let! results =
+                checker.FindBackgroundReferencesInFile(absFileName, options, symbolUse.Symbol, fastCheck = true)
 
             processResults (results |> Seq.toList)
 
@@ -603,28 +693,11 @@ type ProjectWorkflowBuilder(initialProject: SyntheticProject, ?checker: FSharpCh
 let projectWorkflow project = ProjectWorkflowBuilder project
 
 
-/// Just like ProjectWorkflowBuilder but expects a saved and checked project
-/// so time is not spent on it during the benchmark.
-/// Also does not delete the project at the end of a run - so it keeps working for the next iteration
-type ProjectBenchmarkBuilder(initialContext: WorkflowContext, checker) =
-    inherit ProjectWorkflowBuilder(initialContext.Project, checker)
-
-    static member Create(initialProject, ?checker) =
-        async {
-            let checker = defaultArg checker (FSharpChecker.Create())
-            let! initialContext = SaveAndCheckProject initialProject checker
-            return ProjectBenchmarkBuilder(initialContext, checker)
-        }
-
-    member this.Yield _ = async.Return initialContext
-
-    member this.Run(workflow: Async<WorkflowContext>) = Async.RunSynchronously workflow
-
-
 type SyntheticProject with
 
     /// Execute a set of operations on this project.
     /// The project is saved to disk and type checked at the start.
     member this.Workflow = projectWorkflow this
 
-    member this.WorkflowWith checker = ProjectWorkflowBuilder(this, checker)
+    member this.WorkflowWith checker =
+        ProjectWorkflowBuilder(this, checker = checker)
diff --git a/tests/FSharp.Test.Utilities/SurfaceArea.fs b/tests/FSharp.Test.Utilities/SurfaceArea.fs
new file mode 100644
index 00000000000..ca3a3570d16
--- /dev/null
+++ b/tests/FSharp.Test.Utilities/SurfaceArea.fs
@@ -0,0 +1,127 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+module FSharp.Test.SurfaceArea
+    open System
+    open System.IO
+    open System.Reflection
+    open System.Text.RegularExpressions
+
+    let private assembleDiffMessage actual expected =
+      
+        let getLines text =
+            use reader = new StringReader(text)
+            Seq.initInfinite (fun _ -> reader.ReadLine()) 
+            |> Seq.takeWhile (not << isNull)
+            |> set
+        let actual   = getLines actual  
+        let expected = getLines expected
+
+        /// Surface area types/members which were expected to be found but missing from the actual surface area.
+        let unexpectedlyMissing = Set.difference expected actual
+
+        /// Surface area types/members present in the actual surface area but weren't expected to be.
+        let unexpectedlyPresent = Set.difference actual expected
+
+        // If both sets are empty, the surface areas match so allow the test to pass.
+        if Set.isEmpty unexpectedlyMissing
+          && Set.isEmpty unexpectedlyPresent then
+            None
+        else
+            // The surface areas don't match; prepare an easily-readable output message.
+            let msg =
+                let inline newLine (sb : System.Text.StringBuilder) = sb.AppendLine () |> ignore
+                let sb = System.Text.StringBuilder ()
+                sb.Append "Unexpectedly missing (expected, not actual):" |> ignore
+                for s in unexpectedlyMissing do
+                    newLine sb
+                    sb.Append "    " |> ignore
+                    sb.Append s |> ignore
+                newLine sb
+                newLine sb
+                sb.Append "Unexpectedly present (actual, not expected):" |> ignore
+                for s in unexpectedlyPresent do
+                    newLine sb
+                    sb.Append "    " |> ignore
+                    sb.Append s |> ignore
+                newLine sb
+                sb.ToString ()
+
+            Some msg
+        
+    // Gets string form of public surface area for the currently-loaded assembly
+    let private getSurfaceAreaForAssembly (assembly: Assembly) =
+
+        // get current FSharp.Core
+        let fsCoreFullName = assembly.FullName
+
+        // public types only
+        let types = assembly.ExportedTypes |> Seq.filter (fun ty -> let ti = ty.GetTypeInfo() in ti.IsPublic || ti.IsNestedPublic) |> Array.ofSeq
+        let references = assembly.GetReferencedAssemblies()
+
+        // extract canonical string form for every public member of every type
+        let getTypeMemberStrings (t : Type) =
+            // for System.Runtime-based profiles, need to do lots of manual work
+            let getMembers (t : Type) =
+                let ti = t.GetTypeInfo()
+                let cast (info: #MemberInfo) = (t, info :> MemberInfo)
+                let isDeclaredInFSharpCore (m:MemberInfo) = m.DeclaringType.Assembly.FullName = fsCoreFullName
+                seq {
+                    yield! ti.DeclaredEvents     |> Seq.filter (fun m -> m.AddMethod.IsPublic && m |> isDeclaredInFSharpCore) |> Seq.map cast
+                    yield! ti.DeclaredProperties |> Seq.filter (fun m -> m.GetMethod.IsPublic && m |> isDeclaredInFSharpCore) |> Seq.map cast
+                    yield! ti.DeclaredMethods    |> Seq.filter (fun m -> m.IsPublic && m |> isDeclaredInFSharpCore) |> Seq.map cast
+                    yield! ti.DeclaredFields     |> Seq.filter (fun m -> m.IsPublic && m |> isDeclaredInFSharpCore) |> Seq.map cast
+                    yield! ti.DeclaredConstructors  |> Seq.filter (fun m -> m.IsPublic) |> Seq.map cast
+                    yield! ti.DeclaredNestedTypes   |> Seq.filter (fun ty -> ty.IsNestedPublic) |> Seq.map cast
+                } |> Array.ofSeq
+
+            getMembers t
+            |> Array.map (fun (ty, m) -> sprintf "%s: %s" (ty.ToString()) (m.ToString()))
+
+        let actual = [|
+                yield! references |> Array.map(fun name -> $"! AssemblyReference: {name.Name}")
+                yield! types |> Array.collect getTypeMemberStrings
+            |]
+        assembly, actual
+
+    let private appendNewLine str = str + System.Environment.NewLine
+
+    // verify public surface area matches expected, handles baseline update when TEST_UPDATE_BSL is set
+    let verify assembly baselinePath outFileName : unit =
+
+        let expected =
+            File.ReadAllLines(baselinePath)
+            |> String.concat System.Environment.NewLine
+            |> appendNewLine
+
+        let normalize (s:string) = Regex.Replace(s, "(\\r\\n|\\n|\\r)+", Environment.NewLine).Trim()
+        let asm, actualNotNormalized = getSurfaceAreaForAssembly (assembly)
+        let actual = 
+            actualNotNormalized 
+            |> Seq.map normalize 
+            |> Seq.filter (String.IsNullOrWhiteSpace >> not)
+            |> Seq.sort
+            |> String.concat Environment.NewLine
+
+        let expected = normalize expected
+
+        let logFile =
+            Path.Combine(Path.GetDirectoryName(assembly.Location), outFileName)
+
+        File.WriteAllText(logFile, actual)
+
+        match assembleDiffMessage expected actual with
+        | None -> ()
+        | Some diff ->
+            // Update baselines here
+            match Environment.GetEnvironmentVariable("TEST_UPDATE_BSL") with
+            | null -> ()
+            | _ -> File.Copy(logFile, baselinePath, true)
+                
+            let msg = $"""Assembly: %A{asm}
+
+              Expected and actual surface area don't match. To see the delta, run:
+                  windiff {baselinePath} {logFile}
+
+              {diff}"""
+
+            failwith msg
diff --git a/tests/FSharp.Test.Utilities/Utilities.fs b/tests/FSharp.Test.Utilities/Utilities.fs
index f74faf49fa9..1c6781fdd9b 100644
--- a/tests/FSharp.Test.Utilities/Utilities.fs
+++ b/tests/FSharp.Test.Utilities/Utilities.fs
@@ -14,6 +14,24 @@ open Microsoft.CodeAnalysis.CSharp
 open TestFramework
 open NUnit.Framework
 
+type TheoryForNETCOREAPPAttribute() = 
+    inherit Xunit.TheoryAttribute()
+    #if !NETCOREAPP    
+        do base.Skip <- "Only NETCOREAPP is supported runtime for this kind of test."
+    #endif
+
+type FactForNETCOREAPPAttribute() =
+    inherit Xunit.FactAttribute()
+    #if !NETCOREAPP    
+        do base.Skip <- "Only NETCOREAPP is supported runtime for this kind of test."
+    #endif
+
+type FactForDESKTOPAttribute() =
+    inherit Xunit.FactAttribute()
+    #if NETCOREAPP
+        do base.Skip <- "NETCOREAPP is not supported runtime for this kind of test, it is intended for DESKTOP only"
+    #endif
+
 // This file mimics how Roslyn handles their compilation references for compilation testing
 module Utilities =
 
diff --git a/tests/README.md b/tests/README.md
index 59ad0678aac..85feffdb269 100644
--- a/tests/README.md
+++ b/tests/README.md
@@ -52,7 +52,7 @@ The following test frameworks and libraries will be used for new test projects *
 * F# compiler component test which is verifying generated IL for computation expression will have category `Compiler` and subcategories `EmittedIL` and `ComputationExpressions`.
 * F# compiler service unit test which is testing F# tokenizer, will have category `Compiler.Service` and subcategory `Tokenizer`.
 
-Please, refer to [File and project structure](#File-and-project-structure) for more information on how tests will be organized on the filesystem.
+Please, refer to [File and project structure](#file-and-project-structure) for more information on how tests will be organized on the filesystem.
 
 ## File and project structure
 
@@ -63,7 +63,7 @@ The proposed naming schema for test projects is: `FSharp.Category.Subcategory.Te
 
 ### Projects organization
 
-Please refer to the "[Naming schema](#Naming-schema)" section above for more information on the projects naming.
+Please refer to the "[Naming schema](#naming-schema)" section above for more information on the projects naming.
 
 New test projects will be grouped by category and test type, all subcategories are just test folders/files in the test project.
 
diff --git a/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/BackgroundCompilerBenchmarks.fs b/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/BackgroundCompilerBenchmarks.fs
index 3062f194353..3b44c1d37bf 100644
--- a/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/BackgroundCompilerBenchmarks.fs
+++ b/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/BackgroundCompilerBenchmarks.fs
@@ -1,10 +1,11 @@
 module FSharp.Benchmarks.BackgroundCompilerBenchmarks
 
-
 open System.IO
 open BenchmarkDotNet.Attributes
-open FSharp.Test.ProjectGeneration
 open FSharp.Compiler.CodeAnalysis
+open FSharp.Compiler.Text
+open FSharp.Compiler.Diagnostics
+open FSharp.Test.ProjectGeneration
 
 
 [<Literal>]
@@ -25,13 +26,14 @@ type BackgroundCompilerBenchmarks () =
     [<ParamsAllValues>]
     member val EmptyCache = true with get,set
 
-    member val Benchmark = Unchecked.defaultof<ProjectBenchmarkBuilder> with get, set
+    member val Benchmark = Unchecked.defaultof<_> with get, set
 
     member this.setup(project) =
         let checker = FSharpChecker.Create(
-            enableBackgroundItemKeyStoreAndSemanticClassification = true
+            enableBackgroundItemKeyStoreAndSemanticClassification = true,
+            captureIdentifiersWhenParsing = true
         )
-        this.Benchmark <- ProjectBenchmarkBuilder.Create(project, checker) |> Async.RunSynchronously
+        this.Benchmark <- ProjectWorkflowBuilder(project, checker=checker).CreateBenchmarkBuilder()
 
     [<IterationSetup>]
     member this.EditFirstFile_OnlyInternalChange() =
@@ -99,3 +101,123 @@ type BackgroundCompilerBenchmarks () =
     [<GlobalCleanup>]
     member this.Cleanup() =
         this.Benchmark.DeleteProjectDir()
+
+[<MemoryDiagnoser>]
+[<BenchmarkCategory(FSharpCategory)>]
+type ParsingBenchmark() =
+
+    let mutable checker: FSharpChecker = Unchecked.defaultof<_>
+    let mutable parsingOptions: FSharpParsingOptions = Unchecked.defaultof<_>
+
+    let filePath = __SOURCE_DIRECTORY__ ++ ".." ++ ".." ++ ".." ++ ".." ++ "src" ++ "Compiler" ++ "Checking" ++ "CheckExpressions.fs"
+    let source = File.ReadAllText filePath |> SourceText.ofString
+
+    [<ParamsAllValues>]
+    member val IdentCapture = true with get, set
+
+    [<GlobalSetup>]
+    member this.Setup() =
+        checker <- FSharpChecker.Create(captureIdentifiersWhenParsing = this.IdentCapture)
+        parsingOptions <- { (checker.GetParsingOptionsFromCommandLineArgs([]) |> fst) with SourceFiles = [| filePath |] }
+
+    [<IterationSetup>]
+    member _.IterationSetup() =
+        checker.InvalidateAll()
+        checker.ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients()
+
+    [<Benchmark>]
+    member _.ParseBigFile() =
+        let result = checker.ParseFile(filePath, source, parsingOptions) |> Async.RunSynchronously
+
+        if result.ParseHadErrors then
+            failwith "ParseHadErrors"
+
+[<MemoryDiagnoser>]
+[<BenchmarkCategory(FSharpCategory)>]
+type NoFileSystemCheckerBenchmark() =
+
+    let size = 30
+
+    let somethingToCompile = File.ReadAllText (__SOURCE_DIRECTORY__ ++ "SomethingToCompileSmaller.fs")
+
+    let project =
+        { SyntheticProject.Create() with
+            SourceFiles = [
+                sourceFile $"File%03d{0}" []
+                for i in 1..size do
+                    { sourceFile $"File%03d{i}" [$"File%03d{i-1}"] with ExtraSource = somethingToCompile }
+            ]
+        }
+
+    let mutable benchmark : ProjectWorkflowBuilder = Unchecked.defaultof<_>
+
+    [<ParamsAllValues>]
+    member val UseGetSource = true with get,set
+
+    [<ParamsAllValues>]
+    member val UseChangeNotifications = true with get,set
+
+    [<ParamsAllValues>]
+    member val EmptyCache = true with get,set
+
+    [<GlobalSetup>]
+    member this.Setup() =
+        benchmark <-
+            ProjectWorkflowBuilder(
+            project,
+            useGetSource = this.UseGetSource,
+            useChangeNotifications = this.UseChangeNotifications).CreateBenchmarkBuilder()
+
+    [<IterationSetup>]
+    member this.EditFirstFile_OnlyInternalChange() =
+        if this.EmptyCache then
+            benchmark.Checker.InvalidateAll()
+            benchmark.Checker.ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients()
+
+    [<Benchmark>]
+    member this.ExampleWorkflow() =
+
+        use _ = Activity.start "Benchmark" [
+            "UseGetSource", this.UseGetSource.ToString()
+            "UseChangeNotifications", this.UseChangeNotifications.ToString()
+        ]
+
+        let first = "File001"
+        let middle = $"File%03d{size / 2}"
+        let last = $"File%03d{size}"
+
+        if this.UseGetSource && this.UseChangeNotifications then
+
+            benchmark {
+                updateFile first updatePublicSurface
+                checkFile first expectSignatureChanged
+                checkFile last expectSignatureChanged
+                updateFile middle updatePublicSurface
+                checkFile last expectSignatureChanged
+                addFileAbove middle (sourceFile "addedFile" [first])
+                updateFile middle (addDependency "addedFile")
+                checkFile middle expectSignatureChanged
+                checkFile last expectSignatureChanged
+            }
+
+        else
+
+            benchmark {
+                updateFile first updatePublicSurface
+                saveFile first
+                checkFile first expectSignatureChanged
+                checkFile last expectSignatureChanged
+                updateFile middle updatePublicSurface
+                saveFile middle
+                checkFile last expectSignatureChanged
+                addFileAbove middle (sourceFile "addedFile" [first])
+                saveFile "addedFile"
+                updateFile middle (addDependency "addedFile")
+                saveFile middle
+                checkFile middle expectSignatureChanged
+                checkFile last expectSignatureChanged
+            }
+
+    [<GlobalCleanup>]
+    member this.Cleanup() =
+        benchmark.DeleteProjectDir()
diff --git a/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/FSharp.Compiler.Benchmarks.fsproj b/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/FSharp.Compiler.Benchmarks.fsproj
index cc18675151e..07af4baf87e 100644
--- a/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/FSharp.Compiler.Benchmarks.fsproj
+++ b/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/FSharp.Compiler.Benchmarks.fsproj
@@ -15,11 +15,11 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <Compile Include="BackgroundCompilerBenchmarks.fs" />
     <Compile Include="SourceText.fs" />
     <Compile Include="DecentlySizedStandAloneFileBenchmark.fs" />
     <Compile Include="CompilerServiceBenchmarks.fs" />
     <Compile Include="FileCascadeBenchmarks.fs" />
+    <Compile Include="BackgroundCompilerBenchmarks.fs" />
     <Compile Include="Program.fs" />
   </ItemGroup>
 
diff --git a/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/SomethingToCompile.fs b/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/SomethingToCompile.fs
index ad32fba5951..4451929c3f3 100644
--- a/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/SomethingToCompile.fs
+++ b/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/SomethingToCompile.fs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information.
+// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information.
 
 // Taken from Utilities/illib.fs
 
diff --git a/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/SomethingToCompileSmaller.fs b/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/SomethingToCompileSmaller.fs
new file mode 100644
index 00000000000..f3f87402a61
--- /dev/null
+++ b/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/SomethingToCompileSmaller.fs
@@ -0,0 +1,581 @@
+// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information.
+
+// Taken from Utilities/illib.fs
+
+
+open System
+open System.Collections.Generic
+open System.Collections.Concurrent
+open System.Diagnostics
+open System.IO
+open System.Threading
+open System.Threading.Tasks
+open System.Runtime.CompilerServices
+
+
+[<AutoOpen>]
+module internal PervasiveAutoOpens =
+    /// Logical shift right treating int32 as unsigned integer.
+    /// Code that uses this should probably be adjusted to use unsigned integer types.
+    let (>>>&) (x: int32) (n: int32) = int32 (uint32 x >>> n)
+
+    let notlazy v = Lazy<_>.CreateFromValue v
+
+    let inline isNil l = List.isEmpty l
+
+    /// Returns true if the list has less than 2 elements. Otherwise false.
+    let inline isNilOrSingleton l =
+        match l with
+        | []
+        | [ _ ] -> true
+        | _ -> false
+
+    /// Returns true if the list contains exactly 1 element. Otherwise false.
+    let inline isSingleton l =
+        match l with
+        | [ _ ] -> true
+        | _ -> false
+
+    type 'T MaybeNull when 'T: null and 'T: not struct = 'T
+
+    let inline isNotNull (x: 'T) = not (isNull x)
+
+    let inline (|NonNullQuick|) (x: 'T MaybeNull) =
+        match x with
+        | null -> raise (NullReferenceException())
+        | v -> v
+
+    let inline nonNull (x: 'T MaybeNull) =
+        match x with
+        | null -> raise (NullReferenceException())
+        | v -> v
+
+    let inline (|Null|NonNull|) (x: 'T MaybeNull) : Choice<unit, 'T> =
+        match x with
+        | null -> Null
+        | v -> NonNull v
+
+    let inline nullArgCheck paramName (x: 'T MaybeNull) =
+        match x with
+        | null -> raise (ArgumentNullException(paramName))
+        | v -> v
+
+    let inline (===) x y = LanguagePrimitives.PhysicalEquality x y
+
+    /// Per the docs the threshold for the Large Object Heap is 85000 bytes: https://docs.microsoft.com/en-us/dotnet/standard/garbage-collection/large-object-heap#how-an-object-ends-up-on-the-large-object-heap-and-how-gc-handles-them
+    /// We set the limit to be 80k to account for larger pointer sizes for when F# is running 64-bit.
+    let LOH_SIZE_THRESHOLD_BYTES = 80_000
+
+    type String with
+
+        member inline x.StartsWithOrdinal value =
+            x.StartsWith(value, StringComparison.Ordinal)
+
+        member inline x.EndsWithOrdinal value =
+            x.EndsWith(value, StringComparison.Ordinal)
+
+        member inline x.EndsWithOrdinalIgnoreCase value =
+            x.EndsWith(value, StringComparison.OrdinalIgnoreCase)
+
+    /// Get an initialization hole
+    let getHole (r: _ ref) =
+        match r.Value with
+        | None -> failwith "getHole"
+        | Some x -> x
+
+    let reportTime =
+        let mutable tFirst = None
+        let mutable tPrev = None
+
+        fun showTimes descr ->
+            if showTimes then
+                let t = Process.GetCurrentProcess().UserProcessorTime.TotalSeconds
+
+                let prev =
+                    match tPrev with
+                    | None -> 0.0
+                    | Some t -> t
+
+                let first =
+                    match tFirst with
+                    | None ->
+                        (tFirst <- Some t
+                         t)
+                    | Some t -> t
+
+                printf "  ilwrite: Cpu %4.1f (total)   %4.1f (delta) - %s\n" (t - first) (t - prev) descr
+                tPrev <- Some t
+
+    let foldOn p f z x = f z (p x)
+
+    let notFound () = raise (KeyNotFoundException())
+
+    type Async with
+
+        static member RunImmediate(computation: Async<'T>, ?cancellationToken) =
+            let cancellationToken = defaultArg cancellationToken Async.DefaultCancellationToken
+            let ts = TaskCompletionSource<'T>()
+            let task = ts.Task
+
+            Async.StartWithContinuations(
+                computation,
+                (fun k -> ts.SetResult k),
+                (fun exn -> ts.SetException exn),
+                (fun _ -> ts.SetCanceled()),
+                cancellationToken
+            )
+
+            task.Result
+
+/// An efficient lazy for inline storage in a class type. Results in fewer thunks.
+[<Struct>]
+type InlineDelayInit<'T when 'T: not struct> =
+    new(f: unit -> 'T) =
+        {
+            store = Unchecked.defaultof<'T>
+            func = Func<_>(f)
+        }
+
+    val mutable store: 'T
+    val mutable func: Func<'T>
+
+    member x.Value =
+        match x.func with
+        | null -> x.store
+        | _ ->
+            let res = LazyInitializer.EnsureInitialized(&x.store, x.func)
+            x.func <- Unchecked.defaultof<_>
+            res
+
+//-------------------------------------------------------------------------
+// Library: projections
+//------------------------------------------------------------------------
+
+module Order =
+    let orderBy (p: 'T -> 'U) =
+        { new IComparer<'T> with
+            member _.Compare(x, xx) = compare (p x) (p xx)
+        }
+
+    let orderOn p (pxOrder: IComparer<'U>) =
+        { new IComparer<'T> with
+            member _.Compare(x, xx) = pxOrder.Compare(p x, p xx)
+        }
+
+    let toFunction (pxOrder: IComparer<'U>) x y = pxOrder.Compare(x, y)
+
+//-------------------------------------------------------------------------
+// Library: arrays, lists, options, resizearrays
+//-------------------------------------------------------------------------
+
+module Array =
+
+    let mapq f inp =
+        match inp with
+        | [||] -> inp
+        | _ ->
+            let res = Array.map f inp
+            let len = inp.Length
+            let mutable eq = true
+            let mutable i = 0
+
+            while eq && i < len do
+                if not (inp[i] === res[i]) then
+                    eq <- false
+
+                i <- i + 1
+
+            if eq then inp else res
+
+    let lengthsEqAndForall2 p l1 l2 =
+        Array.length l1 = Array.length l2 && Array.forall2 p l1 l2
+
+    let order (eltOrder: IComparer<'T>) =
+        { new IComparer<array<'T>> with
+            member _.Compare(xs, ys) =
+                let c = compare xs.Length ys.Length
+
+                if c <> 0 then
+                    c
+                else
+                    let rec loop i =
+                        if i >= xs.Length then
+                            0
+                        else
+                            let c = eltOrder.Compare(xs[i], ys[i])
+                            if c <> 0 then c else loop (i + 1)
+
+                    loop 0
+        }
+
+    let existsOne p l =
+        let rec forallFrom p l n =
+            (n >= Array.length l) || (p l[n] && forallFrom p l (n + 1))
+
+        let rec loop p l n =
+            (n < Array.length l)
+            && (if p l[n] then
+                    forallFrom (fun x -> not (p x)) l (n + 1)
+                else
+                    loop p l (n + 1))
+
+        loop p l 0
+
+    let existsTrue (arr: bool[]) =
+        let rec loop n =
+            (n < arr.Length) && (arr[n] || loop (n + 1))
+
+        loop 0
+
+    let findFirstIndexWhereTrue (arr: _[]) p =
+        let rec look lo hi =
+            assert ((lo >= 0) && (hi >= 0))
+            assert ((lo <= arr.Length) && (hi <= arr.Length))
+
+            if lo = hi then
+                lo
+            else
+                let i = (lo + hi) / 2
+
+                if p arr[i] then
+                    if i = 0 then i
+                    else if p arr[i - 1] then look lo i
+                    else i
+                else
+                    // not true here, look after
+                    look (i + 1) hi
+
+        look 0 arr.Length
+
+    /// pass an array byref to reverse it in place
+    let revInPlace (array: 'T[]) =
+        if Array.isEmpty array then
+            ()
+        else
+            let arrLen, revLen = array.Length - 1, array.Length / 2 - 1
+
+            for idx in 0..revLen do
+                let t1 = array[idx]
+                let t2 = array[arrLen - idx]
+                array[idx] <- t2
+                array[arrLen - idx] <- t1
+
+    /// Async implementation of Array.map.
+    let mapAsync (mapping: 'T -> Async<'U>) (array: 'T[]) : Async<'U[]> =
+        let len = Array.length array
+        let result = Array.zeroCreate len
+
+        async { // Apply the mapping function to each array element.
+            for i in 0 .. len - 1 do
+                let! mappedValue = mapping array[i]
+                result[i] <- mappedValue
+
+            // Return the completed results.
+            return result
+        }
+
+    /// Returns a new array with an element replaced with a given value.
+    let replace index value (array: _[]) =
+        if index >= array.Length then
+            raise (IndexOutOfRangeException "index")
+
+        let res = Array.copy array
+        res[index] <- value
+        res
+
+    /// Optimized arrays equality. ~100x faster than `array1 = array2` on strings.
+    /// ~2x faster for floats
+    /// ~0.8x slower for ints
+    let inline areEqual (xs: 'T[]) (ys: 'T[]) =
+        match xs, ys with
+        | null, null -> true
+        | [||], [||] -> true
+        | null, _
+        | _, null -> false
+        | _ when xs.Length <> ys.Length -> false
+        | _ ->
+            let mutable break' = false
+            let mutable i = 0
+            let mutable result = true
+
+            while i < xs.Length && not break' do
+                if xs[i] <> ys[i] then
+                    break' <- true
+                    result <- false
+
+                i <- i + 1
+
+            result
+
+    /// Returns all heads of a given array.
+    /// For [|1;2;3|] it returns [|[|1; 2; 3|]; [|1; 2|]; [|1|]|]
+    let heads (array: 'T[]) =
+        let res = Array.zeroCreate<'T[]> array.Length
+
+        for i = array.Length - 1 downto 0 do
+            res[i] <- array[0..i]
+
+        res
+
+    /// check if subArray is found in the wholeArray starting
+    /// at the provided index
+    let inline isSubArray (subArray: 'T[]) (wholeArray: 'T[]) index =
+        if subArray.Length = 0 then
+            true
+        elif subArray.Length > wholeArray.Length then
+            false
+        elif subArray.Length = wholeArray.Length then
+            areEqual subArray wholeArray
+        else
+            let rec loop subidx idx =
+                if subidx = subArray.Length then
+                    true
+                elif subArray[subidx] = wholeArray[idx] then
+                    loop (subidx + 1) (idx + 1)
+                else
+                    false
+
+            loop 0 index
+
+    /// Returns true if one array has another as its subset from index 0.
+    let startsWith (prefix: _[]) (whole: _[]) = isSubArray prefix whole 0
+
+    /// Returns true if one array has trailing elements equal to another's.
+    let endsWith (suffix: _[]) (whole: _[]) =
+        isSubArray suffix whole (whole.Length - suffix.Length)
+
+module Option =
+
+    let mapFold f s opt =
+        match opt with
+        | None -> None, s
+        | Some x ->
+            let x2, s2 = f s x
+            Some x2, s2
+
+    let attempt (f: unit -> 'T) =
+        try
+            Some(f ())
+        with _ ->
+            None
+
+module List =
+
+    let sortWithOrder (c: IComparer<'T>) elements =
+        List.sortWith (Order.toFunction c) elements
+
+    let splitAfter n l =
+        let rec split_after_acc n l1 l2 =
+            if n <= 0 then
+                List.rev l1, l2
+            else
+                split_after_acc (n - 1) ((List.head l2) :: l1) (List.tail l2)
+
+        split_after_acc n [] l
+
+    let existsi f xs =
+        let rec loop i xs =
+            match xs with
+            | [] -> false
+            | h :: t -> f i h || loop (i + 1) t
+
+        loop 0 xs
+
+    let lengthsEqAndForall2 p l1 l2 =
+        List.length l1 = List.length l2 && List.forall2 p l1 l2
+
+    let rec findi n f l =
+        match l with
+        | [] -> None
+        | h :: t -> if f h then Some(h, n) else findi (n + 1) f t
+
+    let splitChoose select l =
+        let rec ch acc1 acc2 l =
+            match l with
+            | [] -> List.rev acc1, List.rev acc2
+            | x :: xs ->
+                match select x with
+                | Choice1Of2 sx -> ch (sx :: acc1) acc2 xs
+                | Choice2Of2 sx -> ch acc1 (sx :: acc2) xs
+
+        ch [] [] l
+
+    let rec checkq l1 l2 =
+        match l1, l2 with
+        | h1 :: t1, h2 :: t2 -> h1 === h2 && checkq t1 t2
+        | _ -> true
+
+    let mapq (f: 'T -> 'T) inp =
+        assert not typeof<'T>.IsValueType
+
+        match inp with
+        | [] -> inp
+        | [ h1a ] ->
+            let h2a = f h1a
+            if h1a === h2a then inp else [ h2a ]
+        | [ h1a; h1b ] ->
+            let h2a = f h1a
+            let h2b = f h1b
+
+            if h1a === h2a && h1b === h2b then inp else [ h2a; h2b ]
+        | [ h1a; h1b; h1c ] ->
+            let h2a = f h1a
+            let h2b = f h1b
+            let h2c = f h1c
+
+            if h1a === h2a && h1b === h2b && h1c === h2c then
+                inp
+            else
+                [ h2a; h2b; h2c ]
+        | _ ->
+            let res = List.map f inp
+            if checkq inp res then inp else res
+
+    let frontAndBack l =
+        let rec loop acc l =
+            match l with
+            | [] ->
+                Debug.Assert(false, "empty list")
+                invalidArg "l" "empty list"
+            | [ h ] -> List.rev acc, h
+            | h :: t -> loop (h :: acc) t
+
+        loop [] l
+
+    let tryFrontAndBack l =
+        match l with
+        | [] -> None
+        | _ -> Some(frontAndBack l)
+
+    let tryRemove f inp =
+        let rec loop acc l =
+            match l with
+            | [] -> None
+            | h :: t -> if f h then Some(h, List.rev acc @ t) else loop (h :: acc) t
+
+        loop [] inp
+
+    let zip4 l1 l2 l3 l4 =
+        List.zip l1 (List.zip3 l2 l3 l4)
+        |> List.map (fun (x1, (x2, x3, x4)) -> (x1, x2, x3, x4))
+
+    let unzip4 l =
+        let a, b, cd = List.unzip3 (List.map (fun (x, y, z, w) -> (x, y, (z, w))) l)
+        let c, d = List.unzip cd
+        a, b, c, d
+
+    let rec iter3 f l1 l2 l3 =
+        match l1, l2, l3 with
+        | h1 :: t1, h2 :: t2, h3 :: t3 ->
+            f h1 h2 h3
+            iter3 f t1 t2 t3
+        | [], [], [] -> ()
+        | _ -> failwith "iter3"
+
+    let takeUntil p l =
+        let rec loop acc l =
+            match l with
+            | [] -> List.rev acc, []
+            | x :: xs -> if p x then List.rev acc, l else loop (x :: acc) xs
+
+        loop [] l
+
+    let order (eltOrder: IComparer<'T>) =
+        { new IComparer<'T list> with
+            member _.Compare(xs, ys) =
+                let rec loop xs ys =
+                    match xs, ys with
+                    | [], [] -> 0
+                    | [], _ -> -1
+                    | _, [] -> 1
+                    | x :: xs, y :: ys ->
+                        let cxy = eltOrder.Compare(x, y)
+                        if cxy = 0 then loop xs ys else cxy
+
+                loop xs ys
+        }
+
+    let indexNotFound () =
+        raise (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 memAssoc x l =
+        match l with
+        | [] -> false
+        | (h, _) :: t -> x = h || memAssoc x t
+
+    let rec memq x l =
+        match l with
+        | [] -> false
+        | h :: t -> LanguagePrimitives.PhysicalEquality x h || memq x t
+
+    let mapNth n f xs =
+        let rec mn i =
+            function
+            | [] -> []
+            | x :: xs -> if i = n then f x :: xs else x :: mn (i + 1) xs
+
+        mn 0 xs
+
+    let count pred xs =
+        List.fold (fun n x -> if pred x then n + 1 else n) 0 xs
+
+    let headAndTail l =
+        match l with
+        | [] -> failwith "headAndTail"
+        | h :: t -> (h, t)
+
+    // WARNING: not tail-recursive
+    let mapHeadTail fhead ftail =
+        function
+        | [] -> []
+        | [ x ] -> [ fhead x ]
+        | x :: xs -> fhead x :: List.map ftail xs
+
+    let collectFold f s l =
+        let l, s = List.mapFold f s l
+        List.concat l, s
+
+    let collect2 f xs ys = List.concat (List.map2 f xs ys)
+
+    let toArraySquared xss =
+        xss |> List.map List.toArray |> List.toArray
+
+    let iterSquared f xss = xss |> List.iter (List.iter f)
+
+    let collectSquared f xss = xss |> List.collect (List.collect f)
+
+    let mapSquared f xss = xss |> List.map (List.map f)
+
+    let mapFoldSquared f z xss = List.mapFold (List.mapFold f) z xss
+
+    let forallSquared f xss = xss |> List.forall (List.forall f)
+
+    let mapiSquared f xss =
+        xss |> List.mapi (fun i xs -> xs |> List.mapi (fun j x -> f i j x))
+
+    let existsSquared f xss =
+        xss |> List.exists (fun xs -> xs |> List.exists (fun x -> f x))
+
+    let mapiFoldSquared f z xss =
+        mapFoldSquared f z (xss |> mapiSquared (fun i j x -> (i, j, x)))
+
+    let duplicates (xs: 'T list) =
+        xs
+        |> List.groupBy id
+        |> List.filter (fun (_, elems) -> Seq.length elems > 1)
+        |> List.map fst
+
+    let internal allEqual (xs: 'T list) =
+        match xs with
+        | [] -> true
+        | h :: t -> t |> List.forall (fun h2 -> h = h2)
+
+    let isSingleton xs =
+        match xs with
+        | [ _ ] -> true
+        | _ -> false
diff --git a/tests/fsharp/Compiler/CodeGen/EmittedIL/ReferenceAssemblyTests.fs b/tests/fsharp/Compiler/CodeGen/EmittedIL/ReferenceAssemblyTests.fs
index 0a3acccc85e..31cf848815a 100644
--- a/tests/fsharp/Compiler/CodeGen/EmittedIL/ReferenceAssemblyTests.fs
+++ b/tests/fsharp/Compiler/CodeGen/EmittedIL/ReferenceAssemblyTests.fs
@@ -463,6 +463,115 @@ extends [runtime]System.Object
 
   }"""]
 
+    [<Test>]
+    let ``Properties are emitted for CliMutable records`` () = 
+        FSharp """
+namespace ReferenceAssembly
+type [<CLIMutable;NoComparison;NoEquality>] MyRecord = { MyId: int }"""
+        |> withOptions ["--refonly"]
+        |> compile
+        |> shouldSucceed
+        |> verifyIL [
+            referenceAssemblyAttributeExpectedIL
+            "      .property instance int32 MyId()"]
+
+    [<Test>] 
+    let ``Properties are emitted even for CliMutable records which are not last in a file`` () = 
+        FSharp """
+namespace ReferenceAssembly
+type [<CLIMutable;NoComparison;NoEquality>] MyRecord = { MyId: int }
+type [<CLIMutable;NoComparison;NoEquality>] MySecondRecord = { MySecondId: string }
+"""
+        |> withOptions ["--refonly"]
+        |> compile
+        |> shouldSucceed
+        |> verifyIL [
+            referenceAssemblyAttributeExpectedIL
+            "      .property instance int32 MyId()"
+            "      .property instance string MySecondId()"]
+
+    [<Test>] // Regression https://github.com/dotnet/fsharp/issues/14088 .
+    // Generated IL was assigning properties to the last record in file instead of where they are supposed to be
+    let ``Properties are emitted for equal records in the same file`` () = 
+        FSharp """
+namespace Net7FSharpSnafu.Library
+
+open System
+
+type [<CLIMutable;NoComparison;NoEquality>] MyRecord = 
+  {  Name: string }
+
+type [<CLIMutable;NoComparison;NoEquality>] MySecondRecord = { Name: string }
+"""
+        |> withOptions ["--refonly"]
+        |> compile
+        |> shouldSucceed
+        |> verifyIL ["""    .class public auto ansi serializable sealed Net7FSharpSnafu.Library.MyRecord
+           extends [runtime]System.Object
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CLIMutableAttribute::.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.NoEqualityAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 02 00 00 00 00 00 ) 
+      .method public hidebysig specialname instance string 
+              get_Name() cil managed
+      {
+        .custom instance void [runtime]System.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:  throw
+      } 
+    
+      .method public hidebysig specialname instance void 
+              set_Name(string '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:  ldnull
+        IL_0001:  throw
+      } 
+    
+      .method public specialname rtspecialname 
+              instance void  .ctor(string name) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldnull
+        IL_0001:  throw
+      } 
+    
+      .method public specialname rtspecialname 
+              instance void  .ctor() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldnull
+        IL_0001:  throw
+      } 
+    
+      .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:  ldnull
+    IL_0001:  throw
+  } 
+
+      .property instance string Name()
+  {
+    .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 ) 
+    .set instance void Net7FSharpSnafu.Library.MyRecord::set_Name(string)
+    .get instance string Net7FSharpSnafu.Library.MyRecord::get_Name()
+  } 
+}  """]
+
     [<Test>]
     let ``Properties, getters, setters are emitted for internal properties`` () =
         FSharp """
@@ -520,6 +629,11 @@ type MySecondaryAttribute() =
       IL_0001:  throw
     } 
 
+    .property instance int32 Prop1()
+    {
+      .set instance void ReferenceAssembly/MyAttribute::set_Prop1(int32)
+      .get instance int32 ReferenceAssembly/MyAttribute::get_Prop1()
+    } 
   } 
 
   .class auto ansi serializable nested public MySecondaryAttribute
@@ -559,11 +673,6 @@ type MySecondaryAttribute() =
       IL_0001:  throw
     } 
 
-    .property instance int32 Prop1()
-    {
-      .set instance void ReferenceAssembly/MyAttribute::set_Prop1(int32)
-      .get instance int32 ReferenceAssembly/MyAttribute::get_Prop1()
-    } 
     .property instance int32 Prop1()
     {
       .set instance void ReferenceAssembly/MySecondaryAttribute::set_Prop1(int32)
@@ -767,6 +876,10 @@ type Person(name : string, age : int) =
       IL_0001:  throw
     }
 
+    .property instance bool Something()
+    {
+      .get instance bool ReferenceAssembly/CustomAttribute::get_Something()
+    }
   }
 
   .class auto ansi serializable nested public Person
@@ -827,10 +940,6 @@ type Person(name : string, age : int) =
       IL_0001:  throw
     }
 
-    .property instance bool Something()
-    {
-      .get instance bool ReferenceAssembly/CustomAttribute::get_Something()
-    }
     .property instance string Name()
     {
       .custom instance void ReferenceAssembly/CustomAttribute::.ctor(bool) = ( 01 00 01 00 00 )
diff --git a/tests/fsharp/FSharpSuite.Tests.fsproj b/tests/fsharp/FSharpSuite.Tests.fsproj
index 2ef59aaec06..d9b02982c8f 100644
--- a/tests/fsharp/FSharpSuite.Tests.fsproj
+++ b/tests/fsharp/FSharpSuite.Tests.fsproj
@@ -118,6 +118,7 @@
     <PackageReference Include="System.Collections.Immutable" Version="$(SystemCollectionsImmutableVersion)" />
     <PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
     <PackageReference Include="System.Reflection.Metadata" Version="$(SystemReflectionMetadataVersion)" />
+    <PackageReference Include="Microsoft.CodeAnalysis.Workspaces.Common" Version="$(MicrosoftCodeAnalysisVersion)" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="$(MicrosoftCodeAnalysisCSharpVersion)" />
     <PackageReference Include="Microsoft.CodeAnalysis.Test.Resources.Proprietary" Version="$(MicrosoftCodeAnalysisTestResourcesProprietaryVersion)" />
   </ItemGroup>
diff --git a/tests/fsharp/TestHelpers.fs b/tests/fsharp/TestHelpers.fs
deleted file mode 100644
index f6b17da6c06..00000000000
--- a/tests/fsharp/TestHelpers.fs
+++ /dev/null
@@ -1,47 +0,0 @@
-module Tests.TestHelpers
-open System.IO
-
-let assembleDiffMessage actual expected =
-  
-    let getLines text =
-        use reader = new StringReader(text)
-        Seq.initInfinite (fun _ -> reader.ReadLine()) 
-        |> Seq.takeWhile (not << isNull)
-        |> set
-    let actual   = getLines actual  
-    let expected = getLines expected
-    //
-    // Find types/members which exist in exactly one of the expected or actual surface areas.
-    //
-
-    /// Surface area types/members which were expected to be found but missing from the actual surface area.
-    let unexpectedlyMissing = Set.difference expected actual
-
-    /// Surface area types/members present in the actual surface area but weren't expected to be.
-    let unexpectedlyPresent = Set.difference actual expected
-
-    // If both sets are empty, the surface areas match so allow the test to pass.
-    if Set.isEmpty unexpectedlyMissing
-      && Set.isEmpty unexpectedlyPresent then
-        None
-    else
-        // The surface areas don't match; prepare an easily-readable output message.
-        let msg =
-            let inline newLine (sb : System.Text.StringBuilder) = sb.AppendLine () |> ignore
-            let sb = System.Text.StringBuilder ()
-            sb.Append "Unexpectedly missing (expected, not actual):" |> ignore
-            for s in unexpectedlyMissing do
-                newLine sb
-                sb.Append "    " |> ignore
-                sb.Append s |> ignore
-            newLine sb
-            newLine sb
-            sb.Append "Unexpectedly present (actual, not expected):" |> ignore
-            for s in unexpectedlyPresent do
-                newLine sb
-                sb.Append "    " |> ignore
-                sb.Append s |> ignore
-            newLine sb
-            sb.ToString ()
-
-        Some msg
\ No newline at end of file
diff --git a/tests/fsharp/core/printing/output.multiemit.stderr.bsl b/tests/fsharp/core/printing/output.multiemit.stderr.bsl
index 68785a152df..6926dcc9f34 100644
--- a/tests/fsharp/core/printing/output.multiemit.stderr.bsl
+++ b/tests/fsharp/core/printing/output.multiemit.stderr.bsl
@@ -346,21 +346,3 @@ stdin(838,6): error FS1210: Active pattern '|A|B|' has a result type containing
 
 stdin(844,6): error FS1209: Active pattern '|A|B|' is not a function
 
-
-  let internal f() = 1;; f();; // should give a warning in multi-assembly interactive emit
-  -----------------------^^^
-
-stdin(1089,24): warning FS2303: Accessing the internal type, method or field 'f' from a previous evaluation in F# Interactive is deprecated and may cause subsequent access errors. To enable the legacy generation of a single dynamic assembly that can access internals, use the '--multiemit-' option.
-
-
-  CPublic().MInternal();; // should give a warning in multi-assembly interactive emit
-  ^^^^^^^^^^^^^^^^^^^^^
-
-stdin(1099,1): warning FS2303: Accessing the internal type, method or field 'MInternal' from a previous evaluation in F# Interactive is deprecated and may cause subsequent access errors. To enable the legacy generation of a single dynamic assembly that can access internals, use the '--multiemit-' option.
-
-
-  CPublic2().MPublic();; // should give a warning in multi-assembly interactive emit
-  ^^^^^^^^^^^^^^^^^^^^
-
-stdin(1105,1): warning FS2303: Accessing the internal type, method or field 'MPublic' from a previous evaluation in F# Interactive is deprecated and may cause subsequent access errors. To enable the legacy generation of a single dynamic assembly that can access internals, use the '--multiemit-' option.
-
diff --git a/tests/fsharpqa/Source/CompilerOptions/fsc/gccerrors/env.lst b/tests/fsharpqa/Source/CompilerOptions/fsc/gccerrors/env.lst
index e45bfc18344..f66e0766f85 100644
--- a/tests/fsharpqa/Source/CompilerOptions/fsc/gccerrors/env.lst
+++ b/tests/fsharpqa/Source/CompilerOptions/fsc/gccerrors/env.lst
@@ -1 +1 @@
-ReqENU	SOURCE=gccerrors01.fs COMPILE_ONLY=1 SCFLAGS="--gccerrors --nologo gccerrors01.fs >gccerrors01.txt" POSTCMD="\$FSI_PIPE --nologo --quiet --exec ..\\..\\..\\comparer.fsx gccerrors01.txt gccerrors01.bsl"	
+ReqENU	SOURCE=gccerrors01.fs COMPILE_ONLY=1 SCFLAGS="--gccerrors --nologo >gccerrors01.txt" POSTCMD="\$FSI_PIPE --nologo --quiet --exec ..\\..\\..\\comparer.fsx gccerrors01.txt gccerrors01.bsl"	
diff --git a/tests/fsharpqa/Source/CompilerOptions/fsi/exename/help40.437.1033.bsl b/tests/fsharpqa/Source/CompilerOptions/fsi/exename/help40.437.1033.bsl
index 623a47f3f1a..230f80b709e 100644
--- a/tests/fsharpqa/Source/CompilerOptions/fsi/exename/help40.437.1033.bsl
+++ b/tests/fsharpqa/Source/CompilerOptions/fsi/exename/help40.437.1033.bsl
@@ -107,5 +107,5 @@ Usage: fsharpi <options> [script.fsx [<arguments>]]
 --quotations-debug[+|-]                  Emit debug information in quotations
 --shadowcopyreferences[+|-]              Prevents references from being
                                          locked by the F# Interactive process
---multiemit[+|-]                         Emit multiple assemblies (off by
-                                         default for .NET Framework)
\ No newline at end of file
+--multiemit[+|-]                         Emit multiple assemblies (on by
+                                         default)
\ No newline at end of file
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 c52df3651b3..b0d97ddcd12 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
@@ -107,5 +107,5 @@ Usage: fsiAnyCpu <options> [script.fsx [<arguments>]]
 --quotations-debug[+|-]                  Emit debug information in quotations
 --shadowcopyreferences[+|-]              Prevents references from being
                                          locked by the F# Interactive process
---multiemit[+|-]                         Emit multiple assemblies (off by
-                                         default for .NET Framework)
\ No newline at end of file
+--multiemit[+|-]                         Emit multiple assemblies (on by
+                                         default)
\ No newline at end of file
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 0da770a2436..e95a139b5fb 100644
--- a/tests/fsharpqa/Source/CompilerOptions/fsi/help/help40.437.1033.bsl
+++ b/tests/fsharpqa/Source/CompilerOptions/fsi/help/help40.437.1033.bsl
@@ -109,5 +109,5 @@ Usage: fsiAnyCpu <options> [script.fsx [<arguments>]]
 --quotations-debug[+|-]                  Emit debug information in quotations
 --shadowcopyreferences[+|-]              Prevents references from being
                                          locked by the F# Interactive process
---multiemit[+|-]                         Emit multiple assemblies (off by
-                                         default for .NET Framework)
\ No newline at end of file
+--multiemit[+|-]                         Emit multiple assemblies (on by
+                                         default)
\ No newline at end of file
diff --git a/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/EnumTypes/E_BoolUnderlyingType.fs b/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/EnumTypes/E_BoolUnderlyingType.fs
index 3ac06c6252b..72ca7f38a43 100644
--- a/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/EnumTypes/E_BoolUnderlyingType.fs
+++ b/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/EnumTypes/E_BoolUnderlyingType.fs
@@ -3,7 +3,7 @@
 // Test errors related to enums of invalid primitive/built-in types
 
 
-//<Expects id="FS0010" status="error">Unexpected keyword 'true' in union case</Expects>
+//<Expects id="FS0951" status="error">Literal enumerations must have type int, uint, int16, uint16, int64, uint64, byte, sbyte or char</Expects>
 
 type EnumOfBool = 
     | A = true
diff --git a/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/EnumTypes/E_DiscrimnantOfDifferentTypes.fs b/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/EnumTypes/E_DiscrimnantOfDifferentTypes.fs
index 5b5f674afeb..4d4220df500 100644
--- a/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/EnumTypes/E_DiscrimnantOfDifferentTypes.fs
+++ b/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/EnumTypes/E_DiscrimnantOfDifferentTypes.fs
@@ -1,7 +1,7 @@
 // #Regression #Conformance #ObjectOrientedTypes #Enums 
 // Verify that you cannot mix underlying types
 
-//<Expects id="FS0001" status="error" span="(8,7-8,13)">This expression was expected to have type.    'int'    .but here has type.    'int64'</Expects>
+//<Expects id="FS0001" status="error" span="(8,11-8,13)">This expression was expected to have type.    'int'    .but here has type.    'int64'</Expects>
 
 type EnumType = 
     | D = 3
diff --git a/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/EnumTypes/E_NonInt32Enums01.fs b/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/EnumTypes/E_NonInt32Enums01.fs
index a2633f7bafb..1fe862f08c0 100644
--- a/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/EnumTypes/E_NonInt32Enums01.fs
+++ b/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/EnumTypes/E_NonInt32Enums01.fs
@@ -4,8 +4,8 @@
 
 
 //<Expects id="FS0951" span="(19,5-20,16)" status="error">Literal enumerations must have type int, uint, int16, uint16, int64, uint64, byte, sbyte or char</Expects>
-//<Expects id="FS0886" span="(23,7-23,13)" status="error">This is not a valid value for an enumeration literal</Expects>
-//<Expects id="FS0886" span="(27,7-27,13)" status="error">This is not a valid value for an enumeration literal</Expects>
+//<Expects id="FS0886" span="(23,11-23,13)" status="error">This is not a valid value for an enumeration literal</Expects>
+//<Expects id="FS0886" span="(27,11-27,13)" status="error">This is not a valid value for an enumeration literal</Expects>
 //<Expects id="FS0951" span="(32,5-33,13)" status="error">Literal enumerations must have type int, uint, int16, uint16, int64, uint64, byte, sbyte or char</Expects>
 //<Expects id="FS0951" span="(37,5-38,14)" status="error">Literal enumerations must have type int, uint, int16, uint16, int64, uint64, byte, sbyte or char</Expects>
 //<Expects id="FS0951" span="(41,5-42,15)" status="error">Literal enumerations must have type int, uint, int16, uint16, int64, uint64, byte, sbyte or char</Expects>
diff --git a/tests/fsharpqa/Source/Diagnostics/General/E_LiteralEnumerationMustHaveType01.fs b/tests/fsharpqa/Source/Diagnostics/General/E_LiteralEnumerationMustHaveType01.fs
index 19e941aa0d8..4de07d35eb2 100644
--- a/tests/fsharpqa/Source/Diagnostics/General/E_LiteralEnumerationMustHaveType01.fs
+++ b/tests/fsharpqa/Source/Diagnostics/General/E_LiteralEnumerationMustHaveType01.fs
@@ -1,8 +1,8 @@
 // #Regression #Diagnostics 
 // Regression test for FSHARP1.0:1729
 // Notice that the bug was in the IDE, but a compiler test is equally useful.
-//<Expects id="FS0886" span="(10,7-10,13)" status="error">This is not a valid value for an enumeration literal</Expects>
-//<Expects id="FS0886" span="(14,7-14,13)" status="error">This is not a valid value for an enumeration literal</Expects>
+//<Expects id="FS0886" span="(10,11-10,13)" status="error">This is not a valid value for an enumeration literal</Expects>
+//<Expects id="FS0886" span="(14,11-14,13)" status="error">This is not a valid value for an enumeration literal</Expects>
 #light
 
 // Shouldn't work    
diff --git a/tests/fsharpqa/Source/InteractiveSession/Misc/E_InheritClassWithoutDefCtor.fs b/tests/fsharpqa/Source/InteractiveSession/Misc/E_InheritClassWithoutDefCtor.fs
deleted file mode 100644
index 8fb0dc6abd8..00000000000
--- a/tests/fsharpqa/Source/InteractiveSession/Misc/E_InheritClassWithoutDefCtor.fs
+++ /dev/null
@@ -1,19 +0,0 @@
-// #Regression #NoMT #FSI 
-// Regression test for FSharp1.0:1626 - Classes without constructors can't be emitted by Reflection.Emit. This causes late error in compilation
-// <Expects id="FS0193" status="error">Parent does not have a default constructor\. The default constructor must be explicitly defined</Expects>
-
-type B = class
-
-  new(a:int) = {}
-
-end
-
-type C = class
-  inherit B
-end
-
-#if INTERACTIVE
-;;
-exit 1;;
-#endif
-
diff --git a/tests/fsharpqa/Source/InteractiveSession/Misc/env.lst b/tests/fsharpqa/Source/InteractiveSession/Misc/env.lst
index c3cf858c21b..ef48ada5cfa 100644
--- a/tests/fsharpqa/Source/InteractiveSession/Misc/env.lst
+++ b/tests/fsharpqa/Source/InteractiveSession/Misc/env.lst
@@ -74,8 +74,6 @@ NOMONO	SOURCE=References40.fsx COMPILE_ONLY=1 FSIMODE=PIPE SCFLAGS="--nologo"	#
 	SOURCE=DefinesCompiled.fs												# DefinesCompiled
 
 	SOURCE=E_ErrorRanges01.fs COMPILE_ONLY=1 FSIMODE=PIPE					# E_ErrorRanges01.fs
-	SOURCE=E_InheritClassWithoutDefCtor.fs COMPILE_ONLY=1 FSIMODE=PIPE			# E_InheritClassWithoutDefCtor.fs
-    
 	SOURCE=DoWithNotUnit.fs COMPILE_ONLY=1 FSIMODE=PIPE					# DoWithNotUnit.fs
 	SOURCE=LoadingFsx.fsx COMPILE_ONLY=1 FSIMODE=PIPE SCFLAGS="--test:ErrorRanges"	# LoadingFsx.fsx
 	SOURCE=LoadingFsx.fsscript COMPILE_ONLY=1 FSIMODE=PIPE SCFLAGS="--test:ErrorRanges"	# LoadingFsx.fsscript
diff --git a/tests/fsharpqa/Source/test.lst b/tests/fsharpqa/Source/test.lst
index e72cbd11612..2c9482e2461 100644
--- a/tests/fsharpqa/Source/test.lst
+++ b/tests/fsharpqa/Source/test.lst
@@ -10,7 +10,7 @@ CompilerOptions01,NoMT				CompilerOptions\fsc\crossoptimize
 CompilerOptions01,NoMT,Determinism  CompilerOptions\fsc\determinism
 CompilerOptions01,NoMT				CompilerOptions\fsc\dumpAllCommandLineOptions
 CompilerOptions01,NoMT				CompilerOptions\fsc\flaterrors
-CompilerOptions02,NoMT				CompilerOptions\fsc\gccerrors
+CompilerOptions02,NoMT,gcc			CompilerOptions\fsc\gccerrors
 CompilerOptions01,NoMT,help			CompilerOptions\fsc\help
 CompilerOptions01,NoMT				CompilerOptions\fsc\highentropyva
 CompilerOptions01,NoMT				CompilerOptions\fsc\langversion
diff --git a/tests/projects/SelfContained_Trimming_Test/check.ps1 b/tests/projects/SelfContained_Trimming_Test/check.ps1
index fbc122b4158..388ed50ae7e 100644
--- a/tests/projects/SelfContained_Trimming_Test/check.ps1
+++ b/tests/projects/SelfContained_Trimming_Test/check.ps1
@@ -14,7 +14,7 @@ if (-not ($output -eq $expected))
 }
 
 # Checking that FSharp.Core binary is of expected size (needs adjustments if test is updated).
-$expected_len = 245248 # In bytes
+$expected_len = 246272  # In bytes
 $file = Get-Item .\bin\Release\net7.0\win-x64\publish\FSharp.Core.dll
 $file_len = $file.Length
 if (-not ($file_len -eq $expected_len))
diff --git a/tests/service/ExprTests.fs b/tests/service/ExprTests.fs
index 02a62ba5b99..6363622eb11 100644
--- a/tests/service/ExprTests.fs
+++ b/tests/service/ExprTests.fs
@@ -722,6 +722,13 @@ let test{0}ToStringOperator   (e1:{1}) = string e1
 
 """
 
+let ignoreTestIfStackOverflowExpected () =
+#if !NETFRAMEWORK && DEBUG
+    Assert.Ignore("Test is known to fail in DEBUG when not using NetFramework. Use RELEASE configuration or NetFramework to run it.")
+#else
+    ()
+#endif
+
 /// This test is run in unison with its optimized counterpart below
 [<Test>]
 let ``Test Unoptimized Declarations Project1`` () =
@@ -3191,6 +3198,7 @@ let BigSequenceExpression(outFileOpt,docFileOpt,baseAddressOpt) =
 
 [<Test>]
 let ``Test expressions of declarations stress big expressions`` () =
+    ignoreTestIfStackOverflowExpected ()
     let cleanup, options = ProjectStressBigExpressions.createOptions()
     use _holder = cleanup
     let exprChecker = FSharpChecker.Create(keepAssemblyContents=true)
@@ -3207,6 +3215,7 @@ let ``Test expressions of declarations stress big expressions`` () =
 
 [<Test>]
 let ``Test expressions of optimized declarations stress big expressions`` () =
+    ignoreTestIfStackOverflowExpected ()
     let cleanup, options = ProjectStressBigExpressions.createOptions()
     use _holder = cleanup
     let exprChecker = FSharpChecker.Create(keepAssemblyContents=true)
diff --git a/tests/service/ScriptOptionsTests.fs b/tests/service/ScriptOptionsTests.fs
index a533d7ac4c8..998120a81d4 100644
--- a/tests/service/ScriptOptionsTests.fs
+++ b/tests/service/ScriptOptionsTests.fs
@@ -24,11 +24,12 @@ let pi = Math.PI
 """
 
 [<TestCase(true, false, [| "--targetprofile:mscorlib" |])>]
+[<TestCase(false, false, [| "--targetprofile:netcore" |])>]
 [<TestCase(false, true, [| "--targetprofile:netcore" |])>]
 [<Test>]
 let ``can generate options for different frameworks regardless of execution environment``(assumeNetFx, useSdk, flags) =
     let path = Path.GetTempPath()
-    let file = tryCreateTemporaryFileName ()
+    let file = tryCreateTemporaryFileName () + ".fsx"
     let tempFile = Path.Combine(path, file)
     let _, errors =
         checker.GetProjectOptionsFromScript(tempFile, SourceText.ofString scriptSource, assumeDotNetFramework = assumeNetFx, useSdkRefs = useSdk, otherFlags = flags)
@@ -37,6 +38,32 @@ let ``can generate options for different frameworks regardless of execution envi
     | [] -> ()
     | errors -> failwithf "Error while parsing script with assumeDotNetFramework:%b, useSdkRefs:%b, and otherFlags:%A:\n%A" assumeNetFx useSdk flags errors
 
+#if NETFRAMEWORK
+// See https://github.com/dotnet/fsharp/pull/13994#issuecomment-1259663865
+//
+// .NET Core-based tooling can't resolve nuget packages to .NET Framework references
+[<TestCase(true, false, [| "--targetprofile:mscorlib" |])>]
+#endif
+[<TestCase(false, true, [| "--targetprofile:netcore" |])>]
+[<Test>]
+let ``can resolve nuget packages to right target framework for different frameworks regardless of execution environment``(assumeNetFx, useSdk, flags) =
+    let path = Path.GetTempPath()
+    let file = tryCreateTemporaryFileName () + ".fsx"
+    let tempFile = Path.Combine(path, file)
+    let scriptSource = """
+#r "nuget: FSharp.Data, 3.3.3"
+open System
+let pi = Math.PI
+"""
+    let options, errors =
+        checker.GetProjectOptionsFromScript(tempFile, SourceText.ofString scriptSource, assumeDotNetFramework = assumeNetFx, useSdkRefs = useSdk, otherFlags = flags)
+        |> Async.RunImmediate
+    match errors with
+    | [] -> ()
+    | errors -> failwithf "Error while parsing script with assumeDotNetFramework:%b, useSdkRefs:%b, and otherFlags:%A:\n%A" assumeNetFx useSdk flags errors
+    let expectedReferenceText = (if assumeNetFx then "net45" else "netstandard2.0")
+    let found = options.OtherOptions |> Array.exists (fun s -> s.Contains(expectedReferenceText) && s.Contains("FSharp.Data.dll"))
+    Assert.IsTrue(found)
 
 // This test atempts to use a bad SDK number 666.666.666
 //
diff --git a/tests/service/SyntaxTreeTests/BindingTests.fs b/tests/service/SyntaxTreeTests/BindingTests.fs
index e2afdfd7f93..ef6efe22230 100644
--- a/tests/service/SyntaxTreeTests/BindingTests.fs
+++ b/tests/service/SyntaxTreeTests/BindingTests.fs
@@ -439,3 +439,44 @@ type X =
         assertRange (3,28) (3,29) mColon1
         assertRange (3,52) (3,53) mColon2
     | _ -> Assert.Fail $"Could not get valid AST, got {parseResults}"
+
+[<Test>]
+let ``Inline keyword in binding`` () =
+    let parseResults = 
+        getParseResults """
+let inline x y z =
+    let inline a b c = ()
+    ()
+"""
+
+    match parseResults with
+    | ParsedInput.ImplFile (ParsedImplFileInput (contents = [ SynModuleOrNamespace.SynModuleOrNamespace(decls = [
+        SynModuleDecl.Let(bindings = [
+            SynBinding(trivia = { InlineKeyword = Some mInline1 }
+                       expr = SynExpr.LetOrUse(bindings = [
+                           SynBinding(trivia = { InlineKeyword = Some mInline2 })
+                       ]))
+        ])
+    ]) ])) ->
+        assertRange (2,4) (2,10) mInline1
+        assertRange (3,8) (3,14) mInline2
+    | _ -> Assert.Fail $"Could not get valid AST, got {parseResults}"
+
+[<Test>]
+let ``Conditional directive around inline keyword`` () =
+    let parseResults = 
+        getParseResults """
+let 
+#if !FOO
+    inline
+#endif
+    map f ar = Async.map (Result.map f) ar
+"""
+
+    match parseResults with
+    | ParsedInput.ImplFile (ParsedImplFileInput (contents = [ SynModuleOrNamespace.SynModuleOrNamespace(decls = [
+        SynModuleDecl.Let(bindings = [
+            SynBinding(trivia = { InlineKeyword = Some mInline }) ])
+    ]) ])) ->
+        assertRange (4,4) (4,10) mInline
+    | _ -> Assert.Fail $"Could not get valid AST, got {parseResults}"
diff --git a/tests/service/SyntaxTreeTests/MemberTests.fs b/tests/service/SyntaxTreeTests/MemberTests.fs
index 3533a4e69b4..2cd0eaafa4e 100644
--- a/tests/service/SyntaxTreeTests/MemberTests.fs
+++ b/tests/service/SyntaxTreeTests/MemberTests.fs
@@ -315,3 +315,50 @@ type X =
         assertRange (7, 20) (7, 24) mWith
         assertRange (8, 32) (8, 35) mGet
     | _ -> Assert.Fail "Could not get valid AST"
+
+[<Test>]
+let ``Member with inline keyword`` () =
+    let parseResults = 
+        getParseResults
+            """
+type X =
+    member inline x.Y () = ()
+"""
+
+    match parseResults with
+    | ParsedInput.ImplFile (ParsedImplFileInput (contents = [ SynModuleOrNamespace.SynModuleOrNamespace(decls = [
+        SynModuleDecl.Types(
+            typeDefns = [ SynTypeDefn(typeRepr = SynTypeDefnRepr.ObjectModel(members = [
+                SynMemberDefn.Member(memberDefn = SynBinding(trivia = { InlineKeyword = Some mInline }))
+            ])) ]
+        )
+    ]) ])) ->
+        assertRange (3, 11) (3, 17) mInline
+    | ast -> Assert.Fail $"Could not get valid AST, got {ast}"
+
+[<Test>]
+let ``Get/Set member with inline keyword`` () =
+    let parseResults = 
+        getParseResults
+            """
+type X =
+    member inline x.Y 
+        with inline get () = 4
+        and inline set y = ()
+"""
+
+    match parseResults with
+    | ParsedInput.ImplFile (ParsedImplFileInput (contents = [ SynModuleOrNamespace.SynModuleOrNamespace(decls = [
+        SynModuleDecl.Types(
+            typeDefns = [ SynTypeDefn(typeRepr = SynTypeDefnRepr.ObjectModel(members = [
+                SynMemberDefn.GetSetMember(Some (SynBinding(trivia = { InlineKeyword = Some mInlineGet })),
+                                           Some (SynBinding(trivia = { InlineKeyword = Some mInlineSet })),
+                                           _,
+                                           { InlineKeyword = Some mInlineGetSetMember })
+            ])) ]
+        )
+    ]) ])) ->
+        assertRange (3, 11) (3, 17) mInlineGetSetMember
+        assertRange (4, 13) (4, 19) mInlineGet
+        assertRange (5, 12) (5, 18) mInlineSet
+    | ast -> Assert.Fail $"Could not get valid AST, got {ast}"
diff --git a/tests/service/SyntaxTreeTests/TypeTests.fs b/tests/service/SyntaxTreeTests/TypeTests.fs
index 22df4ec8806..37fe10678fc 100644
--- a/tests/service/SyntaxTreeTests/TypeTests.fs
+++ b/tests/service/SyntaxTreeTests/TypeTests.fs
@@ -17,9 +17,9 @@ type Foo = One = 0x00000001
     | ParsedInput.ImplFile (ParsedImplFileInput (contents = [ SynModuleOrNamespace.SynModuleOrNamespace(decls = [
         SynModuleDecl.Types(typeDefns = [
             SynTypeDefn.SynTypeDefn(typeRepr =
-                SynTypeDefnRepr.Simple(simpleRepr = SynTypeDefnSimpleRepr.Enum(cases = [ SynEnumCase.SynEnumCase(valueRange = r) ])))])
+                SynTypeDefnRepr.Simple(simpleRepr = SynTypeDefnSimpleRepr.Enum(cases = [ SynEnumCase.SynEnumCase(valueExpr = e) ])))])
     ]) ])) ->
-        assertRange (2, 17) (2, 27) r
+        assertRange (2, 17) (2, 27) e.Range
     | _ -> Assert.Fail "Could not get valid AST"
     
 [<Test>]
@@ -36,11 +36,11 @@ type Foo =
     | ParsedInput.ImplFile (ParsedImplFileInput (contents = [ SynModuleOrNamespace.SynModuleOrNamespace(decls = [
         SynModuleDecl.Types(typeDefns = [
             SynTypeDefn.SynTypeDefn(typeRepr =
-                SynTypeDefnRepr.Simple(simpleRepr = SynTypeDefnSimpleRepr.Enum(cases = [ SynEnumCase.SynEnumCase(valueRange = r1)
-                                                                                         SynEnumCase.SynEnumCase(valueRange = r2) ])))])
+                SynTypeDefnRepr.Simple(simpleRepr = SynTypeDefnSimpleRepr.Enum(cases = [ SynEnumCase.SynEnumCase(valueExpr = e1)
+                                                                                         SynEnumCase.SynEnumCase(valueExpr = e2) ])))])
     ]) ])) ->
-        assertRange (3, 13) (3, 23) r1
-        assertRange (4, 12) (4, 13) r2
+        assertRange (3, 13) (3, 23) e1.Range
+        assertRange (4, 12) (4, 13) e2.Range
     | _ -> Assert.Fail "Could not get valid AST"
 
 [<Test>]
diff --git a/tests/service/SyntaxTreeTests/ValTests.fs b/tests/service/SyntaxTreeTests/ValTests.fs
new file mode 100644
index 00000000000..c14415bad6e
--- /dev/null
+++ b/tests/service/SyntaxTreeTests/ValTests.fs
@@ -0,0 +1,20 @@
+module FSharp.Compiler.Service.Tests.SyntaxTreeTests.ValTests
+
+open FSharp.Compiler.Service.Tests.Common
+open FSharp.Compiler.Syntax
+open FSharp.Compiler.SyntaxTrivia
+open NUnit.Framework
+
+[<Test>]
+let ``Inline keyword`` () =
+    let parseResults = 
+        getParseResultsOfSignatureFile
+            """namespace X
+
+val inline meh: int -> int"""
+
+    match parseResults with
+    | ParsedInput.SigFile (ParsedSigFileInput (contents = [
+        SynModuleOrNamespaceSig(decls = [SynModuleSigDecl.Val(valSig = SynValSig(trivia = { InlineKeyword = Some mInline }))]) ])) ->
+        assertRange (3, 4) (3,10) mInline
+    | ast -> Assert.Fail $"Could not get valid AST, got {ast}"
diff --git a/tests/service/TreeVisitorTests.fs b/tests/service/TreeVisitorTests.fs
index 9bcfa47796a..91ac5d99a47 100644
--- a/tests/service/TreeVisitorTests.fs
+++ b/tests/service/TreeVisitorTests.fs
@@ -57,5 +57,21 @@ let ``Visit enum definition test`` () =
     let parseTree = parseSourceCode("C:\\test.fs", source)
 
     match SyntaxTraversal.Traverse(pos0, parseTree, visitor) with
-    | Some [ SynEnumCase (_, SynIdent(id1,_), _, _, _, _, _); SynEnumCase (_, SynIdent(id2,_), _, _, _, _, _) ] when id1.idText = "A" && id2.idText = "B" -> ()
-    | _ -> failwith "Did not visit enum definition"
\ No newline at end of file
+    | Some [ SynEnumCase (ident = SynIdent (id1, _)); SynEnumCase (ident = SynIdent (id2, _)) ] when id1.idText = "A" && id2.idText = "B" -> ()
+    | _ -> failwith "Did not visit enum definition"
+
+[<Test>]
+let ``Visit recursive let binding`` () =
+    let visitor =
+        { new SyntaxVisitorBase<_>() with
+            member x.VisitExpr(_, _, defaultTraverse, expr) = defaultTraverse expr
+            member x.VisitLetOrUse(_, isRecursive, _, bindings, _) =
+                if not isRecursive then failwith $"{nameof isRecursive} should be true"
+                Some bindings }
+
+    let source = "let rec fib n = if n < 2 then n else fib (n - 1) + fib (n - 2) in fib 10"
+    let parseTree = parseSourceCode("C:\\test.fs", source)
+
+    match SyntaxTraversal.Traverse(pos0, parseTree, visitor) with
+    | Some [ SynBinding(valData = SynValData(valInfo = SynValInfo(curriedArgInfos = [ [ SynArgInfo(ident = Some id) ] ]))) ] when id.idText = "n" -> ()
+    | _ -> failwith "Did not visit recursive let binding"
\ No newline at end of file
diff --git a/vsintegration/ProjectTemplates/ConsoleProject/Template/ConsoleApplication.fsproj b/vsintegration/ProjectTemplates/ConsoleProject/Template/ConsoleApplication.fsproj
index ee7baed3960..69e263ef225 100644
--- a/vsintegration/ProjectTemplates/ConsoleProject/Template/ConsoleApplication.fsproj
+++ b/vsintegration/ProjectTemplates/ConsoleProject/Template/ConsoleApplication.fsproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-$if$ ($targetframeworkversion$ == 4.5)    <TargetFramework>net45</TargetFramework>$endif$$if$ ($targetframeworkversion$ == 4.6)    <TargetFramework>net46</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.6.1)    <TargetFramework>net461</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.6.2)    <TargetFramework>net462</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.7)    <TargetFramework>net47</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.7.1)    <TargetFramework>net471</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.7.2)    <TargetFramework>net472</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.8)    <TargetFramework>net48</TargetFramework> $endif$
+$if$ ($targetframeworkversion$ == 4.5)    <TargetFramework>net45</TargetFramework>$endif$$if$ ($targetframeworkversion$ == 4.5.2)    <TargetFramework>net452</TargetFramework>$endif$$if$ ($targetframeworkversion$ == 4.5)    <TargetFramework>net45</TargetFramework>$endif$$if$ ($targetframeworkversion$ == 4.6)    <TargetFramework>net46</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.6.1)    <TargetFramework>net461</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.6.2)    <TargetFramework>net462</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.7)    <TargetFramework>net47</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.7.1)    <TargetFramework>net471</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.7.2)    <TargetFramework>net472</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.8)    <TargetFramework>net48</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.8.1)    <TargetFramework>net481</TargetFramework> $endif$
 $if$ ($safeprojectname$ != $projectname$)    <RootNamespace>$safeprojectname$</RootNamespace> $endif$
     <WarnOn>3390;$(WarnOn)</WarnOn>
   </PropertyGroup>
diff --git a/vsintegration/ProjectTemplates/LibraryProject/Template/Library.fsproj b/vsintegration/ProjectTemplates/LibraryProject/Template/Library.fsproj
index 736dff548d6..b4e52928dd3 100644
--- a/vsintegration/ProjectTemplates/LibraryProject/Template/Library.fsproj
+++ b/vsintegration/ProjectTemplates/LibraryProject/Template/Library.fsproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-$if$ ($targetframeworkversion$ == 4.5)    <TargetFramework>net45</TargetFramework>$endif$$if$ ($targetframeworkversion$ == 4.6)    <TargetFramework>net46</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.6.1)    <TargetFramework>net461</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.6.2)    <TargetFramework>net462</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.7)    <TargetFramework>net47</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.7.1)    <TargetFramework>net471</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.7.2)    <TargetFramework>net472</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.8)    <TargetFramework>net48</TargetFramework> $endif$
+$if$ ($targetframeworkversion$ == 4.5)    <TargetFramework>net45</TargetFramework>$endif$$if$ ($targetframeworkversion$ == 4.5.2)    <TargetFramework>net452</TargetFramework>$endif$$if$ ($targetframeworkversion$ == 4.5)    <TargetFramework>net45</TargetFramework>$endif$$if$ ($targetframeworkversion$ == 4.6)    <TargetFramework>net46</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.6.1)    <TargetFramework>net461</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.6.2)    <TargetFramework>net462</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.7)    <TargetFramework>net47</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.7.1)    <TargetFramework>net471</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.7.2)    <TargetFramework>net472</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.8)    <TargetFramework>net48</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.8.1)    <TargetFramework>net481</TargetFramework> $endif$
 $if$ ($safeprojectname$ != $projectname$)    <RootNamespace>$safeprojectname$</RootNamespace> $endif$
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <WarnOn>3390;$(WarnOn)</WarnOn>
diff --git a/vsintegration/ProjectTemplates/TutorialProject/Template/Tutorial.fsproj b/vsintegration/ProjectTemplates/TutorialProject/Template/Tutorial.fsproj
index 83103261b80..ed267649aa7 100644
--- a/vsintegration/ProjectTemplates/TutorialProject/Template/Tutorial.fsproj
+++ b/vsintegration/ProjectTemplates/TutorialProject/Template/Tutorial.fsproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-$if$ ($targetframeworkversion$ == 4.5)    <TargetFramework>net45</TargetFramework>$endif$$if$ ($targetframeworkversion$ == 4.6)    <TargetFramework>net46</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.6.1)    <TargetFramework>net461</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.6.2)    <TargetFramework>net462</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.7)    <TargetFramework>net47</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.7.1)    <TargetFramework>net471</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.7.2)    <TargetFramework>net472</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.8)    <TargetFramework>net48</TargetFramework> $endif$
+$if$ ($targetframeworkversion$ == 4.5)    <TargetFramework>net45</TargetFramework>$endif$$if$ ($targetframeworkversion$ == 4.5.2)    <TargetFramework>net452</TargetFramework>$endif$$if$ ($targetframeworkversion$ == 4.5)    <TargetFramework>net45</TargetFramework>$endif$$if$ ($targetframeworkversion$ == 4.6)    <TargetFramework>net46</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.6.1)    <TargetFramework>net461</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.6.2)    <TargetFramework>net462</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.7)    <TargetFramework>net47</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.7.1)    <TargetFramework>net471</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.7.2)    <TargetFramework>net472</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.8)    <TargetFramework>net48</TargetFramework> $endif$$if$ ($targetframeworkversion$ == 4.8.1)    <TargetFramework>net481</TargetFramework> $endif$
 $if$ ($safeprojectname$ != $projectname$)    <RootNamespace>$safeprojectname$</RootNamespace> $endif$
     <WarnOn>3390;$(WarnOn)</WarnOn>
   </PropertyGroup>
diff --git a/vsintegration/src/FSharp.Editor/Common/CodeAnalysisExtensions.fs b/vsintegration/src/FSharp.Editor/Common/CodeAnalysisExtensions.fs
index 8f40f743507..0204315d8a4 100644
--- a/vsintegration/src/FSharp.Editor/Common/CodeAnalysisExtensions.fs
+++ b/vsintegration/src/FSharp.Editor/Common/CodeAnalysisExtensions.fs
@@ -41,14 +41,14 @@ type Solution with
             proj.Documents |> Seq.tryFind (fun doc -> doc.Name = docName))
 
 
-     /// Try to find the documentId corresponding to the provided filepath within this solution  
+     /// Try to find the document corresponding to the provided filepath within this solution  
     member self.TryGetDocumentFromPath filePath =
         // It's crucial to normalize file path here (specificaly, remove relative parts),
         // otherwise Roslyn does not find documents.
         self.GetDocumentIdsWithFilePath (Path.GetFullPath filePath)
         |> Seq.tryHead |> Option.map (fun docId -> self.GetDocument docId)
 
-    /// Try to find the documentId corresponding to the provided filepath and ProjectId within this solution  
+    /// Try to find the document corresponding to the provided filepath and ProjectId within this solution  
     member self.TryGetDocumentFromPath(filePath, projId: ProjectId) =
        // It's crucial to normalize file path here (specificaly, remove relative parts),
        // otherwise Roslyn does not find documents.
diff --git a/vsintegration/src/FSharp.Editor/Common/Pervasive.fs b/vsintegration/src/FSharp.Editor/Common/Pervasive.fs
index fc38c56885b..66fb92e6d04 100644
--- a/vsintegration/src/FSharp.Editor/Common/Pervasive.fs
+++ b/vsintegration/src/FSharp.Editor/Common/Pervasive.fs
@@ -200,4 +200,8 @@ module Async =
                     let! replyCh = agent.Receive ()
                     replyCh.Reply res 
             }
-        async { return! agent.PostAndAsyncReply id }
\ No newline at end of file
+        async { return! agent.PostAndAsyncReply id }
+
+let FSharpExperimentalFeaturesEnabledAutomatically =
+    String.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable("FSHARP_EXPERIMENTAL_FEATURES"))
+    |> not
\ No newline at end of file
diff --git a/vsintegration/src/FSharp.Editor/Diagnostics/DocumentDiagnosticAnalyzer.fs b/vsintegration/src/FSharp.Editor/Diagnostics/DocumentDiagnosticAnalyzer.fs
index 915fd0663e7..d3a40e61d06 100644
--- a/vsintegration/src/FSharp.Editor/Diagnostics/DocumentDiagnosticAnalyzer.fs
+++ b/vsintegration/src/FSharp.Editor/Diagnostics/DocumentDiagnosticAnalyzer.fs
@@ -68,7 +68,7 @@ type internal FSharpDocumentDiagnosticAnalyzer
                     match diagnosticType with
                     | DiagnosticsType.Semantic ->
                         let! _, checkResults = document.GetFSharpParseAndCheckResultsAsync("GetDiagnostics")
-                        // In order to eleminate duplicates, we should not return parse errors here because they are returned by `AnalyzeSyntaxAsync` method.
+                        // In order to eliminate duplicates, we should not return parse errors here because they are returned by `AnalyzeSyntaxAsync` method.
                         let allDiagnostics = HashSet(checkResults.Diagnostics, diagnosticEqualityComparer)
                         allDiagnostics.ExceptWith(parseResults.Diagnostics)
                         return Seq.toArray allDiagnostics
@@ -109,23 +109,15 @@ type internal FSharpDocumentDiagnosticAnalyzer
         member this.AnalyzeSyntaxAsync(document: Document, cancellationToken: CancellationToken): Task<ImmutableArray<Diagnostic>> =
             if document.Project.IsFSharpMetadata then Task.FromResult(ImmutableArray.Empty)
             else
-
-            asyncMaybe {
-                return! 
-                    FSharpDocumentDiagnosticAnalyzer.GetDiagnostics(document, DiagnosticsType.Syntax)
-                    |> liftAsync
-            } 
-            |> Async.map (Option.defaultValue ImmutableArray<Diagnostic>.Empty)
-            |> RoslynHelpers.StartAsyncAsTask cancellationToken
+                FSharpDocumentDiagnosticAnalyzer.GetDiagnostics(document, DiagnosticsType.Syntax)
+                |> liftAsync
+                |> Async.map (Option.defaultValue ImmutableArray<Diagnostic>.Empty)
+                |> RoslynHelpers.StartAsyncAsTask cancellationToken
 
         member this.AnalyzeSemanticsAsync(document: Document, cancellationToken: CancellationToken): Task<ImmutableArray<Diagnostic>> =
             if document.Project.IsFSharpMiscellaneousOrMetadata && not document.IsFSharpScript then Task.FromResult(ImmutableArray.Empty)
             else
-
-            asyncMaybe {
-                return! 
-                    FSharpDocumentDiagnosticAnalyzer.GetDiagnostics(document, DiagnosticsType.Semantic)
-                    |> liftAsync
-            }
-            |> Async.map (Option.defaultValue ImmutableArray<Diagnostic>.Empty)
-            |> RoslynHelpers.StartAsyncAsTask cancellationToken
+                FSharpDocumentDiagnosticAnalyzer.GetDiagnostics(document, DiagnosticsType.Semantic)
+                |> liftAsync
+                |> Async.map (Option.defaultValue ImmutableArray<Diagnostic>.Empty)
+                |> RoslynHelpers.StartAsyncAsTask cancellationToken
diff --git a/vsintegration/src/FSharp.Editor/FSharp.Editor.fsproj b/vsintegration/src/FSharp.Editor/FSharp.Editor.fsproj
index 7d75ba27ad8..de7e65c02f5 100644
--- a/vsintegration/src/FSharp.Editor/FSharp.Editor.fsproj
+++ b/vsintegration/src/FSharp.Editor/FSharp.Editor.fsproj
@@ -56,8 +56,8 @@
     <Compile Include="LanguageService\SingleFileWorkspaceMap.fs" />
     <Compile Include="LanguageService\LegacyProjectWorkspaceMap.fs" />
     <Compile Include="LanguageService\FSharpAnalysisSaveFileCommandHandler.fs" />
-    <Compile Include="LanguageService\LanguageService.fs" />
     <Compile Include="LanguageService\WorkspaceExtensions.fs" />
+    <Compile Include="LanguageService\LanguageService.fs" />
     <Compile Include="LanguageService\AssemblyContentProvider.fs" />
     <Compile Include="LanguageService\SymbolHelpers.fs" />
     <Compile Include="Classification\ClassificationDefinitions.fs" />
diff --git a/vsintegration/src/FSharp.Editor/FSharp.Editor.resx b/vsintegration/src/FSharp.Editor/FSharp.Editor.resx
index 9c8c315fe13..af946778b69 100644
--- a/vsintegration/src/FSharp.Editor/FSharp.Editor.resx
+++ b/vsintegration/src/FSharp.Editor/FSharp.Editor.resx
@@ -218,8 +218,10 @@ Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</value>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</value>
   </data>
   <data name="6014" xml:space="preserve">
     <value>Formatting</value>
diff --git a/vsintegration/src/FSharp.Editor/Hints/HintService.fs b/vsintegration/src/FSharp.Editor/Hints/HintService.fs
index 6b23fe78506..349ec56ee3e 100644
--- a/vsintegration/src/FSharp.Editor/Hints/HintService.fs
+++ b/vsintegration/src/FSharp.Editor/Hints/HintService.fs
@@ -3,47 +3,65 @@
 namespace Microsoft.VisualStudio.FSharp.Editor.Hints
 
 open Microsoft.CodeAnalysis
+open Microsoft.CodeAnalysis.Text
 open Microsoft.VisualStudio.FSharp.Editor
 open FSharp.Compiler.CodeAnalysis
 open FSharp.Compiler.Symbols
 open Hints
 
 module HintService =
-    let private getHintsForSymbol parseResults hintKinds (symbolUse: FSharpSymbolUse) =
-        match symbolUse.Symbol with
-        | :? FSharpMemberOrFunctionOrValue as symbol 
-          when hintKinds |> Set.contains HintKind.TypeHint 
-            && InlineTypeHints.isValidForHint parseResults symbol symbolUse ->
-            
-            InlineTypeHints.getHints symbol symbolUse
-        
-        | :? FSharpMemberOrFunctionOrValue as symbol
-          when hintKinds |> Set.contains HintKind.ParameterNameHint 
-            && InlineParameterNameHints.isMemberOrFunctionOrValueValidForHint symbol symbolUse ->
 
-            InlineParameterNameHints.getHintsForMemberOrFunctionOrValue parseResults symbol symbolUse
+    type private NativeHintResolver = FSharpSymbolUse seq -> NativeHint seq
+
+    let inline private getTypeHints parseResults symbol: NativeHintResolver =
+        Seq.filter (InlineTypeHints.isValidForHint parseResults symbol) 
+        >> Seq.collect (InlineTypeHints.getHints symbol)
 
-        | :? FSharpUnionCase as symbol
-          when hintKinds |> Set.contains HintKind.ParameterNameHint
-            && InlineParameterNameHints.isUnionCaseValidForHint symbol symbolUse ->
+    let inline private getHintsForMemberOrFunctionOrValue (sourceText: SourceText) parseResults symbol: NativeHintResolver =
+        Seq.filter (InlineParameterNameHints.isMemberOrFunctionOrValueValidForHint symbol)
+        >> Seq.collect (InlineParameterNameHints.getHintsForMemberOrFunctionOrValue sourceText parseResults symbol)
 
-          InlineParameterNameHints.getHintsForUnionCase parseResults symbol symbolUse
+    let inline private getHintsForUnionCase parseResults symbol: NativeHintResolver =
+        Seq.filter (InlineParameterNameHints.isUnionCaseValidForHint symbol) 
+        >> Seq.collect (InlineParameterNameHints.getHintsForUnionCase parseResults symbol)
 
-        // we'll be adding other stuff gradually here
-        | _ -> 
-            []
+    let private getHintResolvers (sourceText: SourceText) parseResults hintKinds (symbol: FSharpSymbol): NativeHintResolver seq = 
+        let rec resolve hintKinds resolvers =
+            match hintKinds with
+            | [] -> resolvers |> Seq.choose id
+            | hintKind :: hintKinds ->
+                match hintKind with
+                | HintKind.TypeHint -> 
+                    match symbol with
+                    | :? FSharpMemberOrFunctionOrValue as symbol -> getTypeHints parseResults symbol |> Some
+                    | _ -> None
+                | HintKind.ParameterNameHint ->
+                    match symbol with
+                    | :? FSharpMemberOrFunctionOrValue as symbol -> getHintsForMemberOrFunctionOrValue sourceText parseResults symbol |> Some
+                    | :? FSharpUnionCase as symbol -> getHintsForUnionCase parseResults symbol |> Some
+                    | _ -> None
+                // we'll be adding other stuff gradually here
+                :: resolvers |> resolve hintKinds
+
+        in resolve hintKinds []
+        
+    let private getHintsForSymbol (sourceText: SourceText) parseResults hintKinds (symbol: FSharpSymbol, symbolUses: FSharpSymbolUse seq) =
+        symbol 
+        |> getHintResolvers sourceText parseResults hintKinds 
+        |> Seq.collect (fun resolve -> resolve symbolUses)
 
-    let getHintsForDocument (document: Document) hintKinds userOpName cancellationToken = 
+    let getHintsForDocument sourceText (document: Document) hintKinds userOpName cancellationToken = 
         async {
             if isSignatureFile document.FilePath
             then 
                 return []
             else
                 let! parseResults, checkResults = 
-                    document.GetFSharpParseAndCheckResultsAsync userOpName 
+                    document.GetFSharpParseAndCheckResultsAsync userOpName
                 
                 return 
                     checkResults.GetAllUsesOfAllSymbolsInFile cancellationToken
+                    |> Seq.groupBy (fun symbolUse -> symbolUse.Symbol)
+                    |> Seq.collect (getHintsForSymbol sourceText parseResults (hintKinds |> Set.toList))
                     |> Seq.toList
-                    |> List.collect (getHintsForSymbol parseResults hintKinds)
         }
diff --git a/vsintegration/src/FSharp.Editor/Hints/InlineParameterNameHints.fs b/vsintegration/src/FSharp.Editor/Hints/InlineParameterNameHints.fs
index 8fb16d16d04..32af341e583 100644
--- a/vsintegration/src/FSharp.Editor/Hints/InlineParameterNameHints.fs
+++ b/vsintegration/src/FSharp.Editor/Hints/InlineParameterNameHints.fs
@@ -2,8 +2,10 @@
 
 namespace Microsoft.VisualStudio.FSharp.Editor.Hints
 
+open Microsoft.CodeAnalysis.Text
 open Microsoft.VisualStudio.FSharp.Editor
 open FSharp.Compiler.CodeAnalysis
+open FSharp.Compiler.EditorServices
 open FSharp.Compiler.Symbols
 open FSharp.Compiler.Text
 open Hints
@@ -30,15 +32,58 @@ module InlineParameterNameHints =
     let private doesFieldNameExist (field: FSharpField) = 
         not field.IsNameGenerated
 
-    let isMemberOrFunctionOrValueValidForHint (symbol: FSharpMemberOrFunctionOrValue) (symbolUse: FSharpSymbolUse) =
+    let private getArgumentLocations
+        (symbolUse: FSharpSymbolUse)
+        (parseResults: FSharpParseFileResults) =
+
+        let position = Position.mkPos 
+                        (symbolUse.Range.End.Line) 
+                        (symbolUse.Range.End.Column + 1)
+
+        parseResults.FindParameterLocations position
+        |> Option.map (fun locations -> locations.ArgumentLocations |> Seq.filter (fun location -> Position.posGeq location.ArgumentRange.Start position))
+        |> Option.filter (not << Seq.isEmpty)
+        |> Option.defaultValue Seq.empty
+
+    let private getTupleRanges =
+        Seq.map (fun location -> location.ArgumentRange)
+        >> Seq.toList
+
+    let private getCurryRanges 
+        (symbolUse: FSharpSymbolUse) 
+        (parseResults: FSharpParseFileResults) = 
+
+        parseResults.GetAllArgumentsForFunctionApplicationAtPosition symbolUse.Range.Start
+        |> Option.defaultValue []
+
+    let private isNamedArgument range =
+        Seq.filter (fun location -> location.IsNamedArgument)
+        >> Seq.map (fun location -> location.ArgumentRange) 
+        >> Seq.contains range
+
+    let private getSourceTextAtRange 
+        (sourceText: SourceText)
+        (range: range) =
+
+        let line = sourceText.Lines[range.Start.Line - 1].ToString()
+        let length = range.EndColumn - range.StartColumn
+        line.Substring(range.Start.Column, length)
+
+    let isMemberOrFunctionOrValueValidForHint 
+        (symbol: FSharpMemberOrFunctionOrValue) 
+        (symbolUse: FSharpSymbolUse) =
+
         if symbolUse.IsFromUse then
             let isNotBuiltInOperator = 
                 symbol.DeclaringEntity 
                 |> Option.exists (fun entity -> entity.CompiledName <> "Operators")
 
+            let isNotCustomOperation = 
+                not <| symbol.HasAttribute<CustomOperationAttribute>()
+
             (symbol.IsFunction && isNotBuiltInOperator) // arguably, hints for those would be rather useless
             || symbol.IsConstructor
-            || symbol.IsMethod
+            || (symbol.IsMethod && isNotCustomOperation)
         else
             false
 
@@ -47,23 +92,32 @@ module InlineParameterNameHints =
         && symbol.DisplayName <> "(::)"
 
     let getHintsForMemberOrFunctionOrValue
+        (sourceText: SourceText)
         (parseResults: FSharpParseFileResults) 
         (symbol: FSharpMemberOrFunctionOrValue) 
         (symbolUse: FSharpSymbolUse) =
 
         let parameters = symbol.CurriedParameterGroups |> Seq.concat
-        let ranges = parseResults.GetAllArgumentsForFunctionApplicationAtPosition symbolUse.Range.Start
-
-        match ranges with
-        | Some ranges -> 
-            parameters
-            |> Seq.zip ranges
-            |> Seq.where (snd >> doesParameterNameExist)
-            |> Seq.map getParameterHint
-            |> Seq.toList
-        
-        // this is the case at least for custom operators
-        | None -> []
+        let argumentLocations = parseResults |> getArgumentLocations symbolUse
+
+        let tupleRanges = argumentLocations |> getTupleRanges
+        let curryRanges = parseResults |> getCurryRanges symbolUse
+
+        let ranges = 
+            if tupleRanges |> (not << Seq.isEmpty) then tupleRanges else curryRanges
+            |> Seq.filter (fun range -> argumentLocations |> (not << isNamedArgument range))
+
+        let argumentNames = 
+            ranges
+            |> Seq.map (getSourceTextAtRange sourceText)
+
+        parameters
+        |> Seq.zip ranges // Seq.zip is important as List.zip requires equal lengths
+        |> Seq.where (snd >> doesParameterNameExist)
+        |> Seq.zip argumentNames
+        |> Seq.choose (fun (argumentName, (range, parameter)) -> 
+            if argumentName <> parameter.DisplayName then Some (getParameterHint (range, parameter)) else None)
+        |> Seq.toList
 
     let getHintsForUnionCase
         (parseResults: FSharpParseFileResults) 
diff --git a/vsintegration/src/FSharp.Editor/Hints/InlineTypeHints.fs b/vsintegration/src/FSharp.Editor/Hints/InlineTypeHints.fs
index 402eddbaef0..ab40a8931be 100644
--- a/vsintegration/src/FSharp.Editor/Hints/InlineTypeHints.fs
+++ b/vsintegration/src/FSharp.Editor/Hints/InlineTypeHints.fs
@@ -6,6 +6,7 @@ open Microsoft.VisualStudio.FSharp.Editor
 open FSharp.Compiler.CodeAnalysis
 open FSharp.Compiler.Symbols
 open FSharp.Compiler.Text
+open FSharp.Compiler.Text.Position
 open Hints
 
 module InlineTypeHints =
@@ -44,8 +45,20 @@ module InlineTypeHints =
         (symbol: FSharpMemberOrFunctionOrValue)
         (symbolUse: FSharpSymbolUse) =
 
+        let isOptionalParameter = 
+            symbolUse.IsFromDefinition
+            && symbol.FullType.IsAbbreviation 
+            && symbol.FullType.TypeDefinition.DisplayName = "option"
+
+        let adjustedRangeStart =
+            if isOptionalParameter then 
+                // we need the position to start at the '?' symbol
+                mkPos symbolUse.Range.StartLine (symbolUse.Range.StartColumn - 1) 
+            else 
+                symbolUse.Range.Start
+
         let isNotAnnotatedManually = 
-            not (parseFileResults.IsTypeAnnotationGivenAtPosition symbolUse.Range.Start)
+            not (parseFileResults.IsTypeAnnotationGivenAtPosition adjustedRangeStart)
 
         let isNotAfterDot = 
             symbolUse.IsFromDefinition 
diff --git a/vsintegration/src/FSharp.Editor/Hints/RoslynAdapter.fs b/vsintegration/src/FSharp.Editor/Hints/RoslynAdapter.fs
index b6026d6da44..f79e1dba1fa 100644
--- a/vsintegration/src/FSharp.Editor/Hints/RoslynAdapter.fs
+++ b/vsintegration/src/FSharp.Editor/Hints/RoslynAdapter.fs
@@ -30,6 +30,7 @@ type internal RoslynAdapter
                     let! sourceText = document.GetTextAsync cancellationToken |> Async.AwaitTask
                     let! nativeHints =
                         HintService.getHintsForDocument 
+                            sourceText
                             document 
                             hintKinds
                             userOpName 
diff --git a/vsintegration/src/FSharp.Editor/LanguageService/FSharpProjectOptionsManager.fs b/vsintegration/src/FSharp.Editor/LanguageService/FSharpProjectOptionsManager.fs
index 815fab5e904..92d2cefaae5 100644
--- a/vsintegration/src/FSharp.Editor/LanguageService/FSharpProjectOptionsManager.fs
+++ b/vsintegration/src/FSharp.Editor/LanguageService/FSharpProjectOptionsManager.fs
@@ -182,7 +182,7 @@ type private FSharpProjectOptionsReactor (checker: FSharpChecker) =
                 let! scriptProjectOptions, _ =
                     checker.GetProjectOptionsFromScript(document.FilePath,
                         sourceText.ToFSharpSourceText(),
-                        SessionsProperties.fsiPreview,
+                        previewEnabled=SessionsProperties.fsiPreview,
                         assumeDotNetFramework=not SessionsProperties.fsiUseNetCore,
                         userOpName=userOpName)
 
diff --git a/vsintegration/src/FSharp.Editor/LanguageService/LanguageService.fs b/vsintegration/src/FSharp.Editor/LanguageService/LanguageService.fs
index 5a15a55db0f..8b418d2c5b7 100644
--- a/vsintegration/src/FSharp.Editor/LanguageService/LanguageService.fs
+++ b/vsintegration/src/FSharp.Editor/LanguageService/LanguageService.fs
@@ -26,8 +26,11 @@ open Microsoft.VisualStudio.Text.Outlining
 open Microsoft.CodeAnalysis.ExternalAccess.FSharp
 open Microsoft.CodeAnalysis.Host
 open Microsoft.CodeAnalysis.Host.Mef
+open Microsoft.VisualStudio.FSharp.Editor.WorkspaceExtensions
+open System.Threading.Tasks
 
 #nowarn "9" // NativePtr.toNativeInt
+#nowarn "57" // Experimental stuff
 
 type internal RoamingProfileStorageLocation(keyName: string) =
     inherit OptionStorageLocation()
@@ -89,6 +92,12 @@ type internal FSharpWorkspaceServiceFactory
                 | _ ->
                     None
 
+            let getSource filename =
+                workspace.CurrentSolution.TryGetDocumentFromPath(filename)
+                |> Option.map(fun document ->
+                    let text = document.GetTextAsync().Result
+                    text.ToFSharpSourceText())
+
             lock gate (fun () ->
                 match checkerSingleton with
                 | Some _ -> ()
@@ -102,15 +111,19 @@ type internal FSharpWorkspaceServiceFactory
                                 | null -> None
                                 | _ -> Some editorOptions
 
-                            let enableParallelCheckingWithSignatureFiles =
+                            let getOption f defaultValue =
                                 editorOptions
-                                |> Option.map (fun options -> options.LanguageServicePerformance.EnableParallelCheckingWithSignatureFiles)
-                                |> Option.defaultValue false
+                                |> Option.map f
+                                |> Option.defaultValue defaultValue
+
+                            let enableParallelCheckingWithSignatureFiles =
+                                getOption (fun options -> options.LanguageServicePerformance.EnableParallelCheckingWithSignatureFiles) false
 
                             let enableParallelReferenceResolution =
-                                editorOptions
-                                |> Option.map (fun options -> options.LanguageServicePerformance.EnableParallelReferenceResolution)
-                                |> Option.defaultValue false
+                                getOption (fun options -> options.LanguageServicePerformance.EnableParallelReferenceResolution) false
+
+                            let enableLiveBuffers =
+                                getOption (fun options -> options.Advanced.IsLiveBuffersEnabled) false
 
                             let checker =
                                 FSharpChecker.Create(
@@ -122,7 +135,19 @@ type internal FSharpWorkspaceServiceFactory
                                     enableBackgroundItemKeyStoreAndSemanticClassification = true,
                                     enablePartialTypeChecking = true,
                                     enableParallelCheckingWithSignatureFiles = enableParallelCheckingWithSignatureFiles,
-                                    parallelReferenceResolution = enableParallelReferenceResolution)
+                                    parallelReferenceResolution = enableParallelReferenceResolution,
+                                    captureIdentifiersWhenParsing = true,
+                                    documentSource = (if enableLiveBuffers then DocumentSource.Custom getSource else DocumentSource.FileSystem))
+
+                            if enableLiveBuffers then
+                                workspace.WorkspaceChanged.Add(fun args ->
+                                    if args.DocumentId <> null then
+                                        backgroundTask {
+                                            let document = args.NewSolution.GetDocument(args.DocumentId)
+                                            let! _, _, _, options = document.GetFSharpCompilationOptionsAsync(nameof(workspace.WorkspaceChanged))
+                                            do! checker.NotifyFileChanged(document.FilePath, options)
+                                        } |> ignore)
+
                             checker
                     checkerSingleton <- Some checker
             )
diff --git a/vsintegration/src/FSharp.Editor/LanguageService/MetadataAsSource.fs b/vsintegration/src/FSharp.Editor/LanguageService/MetadataAsSource.fs
index 6ac4e754c1f..0a74deb77cd 100644
--- a/vsintegration/src/FSharp.Editor/LanguageService/MetadataAsSource.fs
+++ b/vsintegration/src/FSharp.Editor/LanguageService/MetadataAsSource.fs
@@ -94,7 +94,7 @@ module internal MetadataAsSource =
 
 [<Sealed>]
 [<Export(typeof<FSharpMetadataAsSourceService>); Composition.Shared>]
-type internal FSharpMetadataAsSourceService() =
+type FSharpMetadataAsSourceService() =
 
     let serviceProvider = ServiceProvider.GlobalProvider
     let projs = System.Collections.Concurrent.ConcurrentDictionary<string, IFSharpWorkspaceProjectContext>()
diff --git a/vsintegration/src/FSharp.Editor/LanguageService/WorkspaceExtensions.fs b/vsintegration/src/FSharp.Editor/LanguageService/WorkspaceExtensions.fs
index f25746325b2..dc0d09dca3f 100644
--- a/vsintegration/src/FSharp.Editor/LanguageService/WorkspaceExtensions.fs
+++ b/vsintegration/src/FSharp.Editor/LanguageService/WorkspaceExtensions.fs
@@ -91,7 +91,7 @@ module private CheckerExtensions =
             }
 
 [<RequireQualifiedAccess>]
-module private ProjectCache =
+module internal ProjectCache =
 
     /// This is a cache to maintain FSharpParsingOptions and FSharpProjectOptions per Roslyn Project.
     /// The Roslyn Project is held weakly meaning when it is cleaned up by the GC, the FSharParsingOptions and FSharpProjectOptions will be cleaned up by the GC.
@@ -99,9 +99,8 @@ module private ProjectCache =
     let Projects = ConditionalWeakTable<Project, FSharpChecker * FSharpProjectOptionsManager * FSharpParsingOptions * FSharpProjectOptions>()    
 
 type Solution with
-
     /// Get the instance of IFSharpWorkspaceService.
-    member private this.GetFSharpWorkspaceService() =
+    member internal this.GetFSharpWorkspaceService() =
         this.Workspace.Services.GetRequiredService<IFSharpWorkspaceService>()
 
 type Document with
@@ -207,15 +206,6 @@ type Document with
             return Tokenizer.getSymbolAtPosition(this.Id, sourceText, position, this.FilePath, defines, lookupKind, wholeActivePattern, allowStringToken)
         }
 
-    /// This is only used for testing purposes. It sets the ProjectCache.Projects with the given FSharpProjectOptions and F# document's project.
-    member this.SetFSharpProjectOptionsForTesting(projectOptions: FSharpProjectOptions) =
-        let workspaceService = this.Project.Solution.GetFSharpWorkspaceService()
-        let parsingOptions, _ = 
-            workspaceService.FSharpProjectOptionsManager.TryGetOptionsForDocumentOrProject(this, CancellationToken.None, nameof(this.SetFSharpProjectOptionsForTesting))
-            |> Async.RunImmediateExceptOnUI
-            |> Option.get
-        ProjectCache.Projects.Add(this.Project, (workspaceService.Checker, workspaceService.FSharpProjectOptionsManager, parsingOptions, projectOptions))
-
 type Project with
 
     /// Find F# references in the given project.
@@ -247,3 +237,20 @@ type Project with
                 do! doc.FindFSharpReferencesAsync(symbol, (fun textSpan range -> onFound doc textSpan range), userOpName)
                     |> RoslynHelpers.StartAsyncAsTask ct
     }
+    
+    member this.GetFSharpCompilationOptionsAsync(ct: CancellationToken) =
+        backgroundTask {
+            if this.IsFSharp then
+                match ProjectCache.Projects.TryGetValue(this) with
+                | true, result -> return result
+                | _ ->
+                    let service = this.Solution.GetFSharpWorkspaceService()
+                    let projectOptionsManager = service.FSharpProjectOptionsManager
+                    match! projectOptionsManager.TryGetOptionsByProject(this, ct) with
+                    | None -> return raise(OperationCanceledException("FSharp project options not found."))
+                    | Some(parsingOptions, projectOptions) ->
+                        let result = (service.Checker, projectOptionsManager, parsingOptions, projectOptions)
+                        return ProjectCache.Projects.GetValue(this, ConditionalWeakTable<_,_>.CreateValueCallback(fun _ -> result))
+            else
+                return raise(OperationCanceledException("Project is not a FSharp project."))
+        }
diff --git a/vsintegration/src/FSharp.Editor/Navigation/GoToDefinition.fs b/vsintegration/src/FSharp.Editor/Navigation/GoToDefinition.fs
index 4bdfec0bf11..bb84e395b8d 100644
--- a/vsintegration/src/FSharp.Editor/Navigation/GoToDefinition.fs
+++ b/vsintegration/src/FSharp.Editor/Navigation/GoToDefinition.fs
@@ -16,15 +16,18 @@ open Microsoft.CodeAnalysis.Text
 open Microsoft.CodeAnalysis.ExternalAccess.FSharp.Navigation
 
 open Microsoft.VisualStudio
+open Microsoft.VisualStudio.Shell
 open Microsoft.VisualStudio.Shell.Interop
+open Microsoft.VisualStudio.LanguageServices
 
-open FSharp.Compiler
 open FSharp.Compiler.CodeAnalysis
 open FSharp.Compiler.EditorServices
 open FSharp.Compiler.Text
 open FSharp.Compiler.Text.Range
 open FSharp.Compiler.Symbols
 open FSharp.Compiler.Tokenization
+open System.Composition
+open System.Text.RegularExpressions
 
 
 module private Symbol =
@@ -90,7 +93,7 @@ module private ExternalSymbol =
                     |> Option.map (fun args -> upcast methsym, FindDeclExternalSymbol.Constructor(fullTypeName, args))
                     )
                 |> List.ofSeq
-                
+
             (symbol, FindDeclExternalSymbol.Type fullTypeName) :: constructors
 
         | :? IMethodSymbol as methsym ->
@@ -111,14 +114,14 @@ module private ExternalSymbol =
         | _ -> []
 
 // TODO: Uncomment code when VS has a fix for updating the status bar.
-type internal StatusBar(statusBar: IVsStatusbar) =
+type StatusBar(statusBar: IVsStatusbar) =
     let mutable _searchIcon = int16 Microsoft.VisualStudio.Shell.Interop.Constants.SBAI_Find :> obj
 
     let _clear() =
         // unfreeze the statusbar
-        statusBar.FreezeOutput 0 |> ignore  
+        statusBar.FreezeOutput 0 |> ignore
         statusBar.Clear() |> ignore
-        
+
     member _.Message(_msg: string) =
         ()
         //let _, frozen = statusBar.IsFrozen()
@@ -137,11 +140,11 @@ type internal StatusBar(statusBar: IVsStatusbar) =
         //    | 0, currentText when currentText <> msg -> ()
         //    | _ -> clear()
         //}|> Async.Start
-    
+
     member _.Clear() = () //clear()
 
     /// Animated magnifying glass that displays on the status bar while a symbol search is in progress.
-    member _.Animate() : IDisposable = 
+    member _.Animate() : IDisposable =
         //statusBar.Animation (1, &searchIcon) |> ignore
         { new IDisposable with
             member _.Dispose() = () } //statusBar.Animation(0, &searchIcon) |> ignore }
@@ -155,19 +158,18 @@ type internal FSharpGoToDefinitionResult =
     | ExternalAssembly of FSharpSymbolUse * MetadataReference seq
 
 type internal GoToDefinition(metadataAsSource: FSharpMetadataAsSourceService) =
-
-    /// Use an origin document to provide the solution & workspace used to 
+    /// Use an origin document to provide the solution & workspace used to
     /// find the corresponding textSpan and INavigableItem for the range
-    let rangeToNavigableItem (range: range, document: Document) = 
+    let rangeToNavigableItem (range: range, document: Document) =
         async {
             let fileName = try System.IO.Path.GetFullPath range.FileName with _ -> range.FileName
             let refDocumentIds = document.Project.Solution.GetDocumentIdsWithFilePath fileName
-            if not refDocumentIds.IsEmpty then 
+            if not refDocumentIds.IsEmpty then
                 let refDocumentId = refDocumentIds.First()
                 let refDocument = document.Project.Solution.GetDocument refDocumentId
                 let! cancellationToken = Async.CancellationToken
                 let! refSourceText = refDocument.GetTextAsync(cancellationToken) |> Async.AwaitTask
-                match RoslynHelpers.TryFSharpRangeToTextSpan (refSourceText, range) with 
+                match RoslynHelpers.TryFSharpRangeToTextSpan (refSourceText, range) with
                 | None -> return None
                 | Some refTextSpan -> return Some (FSharpGoToDefinitionNavigableItem (refDocument, refTextSpan))
             else return None
@@ -182,7 +184,7 @@ type internal GoToDefinition(metadataAsSource: FSharpMetadataAsSourceService) =
             let! lexerSymbol = originDocument.TryFindFSharpLexerSymbolAsync(position, SymbolLookupKind.Greedy, false, false, userOpName)
             let textLinePos = sourceText.Lines.GetLinePosition position
             let fcsTextLineNumber = Line.fromZ textLinePos.Line
-            let lineText = (sourceText.Lines.GetLineFromPosition position).ToString()  
+            let lineText = (sourceText.Lines.GetLineFromPosition position).ToString()
             let idRange = lexerSymbol.Ident.idRange
 
             let! _, checkFileResults = originDocument.GetFSharpParseAndCheckResultsAsync(nameof(GoToDefinition)) |> liftAsync
@@ -191,14 +193,14 @@ type internal GoToDefinition(metadataAsSource: FSharpMetadataAsSourceService) =
             // if the tooltip was spawned in an implementation file and we have a range targeting
             // a signature file, try to find the corresponding implementation file and target the
             // desired symbol
-            if isSignatureFile fsSymbolUse.FileName && preferSignature = false then 
+            if isSignatureFile fsSymbolUse.FileName && preferSignature = false then
                 let fsfilePath = Path.ChangeExtension (originRange.FileName,"fs")
                 if not (File.Exists fsfilePath) then return! None else
                 let! implDoc = originDocument.Project.Solution.TryGetDocumentFromPath fsfilePath
                 let! implSourceText = implDoc.GetTextAsync ()
                 let! _, checkFileResults = implDoc.GetFSharpParseAndCheckResultsAsync(userOpName) |> liftAsync
                 let symbolUses = checkFileResults.GetUsesOfSymbolInFile symbol
-                let! implSymbol  = symbolUses |> Array.tryHead 
+                let! implSymbol  = symbolUses |> Array.tryHead
                 let! implTextSpan = RoslynHelpers.TryFSharpRangeToTextSpan (implSourceText, implSymbol.Range)
                 return FSharpGoToDefinitionNavigableItem (implDoc, implTextSpan)
             else
@@ -206,10 +208,10 @@ type internal GoToDefinition(metadataAsSource: FSharpMetadataAsSourceService) =
                 return! rangeToNavigableItem (fsSymbolUse.Range, targetDocument)
         }
 
-    /// if the symbol is defined in the given file, return its declaration location, otherwise use the targetSymbol to find the first 
+    /// if the symbol is defined in the given file, return its declaration location, otherwise use the targetSymbol to find the first
     /// instance of its presence in the provided source file. The first case is needed to return proper declaration location for
     /// recursive type definitions, where the first its usage may not be the declaration.
-    member _.FindSymbolDeclarationInDocument(targetSymbolUse: FSharpSymbolUse, document: Document) = 
+    member _.FindSymbolDeclarationInDocument(targetSymbolUse: FSharpSymbolUse, document: Document) =
         asyncMaybe {
             let filePath = document.FilePath
             match targetSymbolUse.Symbol.DeclarationLocation with
@@ -217,7 +219,7 @@ type internal GoToDefinition(metadataAsSource: FSharpMetadataAsSourceService) =
             | _ ->
                 let! _, checkFileResults = document.GetFSharpParseAndCheckResultsAsync("FindSymbolDeclarationInDocument") |> liftAsync
                 let symbolUses = checkFileResults.GetUsesOfSymbolInFile targetSymbolUse.Symbol
-                let! implSymbol  = symbolUses |> Array.tryHead 
+                let! implSymbol  = symbolUses |> Array.tryHead
                 return implSymbol.Range
         }
 
@@ -229,10 +231,10 @@ type internal GoToDefinition(metadataAsSource: FSharpMetadataAsSourceService) =
             let textLinePos = sourceText.Lines.GetLinePosition position
             let textLineString = textLine.ToString()
             let fcsTextLineNumber = Line.fromZ textLinePos.Line
-            let lineText = (sourceText.Lines.GetLineFromPosition position).ToString()  
-            
+            let lineText = (sourceText.Lines.GetLineFromPosition position).ToString()
+
             let preferSignature = isSignatureFile originDocument.FilePath
-                
+
             let! lexerSymbol = originDocument.TryFindFSharpLexerSymbolAsync(position, SymbolLookupKind.Greedy, false, false, userOpName)
             let idRange = lexerSymbol.Ident.idRange
 
@@ -262,10 +264,10 @@ type internal GoToDefinition(metadataAsSource: FSharpMetadataAsSourceService) =
                     let! location = symbol.Locations |> Seq.tryHead
                     return (FSharpGoToDefinitionResult.NavigableItem(FSharpGoToDefinitionNavigableItem(project.GetDocument(location.SourceTree), location.SourceSpan)), idRange)
                 | _ ->
-                    let metadataReferences = originDocument.Project.MetadataReferences                        
+                    let metadataReferences = originDocument.Project.MetadataReferences
                     return (FSharpGoToDefinitionResult.ExternalAssembly(targetSymbolUse, metadataReferences), idRange)
 
-            | FindDeclResult.DeclFound targetRange -> 
+            | FindDeclResult.DeclFound targetRange ->
                 // If the file is not associated with a document, it's considered external.
                 if not (originDocument.Project.Solution.ContainsDocumentWithFilePath(targetRange.FileName)) then
                     let metadataReferences = originDocument.Project.MetadataReferences
@@ -279,7 +281,7 @@ type internal GoToDefinition(metadataAsSource: FSharpMetadataAsSourceService) =
                             let implFilePath = Path.ChangeExtension (originDocument.FilePath,"fs")
                             if not (File.Exists implFilePath) then return! None else
                             let! implDocument = originDocument.Project.Solution.TryGetDocumentFromPath implFilePath
-                        
+
                             let! targetRange = this.FindSymbolDeclarationInDocument(targetSymbolUse, implDocument)
                             let! implSourceText = implDocument.GetTextAsync(cancellationToken) |> liftTaskAsync
                             let! implTextSpan = RoslynHelpers.TryFSharpRangeToTextSpan (implSourceText, targetRange)
@@ -288,7 +290,7 @@ type internal GoToDefinition(metadataAsSource: FSharpMetadataAsSourceService) =
                         else // jump from implementation to the corresponding signature
                             let declarations = checkFileResults.GetDeclarationLocation (fcsTextLineNumber, lexerSymbol.Ident.idRange.EndColumn, textLineString, lexerSymbol.FullIsland, true)
                             match declarations with
-                            | FindDeclResult.DeclFound targetRange -> 
+                            | FindDeclResult.DeclFound targetRange ->
                                 let! sigDocument = originDocument.Project.Solution.TryGetDocumentFromPath targetRange.FileName
                                 let! sigSourceText = sigDocument.GetTextAsync(cancellationToken) |> liftTaskAsync
                                 let! sigTextSpan = RoslynHelpers.TryFSharpRangeToTextSpan (sigSourceText, targetRange)
@@ -296,28 +298,28 @@ type internal GoToDefinition(metadataAsSource: FSharpMetadataAsSourceService) =
                                 return (FSharpGoToDefinitionResult.NavigableItem(navItem), idRange)
                             | _ ->
                                 return! None
-                    // when the target range is different follow the navigation convention of 
+                    // when the target range is different follow the navigation convention of
                     // - gotoDefn origin = signature , gotoDefn destination = signature
-                    // - gotoDefn origin = implementation, gotoDefn destination = implementation 
+                    // - gotoDefn origin = implementation, gotoDefn destination = implementation
                     else
                         let! sigDocument = originDocument.Project.Solution.TryGetDocumentFromPath targetRange.FileName
                         let! sigSourceText = sigDocument.GetTextAsync(cancellationToken) |> liftTaskAsync
                         let! sigTextSpan = RoslynHelpers.TryFSharpRangeToTextSpan (sigSourceText, targetRange)
                         // if the gotodef call originated from a signature and the returned target is a signature, navigate there
-                        if isSignatureFile targetRange.FileName && preferSignature then 
+                        if isSignatureFile targetRange.FileName && preferSignature then
                             let navItem = FSharpGoToDefinitionNavigableItem (sigDocument, sigTextSpan)
                             return (FSharpGoToDefinitionResult.NavigableItem(navItem), idRange)
                         else // we need to get an FSharpSymbol from the targetRange found in the signature
                              // that symbol will be used to find the destination in the corresponding implementation file
                             let implFilePath =
                                 // Bugfix: apparently sigDocument not always is a signature file
-                                if isSignatureFile sigDocument.FilePath then Path.ChangeExtension (sigDocument.FilePath, "fs") 
+                                if isSignatureFile sigDocument.FilePath then Path.ChangeExtension (sigDocument.FilePath, "fs")
                                 else sigDocument.FilePath
 
                             let! implDocument = originDocument.Project.Solution.TryGetDocumentFromPath implFilePath
-                        
-                            let! targetRange = this.FindSymbolDeclarationInDocument(targetSymbolUse, implDocument)    
-                        
+
+                            let! targetRange = this.FindSymbolDeclarationInDocument(targetSymbolUse, implDocument)
+
                             let! implSourceText = implDocument.GetTextAsync () |> liftTaskAsync
                             let! implTextSpan = RoslynHelpers.TryFSharpRangeToTextSpan (implSourceText, targetRange)
                             let navItem = FSharpGoToDefinitionNavigableItem (implDocument, implTextSpan)
@@ -326,7 +328,7 @@ type internal GoToDefinition(metadataAsSource: FSharpMetadataAsSourceService) =
                     return! None
         }
 
-    /// find the declaration location (signature file/.fsi) of the target symbol if possible, fall back to definition 
+    /// find the declaration location (signature file/.fsi) of the target symbol if possible, fall back to definition
     member this.FindDeclarationOfSymbolAtRange(targetDocument: Document, symbolRange: range, targetSource: SourceText) =
         this.FindSymbolHelper(targetDocument, symbolRange, targetSource, preferSignature=true)
 
@@ -341,7 +343,7 @@ type internal GoToDefinition(metadataAsSource: FSharpMetadataAsSourceService) =
                 >> Array.toSeq)
         |> RoslynHelpers.StartAsyncAsTask cancellationToken
 
-    /// Construct a task that will return a navigation target for the implementation definition of the symbol 
+    /// Construct a task that will return a navigation target for the implementation definition of the symbol
     /// at the provided position in the document.
     member this.FindDefinitionTask(originDocument: Document, position: int, cancellationToken: CancellationToken) =
         this.FindDefinitionAtPosition(originDocument, position, cancellationToken)
@@ -355,7 +357,7 @@ type internal GoToDefinition(metadataAsSource: FSharpMetadataAsSourceService) =
         let navigationService = workspace.Services.GetService<IFSharpDocumentNavigationService>()
         let navigationSucceeded = navigationService.TryNavigateToSpan(workspace, navigableItem.Document.Id, navigableItem.SourceSpan, cancellationToken)
 
-        if not navigationSucceeded then 
+        if not navigationSucceeded then
             statusBar.TempMessage (SR.CannotNavigateUnknown())
 
     member _.NavigateToItem(navigableItem: FSharpNavigableItem, statusBar: StatusBar, cancellationToken: CancellationToken) =
@@ -368,13 +370,13 @@ type internal GoToDefinition(metadataAsSource: FSharpMetadataAsSourceService) =
 
         // Prefer open documents in the preview tab.
         let result = navigationService.TryNavigateToSpan(workspace, navigableItem.Document.Id, navigableItem.SourceSpan, cancellationToken)
-            
-        if result then 
+
+        if result then
             statusBar.Clear()
-        else 
+        else
             statusBar.TempMessage (SR.CannotNavigateUnknown())
 
-    /// Find the declaration location (signature file/.fsi) of the target symbol if possible, fall back to definition 
+    /// Find the declaration location (signature file/.fsi) of the target symbol if possible, fall back to definition
     member this.NavigateToSymbolDeclarationAsync(targetDocument: Document, targetSourceText: SourceText, symbolRange: range, statusBar: StatusBar, cancellationToken: CancellationToken) =
         asyncMaybe {
             let! item = this.FindDeclarationOfSymbolAtRange(targetDocument, symbolRange, targetSourceText)
@@ -406,10 +408,10 @@ type internal GoToDefinition(metadataAsSource: FSharpMetadataAsSourceService) =
         let result =
             match textOpt with
             | Some (text, fileName) ->
-                let tmpProjInfo, tmpDocInfo = 
+                let tmpProjInfo, tmpDocInfo =
                     MetadataAsSource.generateTemporaryDocument(
-                        AssemblyIdentity(targetSymbolUse.Symbol.Assembly.QualifiedName), 
-                        fileName, 
+                        AssemblyIdentity(targetSymbolUse.Symbol.Assembly.QualifiedName),
+                        fileName,
                         metadataReferences)
                 let tmpShownDocOpt = metadataAsSource.ShowDocument(tmpProjInfo, tmpDocInfo.FilePath, SourceText.From(text.ToString()))
                 match tmpShownDocOpt with
@@ -427,7 +429,7 @@ type internal GoToDefinition(metadataAsSource: FSharpMetadataAsSourceService) =
                                             ty1.GenericArguments.Count = ty2.GenericArguments.Count &&
                                             (ty1.GenericArguments, ty2.GenericArguments)
                                             ||> Seq.forall2 areTypesEqual
-                                        )                                                    
+                                        )
                                     if generic then
                                         true
                                     else
@@ -436,7 +438,7 @@ type internal GoToDefinition(metadataAsSource: FSharpMetadataAsSourceService) =
                                         namesEqual && accessPathsEqual
 
                                 // This tries to find the best possible location of the target symbol's location in the metadata source.
-                                // We really should rely on symbol equality within FCS instead of doing it here, 
+                                // We really should rely on symbol equality within FCS instead of doing it here,
                                 //     but the generated metadata as source isn't perfect for symbol equality.
                                 checkResults.GetAllUsesOfAllSymbolsInFile(cancellationToken)
                                 |> Seq.tryFind (fun x ->
@@ -470,7 +472,7 @@ type internal GoToDefinition(metadataAsSource: FSharpMetadataAsSourceService) =
                                 | Some span -> span
                                 | _ -> TextSpan()
 
-                            return span                             
+                            return span
                         }
 
                     let span =
@@ -478,7 +480,7 @@ type internal GoToDefinition(metadataAsSource: FSharpMetadataAsSourceService) =
                         | Some span -> span
                         | _ -> TextSpan()
 
-                    let navItem = FSharpGoToDefinitionNavigableItem(tmpShownDoc, span)                               
+                    let navItem = FSharpGoToDefinitionNavigableItem(tmpShownDoc, span)
                     this.NavigateToItem(navItem, statusBar, cancellationToken)
                     true
                 | _ ->
@@ -486,9 +488,9 @@ type internal GoToDefinition(metadataAsSource: FSharpMetadataAsSourceService) =
             | _ ->
                 false
 
-        if result then 
+        if result then
             statusBar.Clear()
-        else 
+        else
             statusBar.TempMessage (SR.CannotNavigateUnknown())
 
 type internal QuickInfo =
@@ -526,7 +528,7 @@ module internal FSharpQuickInfo =
             let! extLexerSymbol = extDocument.TryFindFSharpLexerSymbolAsync(extSpan.Start, SymbolLookupKind.Greedy, true, true, userOpName)
             let! _, extCheckFileResults = extDocument.GetFSharpParseAndCheckResultsAsync(userOpName) |> liftAsync
 
-            let extQuickInfoText = 
+            let extQuickInfoText =
                 extCheckFileResults.GetToolTip
                     (declRange.StartLine, extLexerSymbol.Ident.idRange.EndColumn, extLineText, extLexerSymbol.FullIsland, FSharpTokenTag.IDENT)
 
@@ -558,7 +560,7 @@ module internal FSharpQuickInfo =
             let! lexerSymbol = document.TryFindFSharpLexerSymbolAsync(position, SymbolLookupKind.Greedy, true, true, userOpName)
             let! _, checkFileResults = document.GetFSharpParseAndCheckResultsAsync(userOpName) |> liftAsync
             let! sourceText = document.GetTextAsync cancellationToken
-            let idRange = lexerSymbol.Ident.idRange  
+            let idRange = lexerSymbol.Ident.idRange
             let textLinePos = sourceText.Lines.GetLinePosition position
             let fcsTextLineNumber = Line.fromZ textLinePos.Line
             let lineText = (sourceText.Lines.GetLineFromPosition position).ToString()
@@ -584,13 +586,13 @@ module internal FSharpQuickInfo =
                                  SymbolKind = lexerSymbol.Kind }
                 }
 
-            match lexerSymbol.Kind with 
+            match lexerSymbol.Kind with
             | LexerSymbolKind.Keyword
             | LexerSymbolKind.String ->
                 let! targetQuickInfo = getTargetSymbolQuickInfo (None, FSharpTokenTag.STRING)
                 return lexerSymbol.Range, None, Some targetQuickInfo
-            
-            | _ -> 
+
+            | _ ->
             let! symbolUse = checkFileResults.GetSymbolUseAtLocation (fcsTextLineNumber, idRange.EndColumn, lineText, lexerSymbol.FullIsland)
 
             // if the target is in a signature file, adjusting the quick info is unnecessary
@@ -606,7 +608,7 @@ module internal FSharpQuickInfo =
                 let! targetQuickInfo = getTargetSymbolQuickInfo (Some symbolUse.Symbol, FSharpTokenTag.IDENT)
 
                 let! result =
-                    match findSigDeclarationResult with 
+                    match findSigDeclarationResult with
                     | FindDeclResult.DeclFound declRange when isSignatureFile declRange.FileName ->
                         asyncMaybe {
                             let! sigQuickInfo = getQuickInfoFromRange(document, declRange, cancellationToken)
@@ -666,11 +668,11 @@ type internal FSharpNavigation
 
             // To ensure proper navigation decsions, we need to check the type of document the navigation call
             // is originating from and the target we're provided by default:
-            //  - signature files (.fsi) should navigate to other signature files 
+            //  - signature files (.fsi) should navigate to other signature files
             //  - implementation files (.fs) should navigate to other implementation files
             let (|Signature|Implementation|) filepath =
                 if isSignatureFile filepath then Signature else Implementation
-               
+
             match initialDoc.FilePath, targetPath with
             | Signature, Signature
             | Implementation, Implementation ->
@@ -679,7 +681,7 @@ type internal FSharpNavigation
             // Adjust the target from signature to implementation.
             | Implementation, Signature  ->
                 return! gtd.NavigateToSymbolDefinitionAsync(targetDoc, targetSource, range, statusBar, cancellationToken)
-                    
+
             // Adjust the target from implmentation to signature.
             | Signature, Implementation ->
                 return! gtd.NavigateToSymbolDeclarationAsync(targetDoc, targetSource, range, statusBar, cancellationToken)
@@ -699,10 +701,10 @@ type internal FSharpNavigation
         )
         |> Task.FromResult
 
-    member this.TryGoToDefinition(position, cancellationToken) =
+    member _.TryGoToDefinition(position, cancellationToken) =
         let gtd = GoToDefinition(metadataAsSource)
         let gtdTask = gtd.FindDefinitionTask(initialDoc, position, cancellationToken)
-        
+
         // Wrap this in a try/with as if the user clicks "Cancel" on the thread dialog, we'll be cancelled.
         // Task.Wait throws an exception if the task is cancelled, so be sure to catch it.
         try
@@ -718,12 +720,244 @@ type internal FSharpNavigation
                     gtd.NavigateToExternalDeclaration(targetSymbolUse, metadataReferences, cancellationToken, statusBar)
                     // 'true' means do it, like Sheev Palpatine would want us to.
                     true
-            else 
+            else
                 statusBar.TempMessage (SR.CannotDetermineSymbol())
                 false
-        with exc -> 
+        with exc ->
             statusBar.TempMessage(String.Format(SR.NavigateToFailed(), Exception.flattenMessage exc))
-        
+
             // Don't show the dialog box as it's most likely that the user cancelled.
             // Don't make them click twice.
-            true
\ No newline at end of file
+            true
+
+[<RequireQualifiedAccess>]
+type internal SymbolMemberType =
+    Event | Property | Method | Constructor | Other
+    static member FromString(s: string) =
+        match s with
+        | "E" -> Event
+        | "P" -> Property
+        | "CTOR" -> Constructor // That one is "artificial one", so we distinguish constructors.
+        | "M" -> Method
+        | _ -> Other
+
+type internal SymbolPath = { EntityPath: string list; MemberOrValName: string; GenericParameters: int }
+
+[<RequireQualifiedAccess>]
+type internal DocCommentId =
+    | Member of SymbolPath * SymbolMemberType: SymbolMemberType
+    | Field of SymbolPath
+    | Type of EntityPath: string list
+    | None
+
+type FSharpNavigableLocation(statusBar: StatusBar, metadataAsSource: FSharpMetadataAsSourceService, symbolRange: range, project: Project) =
+    interface IFSharpNavigableLocation with
+        member _.NavigateToAsync(_options: FSharpNavigationOptions2, cancellationToken: CancellationToken) : Task<bool> =
+            asyncMaybe {
+                let targetPath = symbolRange.FileName
+                let! targetDoc = project.Solution.TryGetDocumentFromFSharpRange (symbolRange, project.Id)
+                let! targetSource = targetDoc.GetTextAsync(cancellationToken)
+                let gtd = GoToDefinition(metadataAsSource)
+
+                let (|Signature|Implementation|) filepath =
+                    if isSignatureFile filepath then Signature else Implementation
+
+                match targetPath with
+                | Signature  ->
+                    return! gtd.NavigateToSymbolDefinitionAsync(targetDoc, targetSource, symbolRange, statusBar, cancellationToken)
+                | Implementation ->
+                    return! gtd.NavigateToSymbolDeclarationAsync(targetDoc, targetSource, symbolRange, statusBar, cancellationToken)
+            }
+            |> Async.map (fun a -> a.IsSome)
+            |> RoslynHelpers.StartAsyncAsTask cancellationToken
+
+[<Export(typeof<IFSharpCrossLanguageSymbolNavigationService>)>]
+[<Export(typeof<FSharpCrossLanguageSymbolNavigationService>)>]
+type FSharpCrossLanguageSymbolNavigationService()  =
+    let componentModel = Package.GetGlobalService(typeof<ComponentModelHost.SComponentModel>) :?> ComponentModelHost.IComponentModel
+    let workspace = componentModel.GetService<VisualStudioWorkspace>()
+    let statusBar = StatusBar(ServiceProvider.GlobalProvider.GetService<SVsStatusbar,IVsStatusbar>())
+    let metadataAsSource = componentModel.DefaultExportProvider.GetExport<FSharpMetadataAsSourceService>().Value
+
+    let tryFindFieldByName (name: string) (e: FSharpEntity) =
+        let fields =
+            e.FSharpFields
+            |> Seq.filter (
+                fun x ->
+                    x.DisplayName = name
+                    && not x.IsCompilerGenerated)
+            |> Seq.map (fun e -> e.DeclarationLocation)
+
+        if fields.Count() <= 0 && (e.IsFSharpUnion || e.IsFSharpRecord) then
+            Seq.singleton e.DeclarationLocation
+        else
+            fields
+
+    let tryFindValByNameAndType (name: string) (symbolMemberType: SymbolMemberType) (genericParametersCount: int) (e: FSharpEntity) (entities: FSharpMemberOrFunctionOrValue seq) =
+
+        let defaultFilter (e: FSharpMemberOrFunctionOrValue) =
+            (e.DisplayName = name || e.CompiledName = name) &&
+            e.GenericParameters.Count = genericParametersCount
+
+        let isProperty (e: FSharpMemberOrFunctionOrValue) = defaultFilter e && e.IsProperty
+        let isConstructor (e: FSharpMemberOrFunctionOrValue) = defaultFilter e && e.IsConstructor
+
+        let  getLocation (e: FSharpMemberOrFunctionOrValue) = e.DeclarationLocation
+
+        let filteredEntities: range seq =
+            match symbolMemberType with
+            | SymbolMemberType.Other
+            | SymbolMemberType.Method ->
+                entities
+                |> Seq.filter defaultFilter
+                |> Seq.map getLocation
+            // F# record-specific logic, if navigating to the record's ctor, then navigate to record declaration.
+            // If we navigating to F# record property, we first check if it's "custom" property, if it's one of the record fields, we search for it in the fields.
+            | SymbolMemberType.Constructor when e.IsFSharpRecord ->
+                Seq.singleton e.DeclarationLocation
+            | SymbolMemberType.Property when e.IsFSharpRecord ->
+                let properties =
+                    entities
+                    |> Seq.filter isProperty
+                    |> Seq.map getLocation
+                let fields = tryFindFieldByName name e
+                Seq.append properties fields
+            | SymbolMemberType.Constructor ->
+                entities
+                |> Seq.filter isConstructor
+                |> Seq.map getLocation
+            // When navigating to property for the record, it will be in members bag for custom ones, but will be in the fields in fields.
+            | SymbolMemberType.Event // Events are just properties`
+            | SymbolMemberType.Property ->
+                entities
+                |> Seq.filter isProperty
+                |> Seq.map getLocation
+
+        filteredEntities
+
+    let tryFindVal (name: string) (documentCommentId: string) (symbolMemberType: SymbolMemberType) (genericParametersCount: int) (e: FSharpEntity) =
+        let entities = e.TryGetMembersFunctionsAndValues()
+
+        // First, try and find entity by exact xml signature, return if found,
+        // otherwise, just try and match by parsed name and number of arguments.
+
+        let entitiesByXmlSig =
+            entities
+            |> Seq.filter (fun e -> e.XmlDocSig = documentCommentId)
+            |> Seq.map (fun e -> e.DeclarationLocation)
+
+        if Seq.isEmpty entitiesByXmlSig then
+            tryFindValByNameAndType name symbolMemberType genericParametersCount e entities
+        else
+            entitiesByXmlSig
+
+    static member internal DocCommentIdToPath (docId:string) =
+        // The groups are following:
+        //   1 - type (see below).
+        //   2 - Path - a dotted path to a symbol.
+        //   3 - parameters, opetional, only for methods and properties.
+        //   4 - return type, optional, only for methods.
+        let docCommentIdRx = Regex(@"^(?<kind>\w):(?<entity>[\w\d#`.]+)(?<args>\(.+\))?(?:~([\w\d.]+))?$", RegexOptions.Compiled)
+
+        // Parse generic args out of the function name
+        let fnGenericArgsRx = Regex(@"^(?<entity>.+)``(?<typars>\d+)$", RegexOptions.Compiled)
+        // docCommentId is in the following format:
+        //
+        // "T:" prefix for types
+        // "T:N.X.Nested" - type
+        // "T:N.X.D" - delegate
+        //
+        // "M:" prefix is for methods
+        // "M:N.X.#ctor" - constructor
+        // "M:N.X.#ctor(System.Int32)" - constructor with one parameter
+        // "M:N.X.f" - method with unit parameter
+        // "M:N.X.bb(System.String,System.Int32@)" - method with two parameters
+        // "M:N.X.gg(System.Int16[],System.Int32[0:,0:])" - method with two parameters, 1d and 2d array
+        // "M:N.X.op_Addition(N.X,N.X)" - operator
+        // "M:N.X.op_Explicit(N.X)~System.Int32" - operator with return type
+        // "M:N.GenericMethod.WithNestedType``1(N.GenericType{``0}.NestedType)" - generic type with one parameter
+        // "M:N.GenericMethod.WithIntOfNestedType``1(N.GenericType{System.Int32}.NestedType)" - generic type with one parameter
+        // "M:N.X.N#IX{N#KVP{System#String,System#Int32}}#IXA(N.KVP{System.String,System.Int32})" - explicit interface implementation
+        //
+        // "E:" prefix for events
+        //
+        // "E:N.X.d".
+        //
+        // "F:" prefix for fields
+        // "F:N.X.q" - field
+        //
+        // "P:" prefix for properties
+        // "P:N.X.prop" - property with getter and setter
+
+        let m = docCommentIdRx.Match(docId)
+        let t = m.Groups["kind"].Value
+        match m.Success, t with
+        | true, ("M" | "P" | "E") ->
+            // TODO: Probably, there's less janky way of dealing with those.
+            let parts = m.Groups["entity"].Value.Split('.')
+            let entityPath = parts[..(parts.Length - 2)] |> List.ofArray
+            let memberOrVal = parts[parts.Length - 1]
+
+            // Try and parse generic params count from the name (e.g. NameOfTheFunction``1, where ``1 is amount of type parameters)
+            let genericM = fnGenericArgsRx.Match(memberOrVal)
+            let (memberOrVal, genericParametersCount) =
+                if genericM.Success then
+                    (genericM.Groups["entity"].Value, int genericM.Groups["typars"].Value)
+                else
+                    memberOrVal, 0
+
+            // A hack/fixup for the constructor name (#ctor in doccommentid and ``.ctor`` in F#)
+            if memberOrVal = "#ctor" then
+                DocCommentId.Member ({ EntityPath = entityPath; MemberOrValName = "``.ctor``"; GenericParameters = 0 },SymbolMemberType.Constructor)
+            else
+                DocCommentId.Member ({ EntityPath = entityPath; MemberOrValName = memberOrVal; GenericParameters = genericParametersCount }, (SymbolMemberType.FromString t))
+        | true, "T" ->
+            let entityPath = m.Groups["entity"].Value.Split('.') |> List.ofArray
+            DocCommentId.Type entityPath
+        | true, "F" ->
+            let parts = m.Groups["entity"].Value.Split('.')
+            let entityPath = parts[..(parts.Length - 2)] |> List.ofArray
+            let memberOrVal = parts[parts.Length - 1]
+            DocCommentId.Field { EntityPath = entityPath; MemberOrValName = memberOrVal; GenericParameters = 0 }
+        | _ -> DocCommentId.None
+
+    interface IFSharpCrossLanguageSymbolNavigationService with
+        member _.TryGetNavigableLocationAsync(assemblyName: string, documentationCommentId: string, cancellationToken: CancellationToken) : Task<IFSharpNavigableLocation> =
+            let path = FSharpCrossLanguageSymbolNavigationService.DocCommentIdToPath documentationCommentId
+            backgroundTask {
+                let projects = workspace.CurrentSolution.Projects |> Seq.filter (fun p -> p.IsFSharp && p.AssemblyName = assemblyName)
+
+                let mutable locations = Seq.empty
+
+                for project in projects do
+                    let! checker, _, _, options = project.GetFSharpCompilationOptionsAsync(cancellationToken)
+                    let! result = checker.ParseAndCheckProject(options)
+
+                    match path with
+                    | DocCommentId.Member ({ EntityPath = entityPath; MemberOrValName = memberOrVal; GenericParameters = genericParametersCount }, memberType) ->
+                        let entity = result.AssemblySignature.FindEntityByPath (entityPath)
+                        entity |> Option.iter (fun e ->
+                            locations <- e |> tryFindVal memberOrVal documentationCommentId memberType genericParametersCount
+                                     |> Seq.map (fun m -> (m, project))
+                                     |> Seq.append locations)
+                    | DocCommentId.Field { EntityPath = entityPath; MemberOrValName = memberOrVal } ->
+                        let entity = result.AssemblySignature.FindEntityByPath (entityPath)
+                        entity |> Option.iter (fun e ->
+                            locations <- e |> tryFindFieldByName memberOrVal
+                                     |> Seq.map (fun m -> (m, project))
+                                     |> Seq.append locations)
+                    | DocCommentId.Type entityPath ->
+                        let entity = result.AssemblySignature.FindEntityByPath (entityPath)
+                        entity |> Option.iter (fun e ->
+                            locations <- Seq.append locations [e.DeclarationLocation, project])
+                    | DocCommentId.None -> ()
+
+                // TODO: Figure out the way of giving the user choice where to navigate, if there are more than one result
+                // For now, we only take 1st one, since it's usually going to be only one result (given we process names correctly).
+                // More results can theoretically be returned in case of method overloads, or when we have both signature and implementation files.
+                if locations.Count() >= 1 then
+                    let (location, project) = locations.First()
+                    return FSharpNavigableLocation(statusBar, metadataAsSource, location, project) :> IFSharpNavigableLocation
+                else
+                    return Unchecked.defaultof<_> // returning null here, so Roslyn can fallback to default source-as-metadata implementation.
+            }
diff --git a/vsintegration/src/FSharp.Editor/Options/EditorOptions.fs b/vsintegration/src/FSharp.Editor/Options/EditorOptions.fs
index 880a1c2cabc..b782f40d245 100644
--- a/vsintegration/src/FSharp.Editor/Options/EditorOptions.fs
+++ b/vsintegration/src/FSharp.Editor/Options/EditorOptions.fs
@@ -72,19 +72,21 @@ type LanguageServicePerformanceOptions =
         TimeUntilStaleCompletion = 2000 // In ms, so this is 2 seconds
         EnableParallelCheckingWithSignatureFiles = false
         EnableParallelReferenceResolution = false
-        EnableFastFindReferences = false }
+        EnableFastFindReferences = FSharpExperimentalFeaturesEnabledAutomatically }
 
 [<CLIMutable>]
 type AdvancedOptions =
     { IsBlockStructureEnabled: bool
       IsOutliningEnabled: bool
       IsInlineTypeHintsEnabled: bool
-      IsInlineParameterNameHintsEnabled: bool }
+      IsInlineParameterNameHintsEnabled: bool
+      IsLiveBuffersEnabled: bool }
     static member Default =
       { IsBlockStructureEnabled = true
         IsOutliningEnabled = true
         IsInlineTypeHintsEnabled = false 
-        IsInlineParameterNameHintsEnabled = false }
+        IsInlineParameterNameHintsEnabled = false
+        IsLiveBuffersEnabled = FSharpExperimentalFeaturesEnabledAutomatically }
 
 [<CLIMutable>]
 type FormattingOptions =
diff --git a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.cs.xlf b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.cs.xlf
index fd11eefbffb..271152415d1 100644
--- a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.cs.xlf
+++ b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.cs.xlf
@@ -33,15 +33,19 @@ Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</source>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</source>
         <target state="new">Block Structure Guides;
 Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</target>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</target>
         <note />
       </trans-unit>
       <trans-unit id="CodeFixesPageKeywords">
diff --git a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.de.xlf b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.de.xlf
index 29aecb4e068..a264f044ed3 100644
--- a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.de.xlf
+++ b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.de.xlf
@@ -33,15 +33,19 @@ Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</source>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</source>
         <target state="new">Block Structure Guides;
 Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</target>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</target>
         <note />
       </trans-unit>
       <trans-unit id="CodeFixesPageKeywords">
diff --git a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.es.xlf b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.es.xlf
index 1d43e6fe28b..5c4e44f80c5 100644
--- a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.es.xlf
+++ b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.es.xlf
@@ -33,15 +33,19 @@ Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</source>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</source>
         <target state="new">Block Structure Guides;
 Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</target>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</target>
         <note />
       </trans-unit>
       <trans-unit id="CodeFixesPageKeywords">
diff --git a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.fr.xlf b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.fr.xlf
index d127852260f..ba1cbf9f0bf 100644
--- a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.fr.xlf
+++ b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.fr.xlf
@@ -33,15 +33,19 @@ Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</source>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</source>
         <target state="new">Block Structure Guides;
 Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</target>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</target>
         <note />
       </trans-unit>
       <trans-unit id="CodeFixesPageKeywords">
diff --git a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.it.xlf b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.it.xlf
index e9058f4dc73..3a287f0f36a 100644
--- a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.it.xlf
+++ b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.it.xlf
@@ -33,15 +33,19 @@ Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</source>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</source>
         <target state="new">Block Structure Guides;
 Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</target>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</target>
         <note />
       </trans-unit>
       <trans-unit id="CodeFixesPageKeywords">
diff --git a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.ja.xlf b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.ja.xlf
index d21eadf50b3..6b5448db356 100644
--- a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.ja.xlf
+++ b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.ja.xlf
@@ -33,15 +33,19 @@ Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</source>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</source>
         <target state="new">Block Structure Guides;
 Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</target>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</target>
         <note />
       </trans-unit>
       <trans-unit id="CodeFixesPageKeywords">
diff --git a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.ko.xlf b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.ko.xlf
index e0a1add01b6..20cac30b405 100644
--- a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.ko.xlf
+++ b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.ko.xlf
@@ -33,15 +33,19 @@ Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</source>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</source>
         <target state="new">Block Structure Guides;
 Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</target>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</target>
         <note />
       </trans-unit>
       <trans-unit id="CodeFixesPageKeywords">
diff --git a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.pl.xlf b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.pl.xlf
index b85e0b53f3e..aed9ab9c6f9 100644
--- a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.pl.xlf
+++ b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.pl.xlf
@@ -33,15 +33,19 @@ Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</source>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</source>
         <target state="new">Block Structure Guides;
 Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</target>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</target>
         <note />
       </trans-unit>
       <trans-unit id="CodeFixesPageKeywords">
diff --git a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.pt-BR.xlf b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.pt-BR.xlf
index 012625ddc09..b86e03bc023 100644
--- a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.pt-BR.xlf
+++ b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.pt-BR.xlf
@@ -33,15 +33,19 @@ Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</source>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</source>
         <target state="new">Block Structure Guides;
 Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</target>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</target>
         <note />
       </trans-unit>
       <trans-unit id="CodeFixesPageKeywords">
diff --git a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.ru.xlf b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.ru.xlf
index 9724c82c1ec..4b491e1f465 100644
--- a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.ru.xlf
+++ b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.ru.xlf
@@ -33,15 +33,19 @@ Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</source>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</source>
         <target state="new">Block Structure Guides;
 Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</target>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</target>
         <note />
       </trans-unit>
       <trans-unit id="CodeFixesPageKeywords">
diff --git a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.tr.xlf b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.tr.xlf
index cd87fa4f329..75838b42f8c 100644
--- a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.tr.xlf
+++ b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.tr.xlf
@@ -33,15 +33,19 @@ Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</source>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</source>
         <target state="new">Block Structure Guides;
 Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</target>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</target>
         <note />
       </trans-unit>
       <trans-unit id="CodeFixesPageKeywords">
diff --git a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.zh-Hans.xlf b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.zh-Hans.xlf
index f74663ee264..d664fbf723c 100644
--- a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.zh-Hans.xlf
+++ b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.zh-Hans.xlf
@@ -33,15 +33,19 @@ Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</source>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</source>
         <target state="new">Block Structure Guides;
 Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</target>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</target>
         <note />
       </trans-unit>
       <trans-unit id="CodeFixesPageKeywords">
diff --git a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.zh-Hant.xlf b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.zh-Hant.xlf
index 783fa6c7329..0ab59331fa4 100644
--- a/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.zh-Hant.xlf
+++ b/vsintegration/src/FSharp.Editor/xlf/FSharp.Editor.zh-Hant.xlf
@@ -33,15 +33,19 @@ Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</source>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</source>
         <target state="new">Block Structure Guides;
 Show structure guidelines for F# code;
 Outlining;
 Show outlining and collapsible nodes for F# code;
 Inline hints;
-Display inline type hints (experimental);
-Display inline parameter name hints (experimental);Beer</target>
+Display inline type hints (preview);
+Display inline parameter name hints (preview);Beer;
+Live Buffers;
+Use live (unsaved) buffers for checking</target>
         <note />
       </trans-unit>
       <trans-unit id="CodeFixesPageKeywords">
diff --git a/vsintegration/src/FSharp.UIResources/AdvancedOptionsControl.xaml b/vsintegration/src/FSharp.UIResources/AdvancedOptionsControl.xaml
index 1a80650b15b..ad43ae05717 100644
--- a/vsintegration/src/FSharp.UIResources/AdvancedOptionsControl.xaml
+++ b/vsintegration/src/FSharp.UIResources/AdvancedOptionsControl.xaml
@@ -32,6 +32,10 @@
                                   Content="{x:Static local:Strings.Show_Inline_Parameter_Name_Hints}"/>
                     </StackPanel>
                 </GroupBox>
+                <GroupBox Header="{x:Static local:Strings.LiveBuffers}">
+                    <CheckBox x:Name="toggleLiveBuffers" IsChecked="{Binding IsLiveBuffersEnabled}"
+                              Content="{x:Static local:Strings.Enable_Live_Buffers}"/>
+                </GroupBox>
             </StackPanel>
         </ScrollViewer>
     </Grid>
diff --git a/vsintegration/src/FSharp.UIResources/Strings.Designer.cs b/vsintegration/src/FSharp.UIResources/Strings.Designer.cs
index 0af8d70d3b4..8e3e92323e1 100644
--- a/vsintegration/src/FSharp.UIResources/Strings.Designer.cs
+++ b/vsintegration/src/FSharp.UIResources/Strings.Designer.cs
@@ -141,6 +141,15 @@ public static string Enable_in_memory_cross_project_references {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Use live (unsaved) buffers for checking (restart required).
+        /// </summary>
+        public static string Enable_Live_Buffers {
+            get {
+                return ResourceManager.GetString("Enable_Live_Buffers", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Enable parallel type checking with signature files.
         /// </summary>
@@ -249,6 +258,15 @@ public static string Language_Service_Performance {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Live Buffers (experimental).
+        /// </summary>
+        public static string LiveBuffers {
+            get {
+                return ResourceManager.GetString("LiveBuffers", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Navigation links.
         /// </summary>
@@ -322,7 +340,7 @@ public static string Show_guides {
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Display inline parameter name hints (experimental).
+        ///   Looks up a localized string similar to Display inline parameter name hints (preview).
         /// </summary>
         public static string Show_Inline_Parameter_Name_Hints {
             get {
@@ -331,7 +349,7 @@ public static string Show_Inline_Parameter_Name_Hints {
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Display inline type hints (experimental).
+        ///   Looks up a localized string similar to Display inline type hints (preview).
         /// </summary>
         public static string Show_Inline_Type_Hints {
             get {
diff --git a/vsintegration/src/FSharp.UIResources/Strings.resx b/vsintegration/src/FSharp.UIResources/Strings.resx
index 95e7f98231a..e97f18d0ecc 100644
--- a/vsintegration/src/FSharp.UIResources/Strings.resx
+++ b/vsintegration/src/FSharp.UIResources/Strings.resx
@@ -181,7 +181,7 @@
     <value>Inline Hints</value>
   </data>
   <data name="Show_Inline_Type_Hints" xml:space="preserve">
-    <value>Display inline type hints (experimental)</value>
+    <value>Display inline type hints (preview)</value>
   </data>
   <data name="Time_until_stale_completion" xml:space="preserve">
     <value>Time until stale results are used (in milliseconds)</value>
@@ -232,7 +232,7 @@
     <value>Enable parallel reference resolution</value>
   </data>
   <data name="Show_Inline_Parameter_Name_Hints" xml:space="preserve">
-    <value>Display inline parameter name hints (experimental)</value>
+    <value>Display inline parameter name hints (preview)</value>
   </data>
   <data name="Enable_Fast_Find_References" xml:space="preserve">
     <value>Enable fast find references &amp; rename (experimental)</value>
@@ -240,4 +240,10 @@
   <data name="Find_References_Performance" xml:space="preserve">
     <value>Find References Performance Options</value>
   </data>
+  <data name="Enable_Live_Buffers" xml:space="preserve">
+    <value>Use live (unsaved) buffers for checking (restart required)</value>
+  </data>
+  <data name="LiveBuffers" xml:space="preserve">
+    <value>Live Buffers (experimental)</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/vsintegration/src/FSharp.UIResources/xlf/Strings.cs.xlf b/vsintegration/src/FSharp.UIResources/xlf/Strings.cs.xlf
index 6be46211969..9289f9407c7 100644
--- a/vsintegration/src/FSharp.UIResources/xlf/Strings.cs.xlf
+++ b/vsintegration/src/FSharp.UIResources/xlf/Strings.cs.xlf
@@ -9,17 +9,22 @@
       </trans-unit>
       <trans-unit id="Enable_Fast_Find_References">
         <source>Enable fast find references &amp; rename (experimental)</source>
-        <target state="new">Enable fast find references &amp; rename (experimental)</target>
+        <target state="translated">Povolit odkazy rychlého hledání a přejmenování (experimentální)</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Enable_Live_Buffers">
+        <source>Use live (unsaved) buffers for checking (restart required)</source>
+        <target state="new">Use live (unsaved) buffers for checking (restart required)</target>
         <note />
       </trans-unit>
       <trans-unit id="Find_References_Performance">
         <source>Find References Performance Options</source>
-        <target state="new">Find References Performance Options</target>
+        <target state="translated">Najít možnosti výkonu odkazů</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
         <source>Inline Hints</source>
-        <target state="new">Inline Hints</target>
+        <target state="translated">Vložené nápovědy</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Fixes">
@@ -39,12 +44,12 @@
       </trans-unit>
       <trans-unit id="Enable_Parallel_Checking_With_Signature_Files">
         <source>Enable parallel type checking with signature files</source>
-        <target state="new">Enable parallel type checking with signature files</target>
+        <target state="translated">Povolit paralelní kontrolu typů pomocí souborů podpisu</target>
         <note />
       </trans-unit>
       <trans-unit id="Enable_Parallel_Reference_Resolution">
         <source>Enable parallel reference resolution</source>
-        <target state="new">Enable parallel reference resolution</target>
+        <target state="translated">Povolit paralelní referenční rozlišení</target>
         <note />
       </trans-unit>
       <trans-unit id="Language_Service_Performance">
@@ -62,6 +67,11 @@
         <target state="translated">_Tečkované podtržení</target>
         <note />
       </trans-unit>
+      <trans-unit id="LiveBuffers">
+        <source>Live Buffers (experimental)</source>
+        <target state="new">Live Buffers (experimental)</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Navigation_links">
         <source>Navigation links</source>
         <target state="translated">Navigační odkazy</target>
@@ -69,17 +79,17 @@
       </trans-unit>
       <trans-unit id="Parallelization">
         <source>Parallelization (requires restart)</source>
-        <target state="new">Parallelization (requires restart)</target>
+        <target state="translated">Paralelizace (vyžaduje restartování)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Parameter_Name_Hints">
-        <source>Display inline parameter name hints (experimental)</source>
-        <target state="new">Display inline parameter name hints (experimental)</target>
+        <source>Display inline parameter name hints (preview)</source>
+        <target state="needs-review-translation">Zobrazit nápovědy k názvům vložených parametrů (experimentální)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Type_Hints">
-        <source>Display inline type hints (experimental)</source>
-        <target state="new">Display inline type hints (experimental)</target>
+        <source>Display inline type hints (preview)</source>
+        <target state="needs-review-translation">Zobrazení tipů pro vložený typ (experimentální)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_all_symbols">
diff --git a/vsintegration/src/FSharp.UIResources/xlf/Strings.de.xlf b/vsintegration/src/FSharp.UIResources/xlf/Strings.de.xlf
index 3011cc25b9c..d14b590f5b3 100644
--- a/vsintegration/src/FSharp.UIResources/xlf/Strings.de.xlf
+++ b/vsintegration/src/FSharp.UIResources/xlf/Strings.de.xlf
@@ -9,17 +9,22 @@
       </trans-unit>
       <trans-unit id="Enable_Fast_Find_References">
         <source>Enable fast find references &amp; rename (experimental)</source>
-        <target state="new">Enable fast find references &amp; rename (experimental)</target>
+        <target state="translated">Schnellsuche und Umbenennen von Verweisen aktivieren (experimentell)</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Enable_Live_Buffers">
+        <source>Use live (unsaved) buffers for checking (restart required)</source>
+        <target state="new">Use live (unsaved) buffers for checking (restart required)</target>
         <note />
       </trans-unit>
       <trans-unit id="Find_References_Performance">
         <source>Find References Performance Options</source>
-        <target state="new">Find References Performance Options</target>
+        <target state="translated">Leistungsoptionen für Verweise suchen</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
         <source>Inline Hints</source>
-        <target state="new">Inline Hints</target>
+        <target state="translated">Inlinehinweise</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Fixes">
@@ -39,12 +44,12 @@
       </trans-unit>
       <trans-unit id="Enable_Parallel_Checking_With_Signature_Files">
         <source>Enable parallel type checking with signature files</source>
-        <target state="new">Enable parallel type checking with signature files</target>
+        <target state="translated">Parallele Typüberprüfung mit Signaturdateien aktivieren</target>
         <note />
       </trans-unit>
       <trans-unit id="Enable_Parallel_Reference_Resolution">
         <source>Enable parallel reference resolution</source>
-        <target state="new">Enable parallel reference resolution</target>
+        <target state="translated">Parallele Verweisauflösung aktivieren</target>
         <note />
       </trans-unit>
       <trans-unit id="Language_Service_Performance">
@@ -62,6 +67,11 @@
         <target state="translated">Ge_punktete Unterstreichung</target>
         <note />
       </trans-unit>
+      <trans-unit id="LiveBuffers">
+        <source>Live Buffers (experimental)</source>
+        <target state="new">Live Buffers (experimental)</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Navigation_links">
         <source>Navigation links</source>
         <target state="translated">Navigationslinks</target>
@@ -69,17 +79,17 @@
       </trans-unit>
       <trans-unit id="Parallelization">
         <source>Parallelization (requires restart)</source>
-        <target state="new">Parallelization (requires restart)</target>
+        <target state="translated">Parallelisierung (Neustart erforderlich)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Parameter_Name_Hints">
-        <source>Display inline parameter name hints (experimental)</source>
-        <target state="new">Display inline parameter name hints (experimental)</target>
+        <source>Display inline parameter name hints (preview)</source>
+        <target state="needs-review-translation">Hinweise zu Inlineparameternamen anzeigen (experimentell)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Type_Hints">
-        <source>Display inline type hints (experimental)</source>
-        <target state="new">Display inline type hints (experimental)</target>
+        <source>Display inline type hints (preview)</source>
+        <target state="needs-review-translation">Hinweise für Inlinetypen anzeigen (experimentell)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_all_symbols">
diff --git a/vsintegration/src/FSharp.UIResources/xlf/Strings.es.xlf b/vsintegration/src/FSharp.UIResources/xlf/Strings.es.xlf
index 35568eda7a0..5c807e55d08 100644
--- a/vsintegration/src/FSharp.UIResources/xlf/Strings.es.xlf
+++ b/vsintegration/src/FSharp.UIResources/xlf/Strings.es.xlf
@@ -9,17 +9,22 @@
       </trans-unit>
       <trans-unit id="Enable_Fast_Find_References">
         <source>Enable fast find references &amp; rename (experimental)</source>
-        <target state="new">Enable fast find references &amp; rename (experimental)</target>
+        <target state="translated">Habilitar referencias de búsqueda rápida y cambio de nombre (experimental)</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Enable_Live_Buffers">
+        <source>Use live (unsaved) buffers for checking (restart required)</source>
+        <target state="new">Use live (unsaved) buffers for checking (restart required)</target>
         <note />
       </trans-unit>
       <trans-unit id="Find_References_Performance">
         <source>Find References Performance Options</source>
-        <target state="new">Find References Performance Options</target>
+        <target state="translated">Buscar opciones de rendimiento de referencias</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
         <source>Inline Hints</source>
-        <target state="new">Inline Hints</target>
+        <target state="translated">Sugerencias insertadas</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Fixes">
@@ -39,12 +44,12 @@
       </trans-unit>
       <trans-unit id="Enable_Parallel_Checking_With_Signature_Files">
         <source>Enable parallel type checking with signature files</source>
-        <target state="new">Enable parallel type checking with signature files</target>
+        <target state="translated">Habilitar la comprobación de tipos paralelos con archivos de firma</target>
         <note />
       </trans-unit>
       <trans-unit id="Enable_Parallel_Reference_Resolution">
         <source>Enable parallel reference resolution</source>
-        <target state="new">Enable parallel reference resolution</target>
+        <target state="translated">Habilitar resolución de referencias paralelas</target>
         <note />
       </trans-unit>
       <trans-unit id="Language_Service_Performance">
@@ -62,6 +67,11 @@
         <target state="translated">S_ubrayado punto</target>
         <note />
       </trans-unit>
+      <trans-unit id="LiveBuffers">
+        <source>Live Buffers (experimental)</source>
+        <target state="new">Live Buffers (experimental)</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Navigation_links">
         <source>Navigation links</source>
         <target state="translated">Vínculos de navegación</target>
@@ -69,17 +79,17 @@
       </trans-unit>
       <trans-unit id="Parallelization">
         <source>Parallelization (requires restart)</source>
-        <target state="new">Parallelization (requires restart)</target>
+        <target state="translated">Paralelización (requiere reiniciar)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Parameter_Name_Hints">
-        <source>Display inline parameter name hints (experimental)</source>
-        <target state="new">Display inline parameter name hints (experimental)</target>
+        <source>Display inline parameter name hints (preview)</source>
+        <target state="needs-review-translation">Mostrar sugerencias de nombre de parámetro insertado (experimental)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Type_Hints">
-        <source>Display inline type hints (experimental)</source>
-        <target state="new">Display inline type hints (experimental)</target>
+        <source>Display inline type hints (preview)</source>
+        <target state="needs-review-translation">Mostrar sugerencias de tipo insertadas (experimental)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_all_symbols">
diff --git a/vsintegration/src/FSharp.UIResources/xlf/Strings.fr.xlf b/vsintegration/src/FSharp.UIResources/xlf/Strings.fr.xlf
index 68f57243011..04b999dbe0a 100644
--- a/vsintegration/src/FSharp.UIResources/xlf/Strings.fr.xlf
+++ b/vsintegration/src/FSharp.UIResources/xlf/Strings.fr.xlf
@@ -9,17 +9,22 @@
       </trans-unit>
       <trans-unit id="Enable_Fast_Find_References">
         <source>Enable fast find references &amp; rename (experimental)</source>
-        <target state="new">Enable fast find references &amp; rename (experimental)</target>
+        <target state="translated">Activer les références de recherche rapide et renommer (expérimental)</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Enable_Live_Buffers">
+        <source>Use live (unsaved) buffers for checking (restart required)</source>
+        <target state="new">Use live (unsaved) buffers for checking (restart required)</target>
         <note />
       </trans-unit>
       <trans-unit id="Find_References_Performance">
         <source>Find References Performance Options</source>
-        <target state="new">Find References Performance Options</target>
+        <target state="translated">Options de performances de recherche de références</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
         <source>Inline Hints</source>
-        <target state="new">Inline Hints</target>
+        <target state="translated">Indicateurs inline</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Fixes">
@@ -39,12 +44,12 @@
       </trans-unit>
       <trans-unit id="Enable_Parallel_Checking_With_Signature_Files">
         <source>Enable parallel type checking with signature files</source>
-        <target state="new">Enable parallel type checking with signature files</target>
+        <target state="translated">Activer la vérification de type parallèle avec les fichiers de signature</target>
         <note />
       </trans-unit>
       <trans-unit id="Enable_Parallel_Reference_Resolution">
         <source>Enable parallel reference resolution</source>
-        <target state="new">Enable parallel reference resolution</target>
+        <target state="translated">Activer la résolution de référence parallèle</target>
         <note />
       </trans-unit>
       <trans-unit id="Language_Service_Performance">
@@ -62,6 +67,11 @@
         <target state="translated">S_oulignement avec des points</target>
         <note />
       </trans-unit>
+      <trans-unit id="LiveBuffers">
+        <source>Live Buffers (experimental)</source>
+        <target state="new">Live Buffers (experimental)</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Navigation_links">
         <source>Navigation links</source>
         <target state="translated">Liens de navigation</target>
@@ -69,17 +79,17 @@
       </trans-unit>
       <trans-unit id="Parallelization">
         <source>Parallelization (requires restart)</source>
-        <target state="new">Parallelization (requires restart)</target>
+        <target state="translated">Parallélisation (Nécessite un redémarrage)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Parameter_Name_Hints">
-        <source>Display inline parameter name hints (experimental)</source>
-        <target state="new">Display inline parameter name hints (experimental)</target>
+        <source>Display inline parameter name hints (preview)</source>
+        <target state="needs-review-translation">Afficher les indicateurs de nom de paramètre en ligne (expérimental)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Type_Hints">
-        <source>Display inline type hints (experimental)</source>
-        <target state="new">Display inline type hints (experimental)</target>
+        <source>Display inline type hints (preview)</source>
+        <target state="needs-review-translation">Afficher les indicateurs de type inline (expérimental)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_all_symbols">
diff --git a/vsintegration/src/FSharp.UIResources/xlf/Strings.it.xlf b/vsintegration/src/FSharp.UIResources/xlf/Strings.it.xlf
index 523841ce7e2..7351f82dc40 100644
--- a/vsintegration/src/FSharp.UIResources/xlf/Strings.it.xlf
+++ b/vsintegration/src/FSharp.UIResources/xlf/Strings.it.xlf
@@ -9,17 +9,22 @@
       </trans-unit>
       <trans-unit id="Enable_Fast_Find_References">
         <source>Enable fast find references &amp; rename (experimental)</source>
-        <target state="new">Enable fast find references &amp; rename (experimental)</target>
+        <target state="translated">Abilitare la ricerca rapida dei riferimenti e la ridenominazione (sperimentale)</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Enable_Live_Buffers">
+        <source>Use live (unsaved) buffers for checking (restart required)</source>
+        <target state="new">Use live (unsaved) buffers for checking (restart required)</target>
         <note />
       </trans-unit>
       <trans-unit id="Find_References_Performance">
         <source>Find References Performance Options</source>
-        <target state="new">Find References Performance Options</target>
+        <target state="translated">Trovare opzioni prestazioni riferimenti</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
         <source>Inline Hints</source>
-        <target state="new">Inline Hints</target>
+        <target state="translated">Suggerimenti inline</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Fixes">
@@ -39,12 +44,12 @@
       </trans-unit>
       <trans-unit id="Enable_Parallel_Checking_With_Signature_Files">
         <source>Enable parallel type checking with signature files</source>
-        <target state="new">Enable parallel type checking with signature files</target>
+        <target state="translated">Abilitare il controllo dei tipi paralleli con i file di firma</target>
         <note />
       </trans-unit>
       <trans-unit id="Enable_Parallel_Reference_Resolution">
         <source>Enable parallel reference resolution</source>
-        <target state="new">Enable parallel reference resolution</target>
+        <target state="translated">Abilitare risoluzione riferimenti paralleli</target>
         <note />
       </trans-unit>
       <trans-unit id="Language_Service_Performance">
@@ -62,6 +67,11 @@
         <target state="translated">Sottolineatura _punteggiata</target>
         <note />
       </trans-unit>
+      <trans-unit id="LiveBuffers">
+        <source>Live Buffers (experimental)</source>
+        <target state="new">Live Buffers (experimental)</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Navigation_links">
         <source>Navigation links</source>
         <target state="translated">Collegamenti di navigazione</target>
@@ -69,17 +79,17 @@
       </trans-unit>
       <trans-unit id="Parallelization">
         <source>Parallelization (requires restart)</source>
-        <target state="new">Parallelization (requires restart)</target>
+        <target state="translated">Parallelizzazione (richiede il riavvio)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Parameter_Name_Hints">
-        <source>Display inline parameter name hints (experimental)</source>
-        <target state="new">Display inline parameter name hints (experimental)</target>
+        <source>Display inline parameter name hints (preview)</source>
+        <target state="needs-review-translation">Visualizza suggerimenti per i nomi di parametro inline (sperimentale)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Type_Hints">
-        <source>Display inline type hints (experimental)</source>
-        <target state="new">Display inline type hints (experimental)</target>
+        <source>Display inline type hints (preview)</source>
+        <target state="needs-review-translation">Visualizzare suggerimenti di tipo inline (sperimentale)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_all_symbols">
diff --git a/vsintegration/src/FSharp.UIResources/xlf/Strings.ja.xlf b/vsintegration/src/FSharp.UIResources/xlf/Strings.ja.xlf
index 4f02151e44e..597fd8aec1b 100644
--- a/vsintegration/src/FSharp.UIResources/xlf/Strings.ja.xlf
+++ b/vsintegration/src/FSharp.UIResources/xlf/Strings.ja.xlf
@@ -9,17 +9,22 @@
       </trans-unit>
       <trans-unit id="Enable_Fast_Find_References">
         <source>Enable fast find references &amp; rename (experimental)</source>
-        <target state="new">Enable fast find references &amp; rename (experimental)</target>
+        <target state="translated">高速検索参照の有効化と名前の変更 (試験段階)</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Enable_Live_Buffers">
+        <source>Use live (unsaved) buffers for checking (restart required)</source>
+        <target state="new">Use live (unsaved) buffers for checking (restart required)</target>
         <note />
       </trans-unit>
       <trans-unit id="Find_References_Performance">
         <source>Find References Performance Options</source>
-        <target state="new">Find References Performance Options</target>
+        <target state="translated">参照の検索のパフォーマンス オプション</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
         <source>Inline Hints</source>
-        <target state="new">Inline Hints</target>
+        <target state="translated">インラインのヒント</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Fixes">
@@ -39,12 +44,12 @@
       </trans-unit>
       <trans-unit id="Enable_Parallel_Checking_With_Signature_Files">
         <source>Enable parallel type checking with signature files</source>
-        <target state="new">Enable parallel type checking with signature files</target>
+        <target state="translated">署名ファイルを使用して並列型チェックを有効にする</target>
         <note />
       </trans-unit>
       <trans-unit id="Enable_Parallel_Reference_Resolution">
         <source>Enable parallel reference resolution</source>
-        <target state="new">Enable parallel reference resolution</target>
+        <target state="translated">並列参照解決を有効にする</target>
         <note />
       </trans-unit>
       <trans-unit id="Language_Service_Performance">
@@ -62,6 +67,11 @@
         <target state="translated">点線の下線(_O)</target>
         <note />
       </trans-unit>
+      <trans-unit id="LiveBuffers">
+        <source>Live Buffers (experimental)</source>
+        <target state="new">Live Buffers (experimental)</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Navigation_links">
         <source>Navigation links</source>
         <target state="translated">ナビゲーション リンク</target>
@@ -69,17 +79,17 @@
       </trans-unit>
       <trans-unit id="Parallelization">
         <source>Parallelization (requires restart)</source>
-        <target state="new">Parallelization (requires restart)</target>
+        <target state="translated">並列化 (再起動が必要)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Parameter_Name_Hints">
-        <source>Display inline parameter name hints (experimental)</source>
-        <target state="new">Display inline parameter name hints (experimental)</target>
+        <source>Display inline parameter name hints (preview)</source>
+        <target state="needs-review-translation">インライン パラメーター名のヒントを表示する (試験段階)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Type_Hints">
-        <source>Display inline type hints (experimental)</source>
-        <target state="new">Display inline type hints (experimental)</target>
+        <source>Display inline type hints (preview)</source>
+        <target state="needs-review-translation">インライン型のヒントを表示する (試験段階)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_all_symbols">
diff --git a/vsintegration/src/FSharp.UIResources/xlf/Strings.ko.xlf b/vsintegration/src/FSharp.UIResources/xlf/Strings.ko.xlf
index 0ea54bedbba..ad8d15851cb 100644
--- a/vsintegration/src/FSharp.UIResources/xlf/Strings.ko.xlf
+++ b/vsintegration/src/FSharp.UIResources/xlf/Strings.ko.xlf
@@ -9,17 +9,22 @@
       </trans-unit>
       <trans-unit id="Enable_Fast_Find_References">
         <source>Enable fast find references &amp; rename (experimental)</source>
-        <target state="new">Enable fast find references &amp; rename (experimental)</target>
+        <target state="translated">빠른 찾기 참조 및 이름 바꾸기 사용(실험적)</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Enable_Live_Buffers">
+        <source>Use live (unsaved) buffers for checking (restart required)</source>
+        <target state="new">Use live (unsaved) buffers for checking (restart required)</target>
         <note />
       </trans-unit>
       <trans-unit id="Find_References_Performance">
         <source>Find References Performance Options</source>
-        <target state="new">Find References Performance Options</target>
+        <target state="translated">참조 성능 옵션 찾기</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
         <source>Inline Hints</source>
-        <target state="new">Inline Hints</target>
+        <target state="translated">인라인 힌트</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Fixes">
@@ -39,12 +44,12 @@
       </trans-unit>
       <trans-unit id="Enable_Parallel_Checking_With_Signature_Files">
         <source>Enable parallel type checking with signature files</source>
-        <target state="new">Enable parallel type checking with signature files</target>
+        <target state="translated">서명 파일로 병렬 유형 검사 사용</target>
         <note />
       </trans-unit>
       <trans-unit id="Enable_Parallel_Reference_Resolution">
         <source>Enable parallel reference resolution</source>
-        <target state="new">Enable parallel reference resolution</target>
+        <target state="translated">병렬 참조 해상도 사용</target>
         <note />
       </trans-unit>
       <trans-unit id="Language_Service_Performance">
@@ -62,6 +67,11 @@
         <target state="translated">점 밑줄(_O)</target>
         <note />
       </trans-unit>
+      <trans-unit id="LiveBuffers">
+        <source>Live Buffers (experimental)</source>
+        <target state="new">Live Buffers (experimental)</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Navigation_links">
         <source>Navigation links</source>
         <target state="translated">탐색 링크</target>
@@ -69,17 +79,17 @@
       </trans-unit>
       <trans-unit id="Parallelization">
         <source>Parallelization (requires restart)</source>
-        <target state="new">Parallelization (requires restart)</target>
+        <target state="translated">병렬화(다시 시작 필요)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Parameter_Name_Hints">
-        <source>Display inline parameter name hints (experimental)</source>
-        <target state="new">Display inline parameter name hints (experimental)</target>
+        <source>Display inline parameter name hints (preview)</source>
+        <target state="needs-review-translation">인라인 매개 변수 이름 힌트 표시(실험적)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Type_Hints">
-        <source>Display inline type hints (experimental)</source>
-        <target state="new">Display inline type hints (experimental)</target>
+        <source>Display inline type hints (preview)</source>
+        <target state="needs-review-translation">인라인 유형 힌트 표시(실험적)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_all_symbols">
diff --git a/vsintegration/src/FSharp.UIResources/xlf/Strings.pl.xlf b/vsintegration/src/FSharp.UIResources/xlf/Strings.pl.xlf
index c11bdce4a7b..2fd2a1d7aa7 100644
--- a/vsintegration/src/FSharp.UIResources/xlf/Strings.pl.xlf
+++ b/vsintegration/src/FSharp.UIResources/xlf/Strings.pl.xlf
@@ -9,17 +9,22 @@
       </trans-unit>
       <trans-unit id="Enable_Fast_Find_References">
         <source>Enable fast find references &amp; rename (experimental)</source>
-        <target state="new">Enable fast find references &amp; rename (experimental)</target>
+        <target state="translated">Włącz szybkie znajdowanie odwołań i zmień nazwę (eksperymentalne)</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Enable_Live_Buffers">
+        <source>Use live (unsaved) buffers for checking (restart required)</source>
+        <target state="new">Use live (unsaved) buffers for checking (restart required)</target>
         <note />
       </trans-unit>
       <trans-unit id="Find_References_Performance">
         <source>Find References Performance Options</source>
-        <target state="new">Find References Performance Options</target>
+        <target state="translated">Opcje wydajności znajdowania odwołań</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
         <source>Inline Hints</source>
-        <target state="new">Inline Hints</target>
+        <target state="translated">Wskazówki w tekście</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Fixes">
@@ -39,12 +44,12 @@
       </trans-unit>
       <trans-unit id="Enable_Parallel_Checking_With_Signature_Files">
         <source>Enable parallel type checking with signature files</source>
-        <target state="new">Enable parallel type checking with signature files</target>
+        <target state="translated">Włącz równoległe sprawdzanie typów za pomocą plików podpisu</target>
         <note />
       </trans-unit>
       <trans-unit id="Enable_Parallel_Reference_Resolution">
         <source>Enable parallel reference resolution</source>
-        <target state="new">Enable parallel reference resolution</target>
+        <target state="translated">Włącz równoległe rozpoznawanie odwołań</target>
         <note />
       </trans-unit>
       <trans-unit id="Language_Service_Performance">
@@ -62,6 +67,11 @@
         <target state="translated">P_odkreślenie z kropek</target>
         <note />
       </trans-unit>
+      <trans-unit id="LiveBuffers">
+        <source>Live Buffers (experimental)</source>
+        <target state="new">Live Buffers (experimental)</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Navigation_links">
         <source>Navigation links</source>
         <target state="translated">Linki nawigacyjne</target>
@@ -69,17 +79,17 @@
       </trans-unit>
       <trans-unit id="Parallelization">
         <source>Parallelization (requires restart)</source>
-        <target state="new">Parallelization (requires restart)</target>
+        <target state="translated">Równoległość (wymaga ponownego uruchomienia)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Parameter_Name_Hints">
-        <source>Display inline parameter name hints (experimental)</source>
-        <target state="new">Display inline parameter name hints (experimental)</target>
+        <source>Display inline parameter name hints (preview)</source>
+        <target state="needs-review-translation">Wyświetlaj wbudowane wskazówki dotyczące nazw parametrów (eksperymentalne)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Type_Hints">
-        <source>Display inline type hints (experimental)</source>
-        <target state="new">Display inline type hints (experimental)</target>
+        <source>Display inline type hints (preview)</source>
+        <target state="needs-review-translation">Wyświetl wskazówki typu wbudowanego (eksperymentalne)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_all_symbols">
diff --git a/vsintegration/src/FSharp.UIResources/xlf/Strings.pt-BR.xlf b/vsintegration/src/FSharp.UIResources/xlf/Strings.pt-BR.xlf
index 50b7e6f8000..c3b72a1253d 100644
--- a/vsintegration/src/FSharp.UIResources/xlf/Strings.pt-BR.xlf
+++ b/vsintegration/src/FSharp.UIResources/xlf/Strings.pt-BR.xlf
@@ -9,17 +9,22 @@
       </trans-unit>
       <trans-unit id="Enable_Fast_Find_References">
         <source>Enable fast find references &amp; rename (experimental)</source>
-        <target state="new">Enable fast find references &amp; rename (experimental)</target>
+        <target state="translated">Habilitar localizar referências rapidamente e renomear (experimental)</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Enable_Live_Buffers">
+        <source>Use live (unsaved) buffers for checking (restart required)</source>
+        <target state="new">Use live (unsaved) buffers for checking (restart required)</target>
         <note />
       </trans-unit>
       <trans-unit id="Find_References_Performance">
         <source>Find References Performance Options</source>
-        <target state="new">Find References Performance Options</target>
+        <target state="translated">Opções de Localizar Referências de Desempenho</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
         <source>Inline Hints</source>
-        <target state="new">Inline Hints</target>
+        <target state="translated">Dicas Embutidas</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Fixes">
@@ -39,12 +44,12 @@
       </trans-unit>
       <trans-unit id="Enable_Parallel_Checking_With_Signature_Files">
         <source>Enable parallel type checking with signature files</source>
-        <target state="new">Enable parallel type checking with signature files</target>
+        <target state="translated">Habilitar a verificação de tipo paralelo com arquivos de assinatura</target>
         <note />
       </trans-unit>
       <trans-unit id="Enable_Parallel_Reference_Resolution">
         <source>Enable parallel reference resolution</source>
-        <target state="new">Enable parallel reference resolution</target>
+        <target state="translated">Habilitar a resolução de referência paralela</target>
         <note />
       </trans-unit>
       <trans-unit id="Language_Service_Performance">
@@ -62,6 +67,11 @@
         <target state="translated">Sublinhado p_ontilhado</target>
         <note />
       </trans-unit>
+      <trans-unit id="LiveBuffers">
+        <source>Live Buffers (experimental)</source>
+        <target state="new">Live Buffers (experimental)</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Navigation_links">
         <source>Navigation links</source>
         <target state="translated">Links de navegação</target>
@@ -69,17 +79,17 @@
       </trans-unit>
       <trans-unit id="Parallelization">
         <source>Parallelization (requires restart)</source>
-        <target state="new">Parallelization (requires restart)</target>
+        <target state="translated">Paralelização (requer reinicialização)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Parameter_Name_Hints">
-        <source>Display inline parameter name hints (experimental)</source>
-        <target state="new">Display inline parameter name hints (experimental)</target>
+        <source>Display inline parameter name hints (preview)</source>
+        <target state="needs-review-translation">Exibir dicas de nome de parâmetro embutidas (experimental)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Type_Hints">
-        <source>Display inline type hints (experimental)</source>
-        <target state="new">Display inline type hints (experimental)</target>
+        <source>Display inline type hints (preview)</source>
+        <target state="needs-review-translation">Exibir as dicas de tipo embutido (experimental)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_all_symbols">
diff --git a/vsintegration/src/FSharp.UIResources/xlf/Strings.ru.xlf b/vsintegration/src/FSharp.UIResources/xlf/Strings.ru.xlf
index 4dcb753f0c9..8bb9fff9020 100644
--- a/vsintegration/src/FSharp.UIResources/xlf/Strings.ru.xlf
+++ b/vsintegration/src/FSharp.UIResources/xlf/Strings.ru.xlf
@@ -9,17 +9,22 @@
       </trans-unit>
       <trans-unit id="Enable_Fast_Find_References">
         <source>Enable fast find references &amp; rename (experimental)</source>
-        <target state="new">Enable fast find references &amp; rename (experimental)</target>
+        <target state="translated">Включить быстрый поиск ссылок и переименование (экспериментальная версия)</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Enable_Live_Buffers">
+        <source>Use live (unsaved) buffers for checking (restart required)</source>
+        <target state="new">Use live (unsaved) buffers for checking (restart required)</target>
         <note />
       </trans-unit>
       <trans-unit id="Find_References_Performance">
         <source>Find References Performance Options</source>
-        <target state="new">Find References Performance Options</target>
+        <target state="translated">Параметры производительности поиска ссылок</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
         <source>Inline Hints</source>
-        <target state="new">Inline Hints</target>
+        <target state="translated">Встроенные подсказки</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Fixes">
@@ -39,12 +44,12 @@
       </trans-unit>
       <trans-unit id="Enable_Parallel_Checking_With_Signature_Files">
         <source>Enable parallel type checking with signature files</source>
-        <target state="new">Enable parallel type checking with signature files</target>
+        <target state="translated">Включить параллельную проверку типа с файлами подписей</target>
         <note />
       </trans-unit>
       <trans-unit id="Enable_Parallel_Reference_Resolution">
         <source>Enable parallel reference resolution</source>
-        <target state="new">Enable parallel reference resolution</target>
+        <target state="translated">Включить параллельное разрешение ссылок</target>
         <note />
       </trans-unit>
       <trans-unit id="Language_Service_Performance">
@@ -62,6 +67,11 @@
         <target state="translated">Пу_нктирное подчеркивание</target>
         <note />
       </trans-unit>
+      <trans-unit id="LiveBuffers">
+        <source>Live Buffers (experimental)</source>
+        <target state="new">Live Buffers (experimental)</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Navigation_links">
         <source>Navigation links</source>
         <target state="translated">Ссылки навигации</target>
@@ -69,17 +79,17 @@
       </trans-unit>
       <trans-unit id="Parallelization">
         <source>Parallelization (requires restart)</source>
-        <target state="new">Parallelization (requires restart)</target>
+        <target state="translated">Параллелизация (требуется перезапуск)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Parameter_Name_Hints">
-        <source>Display inline parameter name hints (experimental)</source>
-        <target state="new">Display inline parameter name hints (experimental)</target>
+        <source>Display inline parameter name hints (preview)</source>
+        <target state="needs-review-translation">Отображать подсказки для имен встроенных параметров (экспериментальная версия)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Type_Hints">
-        <source>Display inline type hints (experimental)</source>
-        <target state="new">Display inline type hints (experimental)</target>
+        <source>Display inline type hints (preview)</source>
+        <target state="needs-review-translation">Отображать подсказки для встроенных типов (экспериментальная версия)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_all_symbols">
diff --git a/vsintegration/src/FSharp.UIResources/xlf/Strings.tr.xlf b/vsintegration/src/FSharp.UIResources/xlf/Strings.tr.xlf
index 4f4286abe68..9134516abd9 100644
--- a/vsintegration/src/FSharp.UIResources/xlf/Strings.tr.xlf
+++ b/vsintegration/src/FSharp.UIResources/xlf/Strings.tr.xlf
@@ -9,17 +9,22 @@
       </trans-unit>
       <trans-unit id="Enable_Fast_Find_References">
         <source>Enable fast find references &amp; rename (experimental)</source>
-        <target state="new">Enable fast find references &amp; rename (experimental)</target>
+        <target state="translated">Başvuruları hızlı bulma ve yeniden adlandırmayı etkinleştir (deneysel)</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Enable_Live_Buffers">
+        <source>Use live (unsaved) buffers for checking (restart required)</source>
+        <target state="new">Use live (unsaved) buffers for checking (restart required)</target>
         <note />
       </trans-unit>
       <trans-unit id="Find_References_Performance">
         <source>Find References Performance Options</source>
-        <target state="new">Find References Performance Options</target>
+        <target state="translated">Başvuruları Bul Performans Seçenekleri</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
         <source>Inline Hints</source>
-        <target state="new">Inline Hints</target>
+        <target state="translated">Satır İçi İpuçları</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Fixes">
@@ -39,12 +44,12 @@
       </trans-unit>
       <trans-unit id="Enable_Parallel_Checking_With_Signature_Files">
         <source>Enable parallel type checking with signature files</source>
-        <target state="new">Enable parallel type checking with signature files</target>
+        <target state="translated">İmza dosyalarıyla paralel tür denetlemeyi etkinleştir</target>
         <note />
       </trans-unit>
       <trans-unit id="Enable_Parallel_Reference_Resolution">
         <source>Enable parallel reference resolution</source>
-        <target state="new">Enable parallel reference resolution</target>
+        <target state="translated">Paralel başvuru çözümlemeyi etkinleştir</target>
         <note />
       </trans-unit>
       <trans-unit id="Language_Service_Performance">
@@ -62,6 +67,11 @@
         <target state="translated">N_okta alt çizgi</target>
         <note />
       </trans-unit>
+      <trans-unit id="LiveBuffers">
+        <source>Live Buffers (experimental)</source>
+        <target state="new">Live Buffers (experimental)</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Navigation_links">
         <source>Navigation links</source>
         <target state="translated">Gezinti bağlantıları</target>
@@ -69,17 +79,17 @@
       </trans-unit>
       <trans-unit id="Parallelization">
         <source>Parallelization (requires restart)</source>
-        <target state="new">Parallelization (requires restart)</target>
+        <target state="translated">Paralelleştirme (yeniden başlatma gerektirir)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Parameter_Name_Hints">
-        <source>Display inline parameter name hints (experimental)</source>
-        <target state="new">Display inline parameter name hints (experimental)</target>
+        <source>Display inline parameter name hints (preview)</source>
+        <target state="needs-review-translation">Satır içi parametre adı ipuçlarını göster (deneysel)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Type_Hints">
-        <source>Display inline type hints (experimental)</source>
-        <target state="new">Display inline type hints (experimental)</target>
+        <source>Display inline type hints (preview)</source>
+        <target state="needs-review-translation">Satır içi tür ipuçlarını göster (deneysel)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_all_symbols">
diff --git a/vsintegration/src/FSharp.UIResources/xlf/Strings.zh-Hans.xlf b/vsintegration/src/FSharp.UIResources/xlf/Strings.zh-Hans.xlf
index 379907d0d29..cec0e2d1149 100644
--- a/vsintegration/src/FSharp.UIResources/xlf/Strings.zh-Hans.xlf
+++ b/vsintegration/src/FSharp.UIResources/xlf/Strings.zh-Hans.xlf
@@ -9,17 +9,22 @@
       </trans-unit>
       <trans-unit id="Enable_Fast_Find_References">
         <source>Enable fast find references &amp; rename (experimental)</source>
-        <target state="new">Enable fast find references &amp; rename (experimental)</target>
+        <target state="translated">启用快速查找引用和重命名(实验性)</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Enable_Live_Buffers">
+        <source>Use live (unsaved) buffers for checking (restart required)</source>
+        <target state="new">Use live (unsaved) buffers for checking (restart required)</target>
         <note />
       </trans-unit>
       <trans-unit id="Find_References_Performance">
         <source>Find References Performance Options</source>
-        <target state="new">Find References Performance Options</target>
+        <target state="translated">查找引用性能选项</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
         <source>Inline Hints</source>
-        <target state="new">Inline Hints</target>
+        <target state="translated">内联提示</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Fixes">
@@ -39,12 +44,12 @@
       </trans-unit>
       <trans-unit id="Enable_Parallel_Checking_With_Signature_Files">
         <source>Enable parallel type checking with signature files</source>
-        <target state="new">Enable parallel type checking with signature files</target>
+        <target state="translated">使用签名文件启用并行类型检查</target>
         <note />
       </trans-unit>
       <trans-unit id="Enable_Parallel_Reference_Resolution">
         <source>Enable parallel reference resolution</source>
-        <target state="new">Enable parallel reference resolution</target>
+        <target state="translated">启用并行引用解析</target>
         <note />
       </trans-unit>
       <trans-unit id="Language_Service_Performance">
@@ -62,6 +67,11 @@
         <target state="translated">点下划线(_O)</target>
         <note />
       </trans-unit>
+      <trans-unit id="LiveBuffers">
+        <source>Live Buffers (experimental)</source>
+        <target state="new">Live Buffers (experimental)</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Navigation_links">
         <source>Navigation links</source>
         <target state="translated">导航链接</target>
@@ -69,17 +79,17 @@
       </trans-unit>
       <trans-unit id="Parallelization">
         <source>Parallelization (requires restart)</source>
-        <target state="new">Parallelization (requires restart)</target>
+        <target state="translated">并行化(需要重启)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Parameter_Name_Hints">
-        <source>Display inline parameter name hints (experimental)</source>
-        <target state="new">Display inline parameter name hints (experimental)</target>
+        <source>Display inline parameter name hints (preview)</source>
+        <target state="needs-review-translation">显示内联参数名称提示(实验性)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Type_Hints">
-        <source>Display inline type hints (experimental)</source>
-        <target state="new">Display inline type hints (experimental)</target>
+        <source>Display inline type hints (preview)</source>
+        <target state="needs-review-translation">显示内联类型提示(实验性)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_all_symbols">
diff --git a/vsintegration/src/FSharp.UIResources/xlf/Strings.zh-Hant.xlf b/vsintegration/src/FSharp.UIResources/xlf/Strings.zh-Hant.xlf
index 155b2946c2b..268e69e2275 100644
--- a/vsintegration/src/FSharp.UIResources/xlf/Strings.zh-Hant.xlf
+++ b/vsintegration/src/FSharp.UIResources/xlf/Strings.zh-Hant.xlf
@@ -9,17 +9,22 @@
       </trans-unit>
       <trans-unit id="Enable_Fast_Find_References">
         <source>Enable fast find references &amp; rename (experimental)</source>
-        <target state="new">Enable fast find references &amp; rename (experimental)</target>
+        <target state="translated">啟用快速尋找參考和重新命名 (實驗性)</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Enable_Live_Buffers">
+        <source>Use live (unsaved) buffers for checking (restart required)</source>
+        <target state="new">Use live (unsaved) buffers for checking (restart required)</target>
         <note />
       </trans-unit>
       <trans-unit id="Find_References_Performance">
         <source>Find References Performance Options</source>
-        <target state="new">Find References Performance Options</target>
+        <target state="translated">尋找參考效能選項</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
         <source>Inline Hints</source>
-        <target state="new">Inline Hints</target>
+        <target state="translated">內嵌提示</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Fixes">
@@ -39,12 +44,12 @@
       </trans-unit>
       <trans-unit id="Enable_Parallel_Checking_With_Signature_Files">
         <source>Enable parallel type checking with signature files</source>
-        <target state="new">Enable parallel type checking with signature files</target>
+        <target state="translated">啟用簽章檔案的平行類型檢查</target>
         <note />
       </trans-unit>
       <trans-unit id="Enable_Parallel_Reference_Resolution">
         <source>Enable parallel reference resolution</source>
-        <target state="new">Enable parallel reference resolution</target>
+        <target state="translated">啟用平行參考解析</target>
         <note />
       </trans-unit>
       <trans-unit id="Language_Service_Performance">
@@ -62,6 +67,11 @@
         <target state="translated">點線底線(_O)</target>
         <note />
       </trans-unit>
+      <trans-unit id="LiveBuffers">
+        <source>Live Buffers (experimental)</source>
+        <target state="new">Live Buffers (experimental)</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Navigation_links">
         <source>Navigation links</source>
         <target state="translated">導覽連結</target>
@@ -69,17 +79,17 @@
       </trans-unit>
       <trans-unit id="Parallelization">
         <source>Parallelization (requires restart)</source>
-        <target state="new">Parallelization (requires restart)</target>
+        <target state="translated">平行處理 (需要重新開機)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Parameter_Name_Hints">
-        <source>Display inline parameter name hints (experimental)</source>
-        <target state="new">Display inline parameter name hints (experimental)</target>
+        <source>Display inline parameter name hints (preview)</source>
+        <target state="needs-review-translation">顯示內嵌參數名稱提示 (實驗性)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_Inline_Type_Hints">
-        <source>Display inline type hints (experimental)</source>
-        <target state="new">Display inline type hints (experimental)</target>
+        <source>Display inline type hints (preview)</source>
+        <target state="needs-review-translation">顯示內嵌類型提示 (實驗性)</target>
         <note />
       </trans-unit>
       <trans-unit id="Show_all_symbols">
diff --git a/vsintegration/src/FSharp.VS.FSI/fsiLanguageService.fs b/vsintegration/src/FSharp.VS.FSI/fsiLanguageService.fs
index 8de6290a979..b943d3cca13 100644
--- a/vsintegration/src/FSharp.VS.FSI/fsiLanguageService.fs
+++ b/vsintegration/src/FSharp.VS.FSI/fsiLanguageService.fs
@@ -46,6 +46,11 @@ type FsiPropertyPage() =
     [<ResourceDescription(SRProperties.FSharpInteractiveShadowCopyDescr)>]
     member this.FsiShadowCopy with get() = SessionsProperties.fsiShadowCopy and set (x:bool) = SessionsProperties.fsiShadowCopy <- x
 
+    [<ResourceCategory(SRProperties.FSharpInteractiveMisc)>]
+    [<ResourceDisplayName(SRProperties.FSharpInteractiveUseNetCore)>]
+    [<ResourceDescription(SRProperties.FSharpInteractiveUseNetCoreDescr)>]
+    member this.FsiUseNetCore with get() = SessionsProperties.fsiUseNetCore and set (x:bool) = SessionsProperties.fsiUseNetCore <- x
+
     [<ResourceCategory(SRProperties.FSharpInteractiveDebugging)>]
     [<ResourceDisplayName(SRProperties.FSharpInteractiveDebugMode)>]
     [<ResourceDescription(SRProperties.FSharpInteractiveDebugModeDescr)>]
@@ -56,11 +61,6 @@ type FsiPropertyPage() =
     [<ResourceDescription(SRProperties.FSharpInteractivePreviewModeDescr)>]
     member this.FsiPreview with get() = SessionsProperties.fsiPreview and set (x:bool) = SessionsProperties.fsiPreview <- x
 
-    [<ResourceCategory(SRProperties.FSharpInteractivePreview)>]
-    [<ResourceDisplayName(SRProperties.FSharpInteractiveUseNetCore)>]
-    [<ResourceDescription(SRProperties.FSharpInteractiveUseNetCoreDescr)>]
-    member this.FsiUseNetCore with get() = SessionsProperties.fsiUseNetCore and set (x:bool) = SessionsProperties.fsiUseNetCore <- x
-
 // CompletionSet
 type internal FsiCompletionSet(imageList,source:Source) =
     inherit CompletionSet(imageList, source)
diff --git a/vsintegration/tests/FSharp.Editor.Tests/BraceMatchingServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/BraceMatchingServiceTests.fs
index 49b852c5d4a..a5278a27c02 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/BraceMatchingServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/BraceMatchingServiceTests.fs
@@ -3,55 +3,40 @@
 namespace FSharp.Editor.Tests
 
 open System
-open NUnit.Framework
+open Xunit
 open Microsoft.CodeAnalysis.Text
 open FSharp.Compiler.CodeAnalysis
 open Microsoft.VisualStudio.FSharp.Editor
+open FSharp.Editor.Tests.Helpers
 
-[<TestFixture>]
 type BraceMatchingServiceTests() =
     let checker = FSharpChecker.Create()
 
     let fileName = "C:\\test.fs"
 
-    let projectOptions: FSharpProjectOptions =
-        {
-            ProjectFileName = "C:\\test.fsproj"
-            ProjectId = None
-            SourceFiles = [| fileName |]
-            ReferencedProjects = [||]
-            OtherOptions = [||]
-            IsIncompleteTypeCheckEnvironment = true
-            UseScriptResolutionRules = false
-            LoadTime = DateTime.MaxValue
-            OriginalLoadReferences = []
-            UnresolvedReferences = None
-            Stamp = None
-        }
-
     member private this.VerifyNoBraceMatch(fileContents: string, marker: string) =
         let sourceText = SourceText.From(fileContents)
         let position = fileContents.IndexOf(marker)
-        Assert.IsTrue(position >= 0, "Cannot find marker '{0}' in file contents", marker)
+        Assert.True(position >= 0, $"Cannot find marker '{marker}' in file contents")
 
-        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions projectOptions
+        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
         match
             FSharpBraceMatchingService.GetBraceMatchingResult(checker, sourceText, fileName, parsingOptions, position, "UnitTest")
             |> Async.RunImmediateExceptOnUI
         with
         | None -> ()
-        | Some (left, right) -> Assert.Fail("Found match for brace '{0}'", marker)
+        | Some (left, right) ->  failwith $"Found match for brace '{marker}'"
 
     member private this.VerifyBraceMatch(fileContents: string, startMarker: string, endMarker: string) =
         let sourceText = SourceText.From(fileContents)
         let startMarkerPosition = fileContents.IndexOf(startMarker)
         let endMarkerPosition = fileContents.IndexOf(endMarker)
 
-        Assert.IsTrue(startMarkerPosition >= 0, "Cannot find start marker '{0}' in file contents", startMarkerPosition)
-        Assert.IsTrue(endMarkerPosition >= 0, "Cannot find end marker '{0}' in file contents", endMarkerPosition)
+        Assert.True(startMarkerPosition >= 0, $"Cannot find start marker '{startMarkerPosition}' in file contents")
+        Assert.True(endMarkerPosition >= 0, $"Cannot find end marker '{endMarkerPosition}' in file contents")
 
-        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions projectOptions
+        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
         match
             FSharpBraceMatchingService.GetBraceMatchingResult(
@@ -64,24 +49,25 @@ type BraceMatchingServiceTests() =
             )
             |> Async.RunImmediateExceptOnUI
         with
-        | None -> Assert.Fail("Didn't find a match for start brace at position '{0}", startMarkerPosition)
+        | None -> failwith $"Didn't find a match for start brace at position '{startMarkerPosition}"
         | Some (left, right) ->
             let endPositionInRange (range) =
                 let span = RoslynHelpers.FSharpRangeToTextSpan(sourceText, range)
                 span.Start <= endMarkerPosition && endMarkerPosition <= span.End
 
-            Assert.IsTrue(endPositionInRange (left) || endPositionInRange (right), "Found end match at incorrect position")
+            Assert.True(endPositionInRange (left) || endPositionInRange (right), "Found end match at incorrect position")
 
+    [<Theory>]
     // Starting Brace
-    [<TestCase("(marker1", ")marker1")>]
-    [<TestCase("{marker2", "}marker2")>]
-    [<TestCase("(marker3", ")marker3")>]
-    [<TestCase("[marker4", "]marker4")>]
+    [<InlineData("(marker1", ")marker1")>]
+    [<InlineData("{marker2", "}marker2")>]
+    [<InlineData("(marker3", ")marker3")>]
+    [<InlineData("[marker4", "]marker4")>]
     // Ending Brace
-    [<TestCase(")marker1", "(marker1")>]
-    [<TestCase("}marker2", "{marker2")>]
-    [<TestCase(")marker3", "(marker3")>]
-    [<TestCase("]marker4", "[marker4")>]
+    [<InlineData(")marker1", "(marker1")>]
+    [<InlineData("}marker2", "{marker2")>]
+    [<InlineData(")marker3", "(marker3")>]
+    [<InlineData("]marker4", "[marker4")>]
     member this.NestedBrackets(startMarker: string, endMarker: string) =
         let code =
             "
@@ -96,25 +82,26 @@ type BraceMatchingServiceTests() =
 
         this.VerifyBraceMatch(code, startMarker, endMarker)
 
-    [<Test>]
+    [<Fact>]
     member this.BracketInExpression() =
         this.VerifyBraceMatch("let x = (3*5)-1", "(3*", ")-1")
 
-    [<Test>]
+    [<Fact>]
     member this.BraceInInterpolatedStringSimple() =
         this.VerifyBraceMatch("let x = $\"abc{1}def\"", "{1", "}def")
 
-    [<Test>]
+    [<Fact>]
     member this.BraceInInterpolatedStringTwoHoles() =
         this.VerifyBraceMatch("let x = $\"abc{1}def{2+3}hij\"", "{2", "}hij")
 
-    [<Test>]
+    [<Fact>]
     member this.BraceInInterpolatedStringNestedRecord() =
         this.VerifyBraceMatch("let x = $\"abc{ id{contents=3}.contents }\"", "{contents", "}.contents")
         this.VerifyBraceMatch("let x = $\"abc{ id{contents=3}.contents }\"", "{ id", "}\"")
 
-    [<TestCase("[start")>]
-    [<TestCase("]end")>]
+    [<Theory>]
+    [<InlineData("[start")>]
+    [<InlineData("]end")>]
     member this.BraceInMultiLineCommentShouldNotBeMatched(startMarker: string) =
         let code =
             "
@@ -127,7 +114,7 @@ type BraceMatchingServiceTests() =
 
         this.VerifyNoBraceMatch(code, startMarker)
 
-    [<Test>]
+    [<Fact>]
     member this.BraceInAttributesMatch() =
         let code =
             "
@@ -136,7 +123,7 @@ type BraceMatchingServiceTests() =
 
         this.VerifyBraceMatch(code, "[<", ">]")
 
-    [<Test>]
+    [<Fact>]
     member this.BraceEncapsulatingACommentShouldBeMatched() =
         let code =
             "
@@ -146,10 +133,11 @@ type BraceMatchingServiceTests() =
 
         this.VerifyBraceMatch(code, "(start", ")end")
 
-    [<TestCase("(endsInComment")>]
-    [<TestCase(")endsInComment")>]
-    [<TestCase("<startsInComment")>]
-    [<TestCase(">startsInComment")>]
+    [<Theory>]
+    [<InlineData("(endsInComment")>]
+    [<InlineData(")endsInComment")>]
+    [<InlineData("<startsInComment")>]
+    [<InlineData(">startsInComment")>]
     member this.BraceStartingOrEndingInCommentShouldNotBeMatched(startMarker: string) =
         let code =
             "
@@ -159,10 +147,11 @@ type BraceMatchingServiceTests() =
 
         this.VerifyNoBraceMatch(code, startMarker)
 
-    [<TestCase("(endsInDisabledCode")>]
-    [<TestCase(")endsInDisabledCode")>]
-    [<TestCase("<startsInDisabledCode")>]
-    [<TestCase(">startsInDisabledCode")>]
+    [<Theory>]
+    [<InlineData("(endsInDisabledCode")>]
+    [<InlineData(")endsInDisabledCode")>]
+    [<InlineData("<startsInDisabledCode")>]
+    [<InlineData(">startsInDisabledCode")>]
     member this.BraceStartingOrEndingInDisabledCodeShouldNotBeMatched(startMarker: string) =
         let code =
             "
@@ -174,10 +163,11 @@ type BraceMatchingServiceTests() =
 
         this.VerifyNoBraceMatch(code, startMarker)
 
-    [<TestCase("(endsInString")>]
-    [<TestCase(")endsInString")>]
-    [<TestCase("<startsInString")>]
-    [<TestCase(">startsInString")>]
+    [<Theory>]
+    [<InlineData("(endsInString")>]
+    [<InlineData(")endsInString")>]
+    [<InlineData("<startsInString")>]
+    [<InlineData(">startsInString")>]
     member this.BraceStartingOrEndingInStringShouldNotBeMatched(startMarker: string) =
         let code =
             "
@@ -187,7 +177,7 @@ type BraceMatchingServiceTests() =
 
         this.VerifyNoBraceMatch(code, startMarker)
 
-    [<Test>]
+    [<Fact>]
     member this.BraceMatchingAtEndOfLine_Bug1597() =
         // https://github.com/dotnet/fsharp/issues/1597
         let code =
@@ -202,16 +192,17 @@ let main argv =
 
         this.VerifyBraceMatch(code, "(printfn", ")endBrace")
 
-    [<TestCase("let a1 = [ 0 .. 100 ]", [| 9; 20 |])>]
-    [<TestCase("let a2 = [| 0 .. 100 |]", [| 9; 10; 22 |])>]
-    [<TestCase("let a3 = <@ 0 @>", [| 9; 10; 15 |])>]
-    [<TestCase("let a4 = <@@ 0 @@>", [| 9; 10; 11; 15; 16 |])>]
-    [<TestCase("let a6 = (  ()  )", [| 9; 16 |])>]
-    [<TestCase("[<ReflectedDefinition>]\nlet a7 = 70", [| 0; 1; 22 |])>]
-    [<TestCase("let a8 = seq { yield() }", [| 13; 23 |])>]
-    member this.DoNotMatchOnInnerSide(fileContents: string, matchingPositions: int[]) =
+    [<Theory>]
+    [<InlineData("let a1 = [ 0 .. 100 ]", 9, 20)>]
+    [<InlineData("let a2 = [| 0 .. 100 |]", 9, 10, 22)>]
+    [<InlineData("let a3 = <@ 0 @>", 9, 10, 15)>]
+    [<InlineData("let a4 = <@@ 0 @@>", 9, 10, 11, 15, 16)>]
+    [<InlineData("let a6 = (  ()  )", 9, 16)>]
+    [<InlineData("[<ReflectedDefinition>]\nlet a7 = 70", 0, 1, 22)>]
+    [<InlineData("let a8 = seq { yield() }", 13, 23)>]
+    member this.DoNotMatchOnInnerSide(fileContents: string, [<ParamArray>] matchingPositions: int[]) =
         let sourceText = SourceText.From(fileContents)
-        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions projectOptions
+        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
         for position in matchingPositions do
             match
@@ -224,4 +215,4 @@ let main argv =
                 | 0 -> ""
                 | _ -> fileContents.[position - 1] |> sprintf " (previous character '%c')"
                 |> sprintf "Didn't find a matching brace at position '%d' %s" position
-                |> Assert.Fail
+                |> raise (exn())
diff --git a/vsintegration/tests/FSharp.Editor.Tests/BreakpointResolutionServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/BreakpointResolutionServiceTests.fs
index bc5ca99f999..548991e3d5f 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/BreakpointResolutionServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/BreakpointResolutionServiceTests.fs
@@ -3,16 +3,13 @@
 namespace FSharp.Editor.Tests
 
 open System
-open NUnit.Framework
+open Xunit
 open Microsoft.CodeAnalysis.Text
 open Microsoft.VisualStudio.FSharp.Editor
 open FSharp.Editor.Tests.Helpers
 
-[<TestFixture>]
 type BreakpointResolutionServiceTests() =
 
-    let fileName = "C:\\test.fs"
-
     let code =
         "
 // This is a comment
@@ -36,7 +33,7 @@ let main argv =
     0 // return an integer exit code
     "
 
-    static member private testCases: Object[][] =
+    static member testCases: Object[][] =
         [|
             [| "This is a comment"; None |]
             [| "123456"; Some("let integerValue = 123456") |]
@@ -47,13 +44,16 @@ let main argv =
             [| "0"; Some("0") |]
         |]
 
-    [<TestCaseSource("testCases")>]
+    [<Theory>]
+    [<MemberData(nameof(BreakpointResolutionServiceTests.testCases))>]
     member this.TestBreakpointResolution(searchToken: string, expectedResolution: string option) =
         let searchPosition = code.IndexOf(searchToken)
-        Assert.IsTrue(searchPosition >= 0, "SearchToken '{0}' is not found in code", searchToken)
+        Assert.True(searchPosition >= 0, $"SearchToken '{searchToken}' is not found in code")
 
-        let document, sourceText =
-            RoslynTestHelpers.CreateSingleDocumentSolution(fileName, code)
+        let sourceText = SourceText.From(code)
+        let document =
+            RoslynTestHelpers.CreateSolution(code)
+            |> RoslynTestHelpers.GetSingleDocument
 
         let searchSpan =
             TextSpan.FromBounds(searchPosition, searchPosition + searchToken.Length)
@@ -63,17 +63,16 @@ let main argv =
             |> Async.RunSynchronously
 
         match actualResolutionOption with
-        | None -> Assert.IsTrue(expectedResolution.IsNone, "BreakpointResolutionService failed to resolve breakpoint position")
+        | None -> Assert.True(expectedResolution.IsNone, "BreakpointResolutionService failed to resolve breakpoint position")
         | Some (actualResolutionRange) ->
             let actualResolution =
                 sourceText
                     .GetSubText(RoslynHelpers.FSharpRangeToTextSpan(sourceText, actualResolutionRange))
                     .ToString()
 
-            Assert.IsTrue(
+            Assert.True(
                 expectedResolution.IsSome,
-                "BreakpointResolutionService resolved a breakpoint while it shouldn't at: {0}",
-                actualResolution
+                $"BreakpointResolutionService resolved a breakpoint while it shouldn't at: {actualResolution}"
             )
 
-            Assert.AreEqual(expectedResolution.Value, actualResolution, "Expected and actual resolutions should match")
+            Assert.Equal(expectedResolution.Value, actualResolution)
diff --git a/vsintegration/tests/FSharp.Editor.Tests/CompletionProviderTests.fs b/vsintegration/tests/FSharp.Editor.Tests/CompletionProviderTests.fs
index 3f51bcc694e..2be760394f9 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/CompletionProviderTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/CompletionProviderTests.fs
@@ -6,40 +6,25 @@ module CompletionProviderTests =
 
     open System
     open System.Linq
-    open NUnit.Framework
     open Microsoft.CodeAnalysis
     open Microsoft.CodeAnalysis.Completion
     open Microsoft.CodeAnalysis.Text
     open Microsoft.VisualStudio.FSharp.Editor
-    open FSharp.Compiler.CodeAnalysis
     open FSharp.Editor.Tests.Helpers
+    open Xunit
+    open FSharp.Test
 
     let filePath = "C:\\test.fs"
 
-    let internal projectOptions opts =
-        {
-            ProjectFileName = "C:\\test.fsproj"
-            ProjectId = None
-            SourceFiles = [| filePath |]
-            ReferencedProjects = [||]
-            OtherOptions = opts
-            IsIncompleteTypeCheckEnvironment = true
-            UseScriptResolutionRules = false
-            LoadTime = DateTime.MaxValue
-            OriginalLoadReferences = []
-            UnresolvedReferences = None
-            Stamp = None
-        }
-
     let formatCompletions (completions: string seq) =
         "\n\t" + String.Join("\n\t", completions)
 
     let VerifyCompletionListWithOptions (fileContents: string, marker: string, expected: string list, unexpected: string list, opts) =
-        let options = projectOptions opts
         let caretPosition = fileContents.IndexOf(marker) + marker.Length
 
-        let document, _ =
-            RoslynTestHelpers.CreateSingleDocumentSolution(filePath, fileContents, options = options)
+        let document =
+            RoslynTestHelpers.CreateSolution(fileContents)
+            |> RoslynTestHelpers.GetSingleDocument
 
         let results =
             FSharpCompletionProvider.ProvideCompletionsAsyncAux(document, caretPosition, (fun _ -> []))
@@ -76,17 +61,17 @@ module CompletionProviderTests =
 
             let msg = sprintf "%s%s%s" expectedNotFoundMsg unexpectedFoundMsg completionsMsg
 
-            Assert.Fail(msg)
+            failwith msg
 
     let VerifyCompletionList (fileContents, marker, expected, unexpected) =
         VerifyCompletionListWithOptions(fileContents, marker, expected, unexpected, [||])
 
     let VerifyCompletionListExactlyWithOptions (fileContents: string, marker: string, expected: string list, opts) =
-        let options = projectOptions opts
         let caretPosition = fileContents.IndexOf(marker) + marker.Length
 
-        let document, _ =
-            RoslynTestHelpers.CreateSingleDocumentSolution(filePath, fileContents, options = options)
+        let document =
+            RoslynTestHelpers.CreateSolution(fileContents)
+            |> RoslynTestHelpers.GetSingleDocument
 
         let actual =
             FSharpCompletionProvider.ProvideCompletionsAsyncAux(document, caretPosition, (fun _ -> []))
@@ -99,13 +84,11 @@ module CompletionProviderTests =
         let actualNames = actual |> List.map (fun x -> x.DisplayText)
 
         if actualNames <> expected then
-            Assert.Fail(
-                sprintf
-                    "Expected:\n%s,\nbut was:\n%s\nactual with sort text:\n%s"
-                    (String.Join("; ", expected |> List.map (sprintf "\"%s\"")))
-                    (String.Join("; ", actualNames |> List.map (sprintf "\"%s\"")))
-                    (String.Join("\n", actual |> List.map (fun x -> sprintf "%s => %s" x.DisplayText x.SortText)))
-            )
+            failwithf
+                "Expected:\n%s,\nbut was:\n%s\nactual with sort text:\n%s"
+                (String.Join("; ", expected |> List.map (sprintf "\"%s\"")))
+                (String.Join("; ", actualNames |> List.map (sprintf "\"%s\"")))
+                (String.Join("\n", actual |> List.map (fun x -> sprintf "%s => %s" x.DisplayText x.SortText)))
 
     let VerifyCompletionListExactly (fileContents: string, marker: string, expected: string list) =
         VerifyCompletionListExactlyWithOptions(fileContents, marker, expected, [||])
@@ -121,9 +104,9 @@ module CompletionProviderTests =
         let resultSpan =
             CompletionUtils.getDefaultCompletionListSpan (sourceText, caretPosition, documentId, filePath, [])
 
-        Assert.AreEqual(expected, sourceText.ToString(resultSpan))
+        Assert.Equal(expected, sourceText.ToString(resultSpan))
 
-    [<Test>]
+    [<Fact>]
     let ShouldTriggerCompletionAtCorrectMarkers () =
         let testCases =
             [
@@ -158,13 +141,10 @@ System.Console.WriteLine(x + y)
                     IntelliSenseOptions.Default
                 )
 
-            Assert.AreEqual(
-                shouldBeTriggered,
-                triggered,
+            triggered |> Assert.shouldBeEqualWith shouldBeTriggered 
                 "FSharpCompletionProvider.ShouldTriggerCompletionAux() should compute the correct result"
-            )
 
-    [<Test>]
+    [<Fact>]
     let ShouldNotTriggerCompletionAfterAnyTriggerOtherThanInsertionOrDeletion () =
         for triggerKind in [ CompletionTriggerKind.Invoke; CompletionTriggerKind.Snippets ] do
             let fileContents = "System.Console.WriteLine(123)"
@@ -181,9 +161,9 @@ System.Console.WriteLine(x + y)
                     IntelliSenseOptions.Default
                 )
 
-            Assert.IsFalse(triggered, "FSharpCompletionProvider.ShouldTriggerCompletionAux() should not trigger")
+            Assert.False(triggered, "FSharpCompletionProvider.ShouldTriggerCompletionAux() should not trigger")
 
-    [<Test>]
+    [<Fact>]
     let ShouldNotTriggerCompletionInStringLiterals () =
         let fileContents = "let literal = \"System.Console.WriteLine()\""
         let caretPosition = fileContents.IndexOf("System.")
@@ -199,9 +179,9 @@ System.Console.WriteLine(x + y)
                 IntelliSenseOptions.Default
             )
 
-        Assert.IsFalse(triggered, "FSharpCompletionProvider.ShouldTriggerCompletionAux() should not trigger")
+        Assert.False(triggered, "FSharpCompletionProvider.ShouldTriggerCompletionAux() should not trigger")
 
-    [<Test>]
+    [<Fact>]
     let ShouldNotTriggerCompletionInComments () =
         let fileContents =
             """
@@ -224,9 +204,9 @@ System.Console.WriteLine()
                 IntelliSenseOptions.Default
             )
 
-        Assert.IsFalse(triggered, "FSharpCompletionProvider.ShouldTriggerCompletionAux() should not trigger")
+        Assert.False(triggered, "FSharpCompletionProvider.ShouldTriggerCompletionAux() should not trigger")
 
-    [<Test>]
+    [<Fact>]
     let ShouldTriggerCompletionInInterpolatedString () =
         let fileContents =
             """
@@ -262,13 +242,10 @@ let z = $"abc  {System.Console.WriteLine(x + y)} def"
                     IntelliSenseOptions.Default
                 )
 
-            Assert.AreEqual(
-                shouldBeTriggered,
-                triggered,
-                sprintf "FSharpCompletionProvider.ShouldTriggerCompletionAux() should compute the correct result for marker '%s'" marker
-            )
+            triggered |> Assert.shouldBeEqualWith shouldBeTriggered 
+                $"FSharpCompletionProvider.ShouldTriggerCompletionAux() should compute the correct result for marker '{marker}"
 
-    [<Test>]
+    [<Fact>]
     let ShouldNotTriggerCompletionInExcludedCode () =
         let fileContents =
             """
@@ -290,9 +267,9 @@ System.Console.WriteLine()
                 IntelliSenseOptions.Default
             )
 
-        Assert.IsFalse(triggered, "FSharpCompletionProvider.ShouldTriggerCompletionAux() should not trigger")
+        Assert.False(triggered, "FSharpCompletionProvider.ShouldTriggerCompletionAux() should not trigger")
 
-    [<Test>]
+    [<Fact>]
     let ShouldNotTriggerCompletionInOperatorWithDot () =
         // Simulate mistyping '|>' as '|.'
         let fileContents =
@@ -314,9 +291,9 @@ let f() =
                 IntelliSenseOptions.Default
             )
 
-        Assert.IsFalse(triggered, "FSharpCompletionProvider.ShouldTriggerCompletionAux() should not trigger on operators")
+        Assert.False(triggered, "FSharpCompletionProvider.ShouldTriggerCompletionAux() should not trigger on operators")
 
-    [<Test>]
+    [<Fact>]
     let ShouldTriggerCompletionInAttribute () =
         let fileContents =
             """
@@ -338,9 +315,9 @@ module Foo = module end
                 IntelliSenseOptions.Default
             )
 
-        Assert.IsTrue(triggered, "Completion should trigger on Attributes.")
+        Assert.True(triggered, "Completion should trigger on Attributes.")
 
-    [<Test>]
+    [<Fact>]
     let ShouldTriggerCompletionAfterDerefOperator () =
         let fileContents =
             """
@@ -362,9 +339,9 @@ printfn "%d" !f
                 IntelliSenseOptions.Default
             )
 
-        Assert.IsTrue(triggered, "Completion should trigger after typing an identifier that follows a dereference operator (!).")
+        Assert.True(triggered, "Completion should trigger after typing an identifier that follows a dereference operator (!).")
 
-    [<Test>]
+    [<Fact>]
     let ShouldTriggerCompletionAfterAddressOfOperator () =
         let fileContents =
             """
@@ -387,9 +364,9 @@ use ptr = fixed &p
                 IntelliSenseOptions.Default
             )
 
-        Assert.IsTrue(triggered, "Completion should trigger after typing an identifier that follows an addressOf operator (&).")
+        Assert.True(triggered, "Completion should trigger after typing an identifier that follows an addressOf operator (&).")
 
-    [<Test>]
+    [<Fact>]
     let ShouldTriggerCompletionAfterArithmeticOperation () =
         let fileContents =
             """
@@ -421,9 +398,9 @@ xVal**y
                     IntelliSenseOptions.Default
                 )
 
-            Assert.IsTrue(triggered, "Completion should trigger after typing an identifier that follows a mathematical operation")
+            Assert.True(triggered, "Completion should trigger after typing an identifier that follows a mathematical operation")
 
-    [<Test>]
+    [<Fact>]
     let ShouldTriggerCompletionAtStartOfFileWithInsertion =
         let fileContents =
             """
@@ -443,12 +420,12 @@ l"""
                 IntelliSenseOptions.Default
             )
 
-        Assert.IsTrue(
+        Assert.True(
             triggered,
             "Completion should trigger after typing an Insertion character at the top of the file, e.g. a function definition in a new script file."
         )
 
-    [<Test>]
+    [<Fact>]
     let ShouldDisplayTypeMembers () =
         let fileContents =
             """
@@ -464,7 +441,7 @@ let main argv =
 
         VerifyCompletionList(fileContents, "obj.", [ "M1"; "M2" ], [ "System" ])
 
-    [<Test>]
+    [<Fact>]
     let ShouldDisplaySystemNamespace () =
         let fileContents =
             """
@@ -476,7 +453,7 @@ System.Console.WriteLine()
 
         VerifyCompletionList(fileContents, "System.", [ "Console"; "Array"; "String" ], [ "T1"; "M1"; "M2" ])
 
-    [<Test>]
+    [<Fact>]
     let ShouldDisplaySystemNamespaceInInterpolatedString () =
         let fileContents =
             """
@@ -488,7 +465,7 @@ let x = $"1 not the same as {System.Int32.MaxValue} is it"
 
         VerifyCompletionList(fileContents, "System.", [ "Console"; "Array"; "String" ], [ "T1"; "M1"; "M2" ])
 
-    [<Test>]
+    [<Fact>]
     let ``Class instance members are ordered according to their kind and where they are defined (simple case, by a variable)`` () =
         let fileContents =
             """
@@ -519,7 +496,7 @@ x.
 
         VerifyCompletionListExactly(fileContents, "x.", expected)
 
-    [<Test>]
+    [<Fact>]
     let ``Class instance members are ordered according to their kind and where they are defined (simple case, by a constructor)`` () =
         let fileContents =
             """
@@ -549,7 +526,7 @@ let x = Class().
 
         VerifyCompletionListExactly(fileContents, "let x = Class().", expected)
 
-    [<Test>]
+    [<Fact>]
     let ``Class static members are ordered according to their kind and where they are defined`` () =
         let fileContents =
             """
@@ -570,7 +547,7 @@ Class.
 
         VerifyCompletionListExactly(fileContents, "Class.", expected)
 
-    [<Test>]
+    [<Fact>]
     let ``Class instance members are ordered according to their kind and where they are defined (complex case)`` () =
         let fileContents =
             """
@@ -635,7 +612,7 @@ x.
 
         VerifyCompletionListExactly(fileContents, "x.", expected)
 
-    [<Test>]
+    [<Fact>]
     let ``Constructing a new class with object initializer syntax`` () =
         let fileContents =
             """
@@ -651,7 +628,7 @@ let _ = new A(Setta)
         let notExpected = [ "NonSettableProperty" ]
         VerifyCompletionList(fileContents, "(Setta", expected, notExpected)
 
-    [<Test>]
+    [<Fact>]
     let ``Constructing a new class with object initializer syntax and verifying 'at' character doesn't exist.`` () =
         let fileContents =
             """
@@ -670,7 +647,7 @@ let _ = new A(Setta)
 
         VerifyCompletionList(fileContents, "(Setta", expected, notExpected)
 
-    [<Test; Ignore("https://github.com/dotnet/fsharp/issues/3954")>]
+    [<Fact(Skip = "https://github.com/dotnet/fsharp/issues/3954")>]
     let ``Constructing a new fully qualified class with object initializer syntax without ending paren`` () =
         let fileContents =
             """
@@ -687,7 +664,7 @@ let _ = new M.A(Setta
         let notExpected = [ "NonSettableProperty" ]
         VerifyCompletionList(fileContents, "(Setta", expected, notExpected)
 
-    [<Test>]
+    [<Fact>]
     let ``Extension methods go after everything else, extension properties are treated as normal ones`` () =
         let fileContents =
             """
@@ -745,7 +722,7 @@ List().
 
         VerifyCompletionListExactly(fileContents, "List().", expected)
 
-    [<Test>]
+    [<Fact>]
     let ``Completion for open contains namespaces and static types`` () =
         let fileContents =
             """
@@ -755,7 +732,7 @@ open type System.Ma
         let expected = [ "Management"; "Math" ] // both namespace and static type
         VerifyCompletionList(fileContents, "System.Ma", expected, [])
 
-    [<Test>]
+    [<Fact>]
     let ``No completion on type name at declaration site`` () =
         let fileContents =
             """
@@ -765,7 +742,7 @@ type T
 
         VerifyNoCompletionList(fileContents, "type T")
 
-    [<Test>]
+    [<Fact>]
     let ``No completion on name of unfinished function declaration`` () =
         let fileContents =
             """
@@ -775,7 +752,7 @@ let f
 
         VerifyNoCompletionList(fileContents, "let f")
 
-    [<Test>]
+    [<Fact>]
     let ``No completion on name of value declaration`` () =
         let fileContents =
             """
@@ -785,7 +762,7 @@ let xyz = 1
 
         VerifyNoCompletionList(fileContents, "let xy")
 
-    [<Test>]
+    [<Fact>]
     let ``No completion on name of function declaration`` () =
         let fileContents =
             """
@@ -795,7 +772,7 @@ let foo x = 1
 
         VerifyNoCompletionList(fileContents, "let fo")
 
-    [<Test>]
+    [<Fact>]
     let ``No completion on name of tupled function declaration`` () =
         let fileContents =
             """
@@ -805,7 +782,7 @@ let foo (x, y) = 1
 
         VerifyNoCompletionList(fileContents, "let fo")
 
-    [<Test>]
+    [<Fact>]
     let ``No completion on member name at declaration site`` () =
         let fileContents =
             """
@@ -815,7 +792,7 @@ type T() =
 
         VerifyNoCompletionList(fileContents, "member this.M")
 
-    [<Test>]
+    [<Fact>]
     let ``No completion on function first argument name`` () =
         let fileContents =
             """
@@ -824,7 +801,7 @@ let func (p
 
         VerifyNoCompletionList(fileContents, "let func (p")
 
-    [<Test>]
+    [<Fact>]
     let ``No completion on function subsequent argument name`` () =
         let fileContents =
             """
@@ -833,7 +810,7 @@ let func (p, h
 
         VerifyNoCompletionList(fileContents, "let func (p, h")
 
-    [<Test>]
+    [<Fact>]
     let ``No completion on curried function subsequent argument name`` () =
         let fileContents =
             """
@@ -842,7 +819,7 @@ let func (p) (h
 
         VerifyNoCompletionList(fileContents, "let func (p) (h")
 
-    [<Test>]
+    [<Fact>]
     let ``No completion on method first argument name`` () =
         let fileContents =
             """
@@ -852,7 +829,7 @@ type T() =
 
         VerifyNoCompletionList(fileContents, "member this.M(p")
 
-    [<Test>]
+    [<Fact>]
     let ``No completion on method subsequent argument name`` () =
         let fileContents =
             """
@@ -862,7 +839,7 @@ type T() =
 
         VerifyNoCompletionList(fileContents, "member this.M(p:int, h")
 
-    [<Test>]
+    [<Fact>]
     let ``Completion list on abstract member type signature contains modules and types but not keywords or functions`` =
         let fileContents =
             """
@@ -872,7 +849,7 @@ type Interface =
 
         VerifyCompletionList(fileContents, "Eat: l", [ "LanguagePrimitives"; "List" ], [ "let"; "log" ])
 
-    [<Test>]
+    [<Fact>]
     let ``Provide completion on first function argument type hint`` () =
         let fileContents =
             """
@@ -881,7 +858,7 @@ let func (p:i
 
         VerifyCompletionList(fileContents, "let func (p:i", [ "int" ], [])
 
-    [<Test>]
+    [<Fact>]
     let ``Provide completion on subsequent function argument type hint`` () =
         let fileContents =
             """
@@ -890,7 +867,7 @@ let func (p:int, h:f
 
         VerifyCompletionList(fileContents, "let func (p:int, h:f", [ "float" ], [])
 
-    [<Test>]
+    [<Fact>]
     let ``Provide completion on local function argument type hint`` () =
         let fileContents =
             """
@@ -900,7 +877,7 @@ let top () =
 
         VerifyCompletionList(fileContents, "let func (p:i", [ "int" ], [])
 
-    [<Test>]
+    [<Fact>]
     let ``No completion on implicit constructor first argument name`` () =
         let fileContents =
             """
@@ -909,7 +886,7 @@ type T(p) =
 
         VerifyNoCompletionList(fileContents, "type T(p")
 
-    [<Test>]
+    [<Fact>]
     let ``No completion on implicit constructor subsequent argument name`` () =
         let fileContents =
             """
@@ -918,7 +895,7 @@ type T(p:int, h) =
 
         VerifyNoCompletionList(fileContents, "type T(p:int, h")
 
-    [<Test>]
+    [<Fact>]
     let ``Provide completion on implicit constructor argument type hint`` () =
         let fileContents =
             """
@@ -927,7 +904,7 @@ type T(p:i) =
 
         VerifyCompletionList(fileContents, "type T(p:i", [ "int" ], [])
 
-    [<Test>]
+    [<Fact>]
     let ``No completion on lambda argument name`` () =
         let fileContents =
             """
@@ -936,7 +913,7 @@ let _ = fun (p) -> ()
 
         VerifyNoCompletionList(fileContents, "let _ = fun (p")
 
-    [<Test>]
+    [<Fact>]
     let ``No completion on lambda argument name2`` () =
         let fileContents =
             """
@@ -945,7 +922,7 @@ let _ = fun (p: int) -> ()
 
         VerifyNoCompletionList(fileContents, "let _ = fun (p")
 
-    [<Test>]
+    [<Fact>]
     let ``Completions on lambda argument type hint contain modules and types but not keywords or functions`` () =
         let fileContents =
             """
@@ -954,7 +931,7 @@ let _ = fun (p:l) -> ()
 
         VerifyCompletionList(fileContents, "let _ = fun (p:l", [ "LanguagePrimitives"; "List" ], [ "let"; "log" ])
 
-    [<Test>]
+    [<Fact>]
     let ``Completions in match clause type test contain modules and types but not keywords or functions`` () =
         let fileContents =
             """
@@ -965,7 +942,7 @@ match box 5 with
 
         VerifyCompletionList(fileContents, ":? l", [ "LanguagePrimitives"; "List" ], [ "let"; "log" ])
 
-    [<Test>]
+    [<Fact>]
     let ``Completions in catch clause type test contain modules and types but not keywords or functions`` () =
         let fileContents =
             """
@@ -977,7 +954,7 @@ with :? l as x ->
 
         VerifyCompletionList(fileContents, ":? l", [ "LanguagePrimitives"; "List" ], [ "let"; "log" ])
 
-    [<Test>]
+    [<Fact>]
     let ``Extensions.Bug5162`` () =
         let fileContents =
             """
@@ -991,7 +968,7 @@ module M2 =
 
         VerifyCompletionList(fileContents, "    Ext", [ "Extensions"; "ExtraTopLevelOperators" ], [])
 
-    [<Test>]
+    [<Fact>]
     let ``Custom operations should be at the top of completion list inside computation expression`` () =
         let fileContents =
             """
@@ -1007,7 +984,7 @@ let _ =
 
         VerifyCompletionList(fileContents, "        join", [ "groupJoin"; "join"; "leftOuterJoin"; "joinLocal" ], [])
 
-    [<Test>]
+    [<Fact>]
     let ``Byref Extension Methods`` () =
         let fileContents =
             """
@@ -1037,7 +1014,7 @@ module Extensions =
 
         VerifyCompletionList(fileContents, "wrappedMessage.", [ "PrintRef" ], [])
 
-    [<Test>]
+    [<Fact>]
     let ``Completion list span works with underscore in identifier`` () =
         let fileContents =
             """
@@ -1046,7 +1023,7 @@ let x = A.B_C
 
         VerifyCompletionListSpan(fileContents, "A.B_C", "B_C")
 
-    [<Test>]
+    [<Fact>]
     let ``Completion list span works with digit in identifier`` () =
         let fileContents =
             """
@@ -1055,7 +1032,7 @@ let x = A.B1C
 
         VerifyCompletionListSpan(fileContents, "A.B1C", "B1C")
 
-    [<Test>]
+    [<Fact>]
     let ``Completion list span works with enclosed backtick identifier`` () =
         let fileContents =
             """
@@ -1064,7 +1041,7 @@ let x = A.``B C``
 
         VerifyCompletionListSpan(fileContents, "A.``B C``", "``B C``")
 
-    [<Test>]
+    [<Fact>]
     let ``Completion list span works with partial backtick identifier`` () =
         let fileContents =
             """
@@ -1073,7 +1050,7 @@ let x = A.``B C
 
         VerifyCompletionListSpan(fileContents, "A.``B C", "``B C")
 
-    [<Test>]
+    [<Fact>]
     let ``Completion list span works with first of multiple enclosed backtick identifiers`` () =
         let fileContents =
             """
@@ -1082,7 +1059,7 @@ let x = A.``B C`` + D.``E F``
 
         VerifyCompletionListSpan(fileContents, "A.``B C``", "``B C``")
 
-    [<Test>]
+    [<Fact>]
     let ``Completion list span works with last of multiple enclosed backtick identifiers`` () =
         let fileContents =
             """
@@ -1091,7 +1068,7 @@ let x = A.``B C`` + D.``E F``
 
         VerifyCompletionListSpan(fileContents, "D.``E F``", "``E F``")
 
-    [<Test>]
+    [<Fact>]
     let ``No completion on record field identifier at declaration site`` () =
         let fileContents =
             """
@@ -1100,7 +1077,7 @@ type A = { le: string }
 
         VerifyNoCompletionList(fileContents, "le")
 
-    [<Test>]
+    [<Fact>]
     let ``Completion list on record field type at declaration site contains modules, types and type parameters but not keywords or functions``
         ()
         =
@@ -1111,7 +1088,7 @@ type A<'lType> = { Field: l }
 
         VerifyCompletionList(fileContents, "Field: l", [ "LanguagePrimitives"; "List" ], [ "let"; "log" ])
 
-    [<Test>]
+    [<Fact>]
     let ``No completion on record stub with no fields at declaration site`` () =
         let fileContents =
             """
@@ -1120,7 +1097,7 @@ type A = {  }
 
         VerifyNoCompletionList(fileContents, "{ ")
 
-    [<Test>]
+    [<Fact>]
     let ``No completion on record outside of all fields at declaration site`` () =
         let fileContents =
             """
@@ -1129,7 +1106,7 @@ type A = { Field: string; }
 
         VerifyNoCompletionList(fileContents, "; ")
 
-    [<Test>]
+    [<Fact>]
     let ``No completion on union case identifier at declaration site`` () =
         let fileContents =
             """
@@ -1139,7 +1116,7 @@ type A =
 
         VerifyNoCompletionList(fileContents, "| C")
 
-    [<Test>]
+    [<Fact>]
     let ``No completion on union case field identifier at declaration site`` () =
         let fileContents =
             """
@@ -1149,7 +1126,7 @@ type A =
 
         VerifyNoCompletionList(fileContents, "str")
 
-    [<Test>]
+    [<Fact>]
     let ``Completion list on union case type at declaration site contains modules, types and type parameters but not keywords or functions``
         ()
         =
@@ -1161,7 +1138,7 @@ type A<'lType> =
 
         VerifyCompletionList(fileContents, "str: l", [ "LanguagePrimitives"; "List"; "lType" ], [ "let"; "log" ])
 
-    [<Test>]
+    [<Fact>]
     let ``Completion list on union case type at declaration site contains modules, types and type parameters but not keywords or functions2``
         ()
         =
@@ -1173,7 +1150,7 @@ type A<'lType> =
 
         VerifyCompletionList(fileContents, "of l", [ "LanguagePrimitives"; "List"; "lType" ], [ "let"; "log" ])
 
-    [<Test>]
+    [<Fact>]
     let ``Completion list on union case type at declaration site contains type parameter`` () =
         let fileContents =
             """
@@ -1183,7 +1160,7 @@ type A<'keyType> =
 
         VerifyCompletionList(fileContents, "of key", [ "keyType" ], [])
 
-    [<Test>]
+    [<Fact>]
     let ``Completion list on type alias contains modules and types but not keywords or functions`` () =
         let fileContents =
             """
@@ -1192,7 +1169,7 @@ type A = l
 
         VerifyCompletionList(fileContents, "= l", [ "LanguagePrimitives"; "List" ], [ "let"; "log" ])
 
-    [<Test>]
+    [<Fact>]
     let ``No completion on enum case identifier at declaration site`` () =
         let fileContents =
             """
@@ -1202,7 +1179,7 @@ type A =
 
         VerifyNoCompletionList(fileContents, "| C")
 
-    [<Test>]
+    [<Fact>]
     let ``Completion list in generic function body contains type parameter`` () =
         let fileContents =
             """
@@ -1212,7 +1189,7 @@ let Null<'wrappedType> () =
 
         VerifyCompletionList(fileContents, "defaultof<wrapp", [ "wrappedType" ], [])
 
-    [<Test>]
+    [<Fact>]
     let ``Completion list in generic method body contains type parameter`` () =
         let fileContents =
             """
@@ -1222,7 +1199,7 @@ type A () =
 
         VerifyCompletionList(fileContents, "defaultof<wrapp", [ "wrappedType" ], [])
 
-    [<Test>]
+    [<Fact>]
     let ``Completion list in generic class method body contains type parameter`` () =
         let fileContents =
             """
@@ -1232,7 +1209,7 @@ type A<'wrappedType> () =
 
         VerifyCompletionList(fileContents, "defaultof<wrapp", [ "wrappedType" ], [])
 
-    [<Test>]
+    [<Fact>]
     let ``Completion list in type application contains modules, types and type parameters but not keywords or functions`` () =
         let fileContents =
             """
@@ -1242,7 +1219,7 @@ let emptyMap<'keyType, 'lValueType> () =
 
         VerifyCompletionList(fileContents, ", l", [ "LanguagePrimitives"; "List"; "lValueType" ], [ "let"; "log" ])
 
-    [<Test>]
+    [<Fact>]
     let ``Completion list for interface with static abstract method type invocation contains static property with residue`` () =
         let fileContents =
             """
@@ -1255,7 +1232,7 @@ let f_IWSAM_flex_StaticProperty(x: #IStaticProperty<'T>) =
 
         VerifyCompletionListWithOptions(fileContents, "'T.Stati", [ "StaticProperty" ], [], [| "/langversion:preview" |])
 
-    [<Test>]
+    [<Fact>]
     let ``Completion list for interface with static abstract method type invocation contains static property after dot`` () =
         let fileContents =
             """
@@ -1268,7 +1245,7 @@ let f_IWSAM_flex_StaticProperty(x: #IStaticProperty<'T>) =
 
         VerifyCompletionListWithOptions(fileContents, "'T.", [ "StaticProperty" ], [], [| "/langversion:preview" |])
 
-    [<Test>]
+    [<Fact>]
     let ``Completion list for SRTP invocation contains static property with residue`` () =
         let fileContents =
             """
@@ -1279,7 +1256,7 @@ let inline f_StaticProperty_SRTP<'T when 'T : (static member StaticProperty: 'T)
 
         VerifyCompletionListWithOptions(fileContents, "'T.Stati", [ "StaticProperty" ], [], [| "/langversion:preview" |])
 
-    [<Test>]
+    [<Fact>]
     let ``Completion list for SRTP invocation contains static property after dot`` () =
         let fileContents =
             """
diff --git a/vsintegration/tests/FSharp.Editor.Tests/DocumentDiagnosticAnalyzerTests.fs b/vsintegration/tests/FSharp.Editor.Tests/DocumentDiagnosticAnalyzerTests.fs
index 423fbc6e0b3..51fdf2be248 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/DocumentDiagnosticAnalyzerTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/DocumentDiagnosticAnalyzerTests.fs
@@ -2,21 +2,21 @@
 
 namespace FSharp.Editor.Tests
 
-open NUnit.Framework
+open Xunit
 open Microsoft.CodeAnalysis
 open Microsoft.VisualStudio.FSharp.Editor
 open FSharp.Editor.Tests.Helpers
+open FSharp.Test
 
-[<TestFixture>]
 type DocumentDiagnosticAnalyzerTests() =
-    let filePath = "C:\\test.fs"
     let startMarker = "(*start*)"
     let endMarker = "(*end*)"
 
     let getDiagnostics (fileContents: string) =
         async {
-            let document, _ =
-                RoslynTestHelpers.CreateSingleDocumentSolution(filePath, fileContents)
+            let document =
+                RoslynTestHelpers.CreateSolution(fileContents)
+                |> RoslynTestHelpers.GetSingleDocument
 
             let! syntacticDiagnostics = FSharpDocumentDiagnosticAnalyzer.GetDiagnostics(document, DiagnosticsType.Syntax)
             let! semanticDiagnostics = FSharpDocumentDiagnosticAnalyzer.GetDiagnostics(document, DiagnosticsType.Semantic)
@@ -28,7 +28,7 @@ type DocumentDiagnosticAnalyzerTests() =
         let errors = getDiagnostics fileContents
 
         if not errors.IsEmpty then
-            Assert.Fail("There should be no errors generated", errors)
+            failwith $"There should be no errors generated: {errors}"
 
     member private this.VerifyErrorAtMarker(fileContents: string, expectedMarker: string, ?expectedMessage: string) =
         let errors =
@@ -36,17 +36,17 @@ type DocumentDiagnosticAnalyzerTests() =
             |> Seq.filter (fun e -> e.Severity = DiagnosticSeverity.Error)
             |> Seq.toArray
 
-        Assert.AreEqual(1, errors.Length, "There should be exactly one error generated")
+        errors.Length |> Assert.shouldBeEqualWith 1 "There should be exactly one error generated"
         let actualError = errors.[0]
 
         if expectedMessage.IsSome then
-            Assert.AreEqual(expectedMessage.Value, actualError.GetMessage(), "Error messages should match")
+            actualError.GetMessage() |> Assert.shouldBeEqualWith expectedMessage.Value "Error messages should match"
 
-        Assert.AreEqual(DiagnosticSeverity.Error, actualError.Severity)
+        Assert.Equal(DiagnosticSeverity.Error, actualError.Severity)
         let expectedStart = fileContents.IndexOf(expectedMarker)
-        Assert.AreEqual(expectedStart, actualError.Location.SourceSpan.Start, "Error start positions should match")
+        actualError.Location.SourceSpan.Start |> Assert.shouldBeEqualWith expectedStart "Error start positions should match"
         let expectedEnd = expectedStart + expectedMarker.Length
-        Assert.AreEqual(expectedEnd, actualError.Location.SourceSpan.End, "Error end positions should match")
+        actualError.Location.SourceSpan.End |> Assert.shouldBeEqualWith expectedEnd "Error end positions should match"
 
     member private this.VerifyDiagnosticBetweenMarkers
         (
@@ -59,14 +59,14 @@ type DocumentDiagnosticAnalyzerTests() =
             |> Seq.filter (fun e -> e.Severity = expectedSeverity)
             |> Seq.toArray
 
-        Assert.AreEqual(1, errors.Length, "There should be exactly one error generated")
+        errors.Length |> Assert.shouldBeEqualWith 1 "There should be exactly one error generated"
         let actualError = errors.[0]
-        Assert.AreEqual(expectedSeverity, actualError.Severity)
-        Assert.AreEqual(expectedMessage, actualError.GetMessage(), "Error messages should match")
+        Assert.Equal(expectedSeverity, actualError.Severity)
+        actualError.GetMessage() |> Assert.shouldBeEqualWith expectedMessage "Error messages should match"
         let expectedStart = fileContents.IndexOf(startMarker) + startMarker.Length
-        Assert.AreEqual(expectedStart, actualError.Location.SourceSpan.Start, "Error start positions should match")
+        actualError.Location.SourceSpan.Start |> Assert.shouldBeEqualWith expectedStart "Error start positions should match"
         let expectedEnd = fileContents.IndexOf(endMarker)
-        Assert.AreEqual(expectedEnd, actualError.Location.SourceSpan.End, "Error end positions should match")
+        actualError.Location.SourceSpan.End |> Assert.shouldBeEqualWith expectedEnd "Error end positions should match"
 
     member private this.VerifyErrorBetweenMarkers(fileContents: string, expectedMessage: string) =
         this.VerifyDiagnosticBetweenMarkers(fileContents, expectedMessage, DiagnosticSeverity.Error)
@@ -74,7 +74,7 @@ type DocumentDiagnosticAnalyzerTests() =
     member private this.VerifyWarningBetweenMarkers(fileContents: string, expectedMessage: string) =
         this.VerifyDiagnosticBetweenMarkers(fileContents, expectedMessage, DiagnosticSeverity.Warning)
 
-    [<Test>]
+    [<Fact>]
     member public this.Error_Expression_IllegalIntegerLiteral() =
         this.VerifyErrorBetweenMarkers(
             fileContents =
@@ -85,7 +85,7 @@ let a = 0.1(*start*).(*end*)0
             expectedMessage = "Missing qualification after '.'"
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.Error_Expression_IncompleteDefine() =
         this.VerifyErrorBetweenMarkers(
             fileContents =
@@ -95,7 +95,7 @@ let a = (*start*);(*end*)
             expectedMessage = "Unexpected symbol ';' in binding"
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.Error_Expression_KeywordAsValue() =
         this.VerifyErrorBetweenMarkers(
             fileContents =
@@ -106,7 +106,7 @@ let b =
             expectedMessage = "Incomplete structured construct at or before this point in binding"
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.Error_Type_WithoutName() =
         this.VerifyErrorBetweenMarkers(
             fileContents =
@@ -116,7 +116,7 @@ type (*start*)=(*end*)
             expectedMessage = "Unexpected symbol '=' in type name"
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.AbstractClasses_Constructors_PositiveTests_1() =
         this.VerifyNoErrors(
             """
@@ -127,7 +127,7 @@ type C(a : int) =
             """
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.AbstractClasses_Constructors_PositiveTests_2() =
         this.VerifyNoErrors(
             """
@@ -138,7 +138,7 @@ type C(a : int) =
             """
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.AbstractClasses_Constructors_PositiveTests_3() =
         this.VerifyNoErrors(
             """
@@ -148,7 +148,7 @@ type O(o : int) =
             """
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.AbstractClasses_Constructors_PositiveTests_4() =
         this.VerifyNoErrors(
             """
@@ -158,7 +158,7 @@ type O(o : int) =
             """
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.AbstractClasses_Constructors_PositiveTests_5() =
         this.VerifyNoErrors(
             """
@@ -168,7 +168,7 @@ type O(o : int) =
             """
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.AbstractClasses_Constructors_PositiveTests_6() =
         this.VerifyNoErrors(
             """
@@ -181,7 +181,7 @@ type E =
             """
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.AbstractClasses_Constructors_NegativeTests_1() =
         this.VerifyErrorAtMarker(
             fileContents =
@@ -194,7 +194,7 @@ type D =
             expectedMarker = "D()"
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.AbstractClasses_Constructors_NegativeTests_2() =
         this.VerifyErrorAtMarker(
             fileContents =
@@ -207,7 +207,7 @@ type Z () =
             expectedMarker = "Z()"
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.AbstractClasses_Constructors_NegativeTests_3() =
         this.VerifyErrorAtMarker(
             fileContents =
@@ -223,8 +223,8 @@ type Y() =
             expectedMarker = "new X()"
         )
 
-    [<Test>]
-    member public this.Waring_Construct_TypeMatchWithoutAnnotation() =
+    [<Fact>]
+    member public this.Warning_Construct_TypeMatchWithoutAnnotation() =
         this.VerifyWarningBetweenMarkers(
             fileContents =
                 """
@@ -240,7 +240,7 @@ let f () =
                 + "type 'string'."
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.Error_Identifer_IllegalFloatPointLiteral() =
         this.VerifyErrorBetweenMarkers(
             fileContents =
@@ -250,7 +250,7 @@ let x: float = 1.2(*start*).(*end*)3
             expectedMessage = "Missing qualification after '.'"
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.Error_TypeCheck_ParseError_Bug67133() =
         this.VerifyErrorBetweenMarkers(
             fileContents =
@@ -261,7 +261,7 @@ let gDateTime (arr: (*start*)DateTime(*end*)[]) =
             expectedMessage = "The type 'DateTime' is not defined."
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.Error_CyclicalDeclarationDoesNotCrash() =
         this.VerifyErrorBetweenMarkers(
             fileContents =
@@ -271,7 +271,7 @@ type (*start*)A(*end*) = int * A
             expectedMessage = "This type definition involves an immediate cyclic reference through an abbreviation"
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.Warning_FlagsAndSettings_TargetOptionsRespected() =
         this.VerifyWarningBetweenMarkers(
             fileContents =
@@ -283,7 +283,7 @@ let y = (*start*)fn(*end*) 1
             expectedMessage = "This construct is deprecated. x"
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.Basic_Case() =
         this.VerifyErrorBetweenMarkers(
             fileContents =
@@ -295,7 +295,7 @@ let arr = [| 1; 2; 3 |]
             expectedMessage = "This value is not a function and cannot be applied."
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.Multiline_Bug5449() =
         this.VerifyErrorBetweenMarkers(
             fileContents =
@@ -306,7 +306,7 @@ let r = (*start*)f 3(*end*) 4
             expectedMessage = "This value is not a function and cannot be applied."
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.InComputationExpression_Bug6095_A() =
         this.VerifyWarningBetweenMarkers(
             fileContents =
@@ -321,7 +321,7 @@ let a = async {
                 "Incomplete pattern matches on this expression. For example, the value '[|_; _; _|]' may indicate a case not covered by the pattern(s)."
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.InComputationExpression_Bug6095_B() =
         this.VerifyWarningBetweenMarkers(
             fileContents =
@@ -332,7 +332,7 @@ let f = (*start*)function(*end*) | [| a;b |] -> ()
                 "Incomplete pattern matches on this expression. For example, the value '[|_; _; _|]' may indicate a case not covered by the pattern(s)."
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.InComputationExpression_Bug6095_C() =
         this.VerifyWarningBetweenMarkers(
             fileContents =
@@ -343,7 +343,7 @@ for (*start*)[|a;b|](*end*) in [| [|42|] |] do ()
                 "Incomplete pattern matches on this expression. For example, the value '[|_; _; _|]' may indicate a case not covered by the pattern(s). Unmatched elements will be ignored."
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.InComputationExpression_Bug914685() =
         this.VerifyErrorAtMarker(
             fileContents =
@@ -353,7 +353,7 @@ async { if true then return 1 } |> ignore
             expectedMarker = "if true then"
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.ExtraEndif() =
         this.VerifyErrorBetweenMarkers(
             fileContents =
@@ -368,7 +368,7 @@ async { if true then return 1 } |> ignore
             expectedMessage = "#endif has no matching #if in implementation file"
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.Squiggles_HashNotFirstSymbol_If() =
         this.VerifyErrorAtMarker(
             fileContents =
@@ -383,7 +383,7 @@ async { if true then return 1 } |> ignore
             expectedMessage = "#if directive must appear as the first non-whitespace character on a line"
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.Squiggles_HashNotFirstSymbol_Endif() =
         this.VerifyErrorAtMarker(
             fileContents =
@@ -398,7 +398,7 @@ async { if true then return 1 } |> ignore
             expectedMessage = "#endif directive must appear as the first non-whitespace character on a line"
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.Squiggles_HashIfWithMultilineComment() =
         this.VerifyErrorAtMarker(
             fileContents =
@@ -410,7 +410,7 @@ async { if true then return 1 } |> ignore
             expectedMessage = "Expected single line comment or end of line"
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.Squiggles_HashIfWithUnexpected() =
         this.VerifyErrorAtMarker(
             fileContents =
@@ -422,7 +422,7 @@ async { if true then return 1 } |> ignore
             expectedMessage = "Incomplete preprocessor expression"
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.OverloadsAndExtensionMethodsForGenericTypes() =
         this.VerifyNoErrors(
             fileContents =
@@ -442,7 +442,7 @@ let g (t : T) = t.Count()
             """
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.DocumentDiagnosticsDontReportProjectErrors_Bug1596() =
         // https://github.com/dotnet/fsharp/issues/1596
         this.VerifyNoErrors(
diff --git a/vsintegration/tests/FSharp.Editor.Tests/DocumentHighlightsServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/DocumentHighlightsServiceTests.fs
index c6749195615..f590c76df1b 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/DocumentHighlightsServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/DocumentHighlightsServiceTests.fs
@@ -6,33 +6,18 @@ open FSharp.Editor.Tests.Helpers
 
 module DocumentHighlightsServiceTests =
 
-    open System
-    open NUnit.Framework
+    open Xunit
     open Microsoft.CodeAnalysis
     open Microsoft.CodeAnalysis.Text
     open Microsoft.VisualStudio.FSharp.Editor
-    open FSharp.Compiler.CodeAnalysis
     open FSharp.Compiler.Text
 
     let filePath = "C:\\test.fs"
 
-    let internal projectOptions =
-        {
-            ProjectFileName = "C:\\test.fsproj"
-            ProjectId = None
-            SourceFiles = [| filePath |]
-            ReferencedProjects = [||]
-            OtherOptions = [||]
-            IsIncompleteTypeCheckEnvironment = true
-            UseScriptResolutionRules = false
-            LoadTime = DateTime.MaxValue
-            UnresolvedReferences = None
-            OriginalLoadReferences = []
-            Stamp = None
-        }
-
-    let private getSpans (sourceText: SourceText) (caretPosition: int) =
-        let document = RoslynTestHelpers.CreateSingleDocumentSolution(filePath, sourceText)
+    let private getSpans (fileContents: string) (caretPosition: int) =
+        let document = 
+            RoslynTestHelpers.CreateSolution(fileContents)
+            |> RoslynTestHelpers.GetSingleDocument
 
         FSharpDocumentHighlightsService.GetDocumentHighlights(document, caretPosition)
         |> Async.RunSynchronously
@@ -47,7 +32,7 @@ module DocumentHighlightsServiceTests =
             TextSpan = RoslynHelpers.FSharpRangeToTextSpan(sourceText, range)
         }
 
-    [<Test>]
+    [<Fact>]
     let ShouldHighlightAllSimpleLocalSymbolReferences () =
         let fileContents =
             """
@@ -58,14 +43,14 @@ module DocumentHighlightsServiceTests =
 
         let sourceText = SourceText.From(fileContents)
         let caretPosition = fileContents.IndexOf("foo") + 1
-        let spans = getSpans sourceText caretPosition
+        let spans = getSpans fileContents caretPosition
 
         let expected =
             [| span sourceText true (2, 8) (2, 11); span sourceText false (4, 12) (4, 15) |]
 
-        Assert.AreEqual(expected, spans)
+        Assert.Equal<FSharpHighlightSpan array>(expected, spans)
 
-    [<Test>]
+    [<Fact>]
     let ShouldHighlightAllQualifiedSymbolReferences () =
         let fileContents =
             """
@@ -75,9 +60,9 @@ module DocumentHighlightsServiceTests =
 
         let sourceText = SourceText.From(fileContents)
         let caretPosition = fileContents.IndexOf("DateTime") + 1
-        let documentId = DocumentId.CreateNewId(ProjectId.CreateNewId())
+        let _ = DocumentId.CreateNewId(ProjectId.CreateNewId())
 
-        let spans = getSpans sourceText caretPosition
+        let spans = getSpans fileContents caretPosition
 
         let expected =
             [|
@@ -85,11 +70,11 @@ module DocumentHighlightsServiceTests =
                 span sourceText false (3, 19) (3, 27)
             |]
 
-        Assert.AreEqual(expected, spans)
+        Assert.Equal<FSharpHighlightSpan array>(expected, spans)
 
         let caretPosition = fileContents.IndexOf("Now") + 1
-        let documentId = DocumentId.CreateNewId(ProjectId.CreateNewId())
-        let spans = getSpans sourceText caretPosition
+        let _ = DocumentId.CreateNewId(ProjectId.CreateNewId())
+        let spans = getSpans fileContents caretPosition
         let expected = [| span sourceText false (2, 28) (2, 31) |]
 
-        Assert.AreEqual(expected, spans)
+        Assert.Equal<FSharpHighlightSpan array>(expected, spans)
diff --git a/vsintegration/tests/FSharp.Editor.Tests/EditorFormattingServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/EditorFormattingServiceTests.fs
index abf741b972d..2e917447cdf 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/EditorFormattingServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/EditorFormattingServiceTests.fs
@@ -2,33 +2,18 @@
 
 namespace FSharp.Editor.Tests
 
-open System
-open NUnit.Framework
+open Xunit
 open Microsoft.CodeAnalysis
 open Microsoft.CodeAnalysis.Text
 open Microsoft.VisualStudio.FSharp.Editor
 open FSharp.Compiler.CodeAnalysis
 open Microsoft.CodeAnalysis.Formatting
+open FSharp.Editor.Tests.Helpers
+open FSharp.Test
 
-[<TestFixture>]
 type EditorFormattingServiceTests() =
     let filePath = "C:\\test.fs"
 
-    let projectOptions: FSharpProjectOptions =
-        {
-            ProjectFileName = "C:\\test.fsproj"
-            ProjectId = None
-            SourceFiles = [| filePath |]
-            ReferencedProjects = [||]
-            OtherOptions = [||]
-            IsIncompleteTypeCheckEnvironment = true
-            UseScriptResolutionRules = false
-            LoadTime = DateTime.MaxValue
-            OriginalLoadReferences = []
-            UnresolvedReferences = None
-            Stamp = None
-        }
-
     let documentId = DocumentId.CreateNewId(ProjectId.CreateNewId())
     let indentStyle = FormattingOptions.IndentStyle.Smart
 
@@ -66,21 +51,22 @@ marker2
 
 marker4"""
 
-    [<TestCase("marker1", "]")>]
-    [<TestCase("marker2", "}")>]
-    [<TestCase("marker3", "    |]")>]
-    [<TestCase("marker4", "    )")>]
+    [<Theory>]
+    [<InlineData("marker1", "]")>]
+    [<InlineData("marker2", "}")>]
+    [<InlineData("marker3", "    |]")>]
+    [<InlineData("marker4", "    )")>]
     member this.TestIndentation(marker: string, expectedLine: string) =
         let checker = FSharpChecker.Create()
         let position = indentTemplate.IndexOf(marker)
-        Assert.IsTrue(position >= 0, "Precondition failed: unable to find marker in template")
+        Assert.True(position >= 0, "Precondition failed: unable to find marker in template")
 
         let sourceText = SourceText.From(indentTemplate)
 
         let lineNumber =
             sourceText.Lines |> Seq.findIndex (fun line -> line.Span.Contains position)
 
-        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions projectOptions
+        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
         let changesOpt =
             FSharpEditorFormattingService.GetFormattingChanges(
@@ -95,18 +81,19 @@ marker4"""
             |> Async.RunSynchronously
 
         match changesOpt with
-        | None -> Assert.Fail("Expected a text change, but got None")
+        | None -> failwith "Expected a text change, but got None"
         | Some changes ->
             let changedText = sourceText.WithChanges(changes)
             let lineText = changedText.Lines.[lineNumber].ToString()
-            Assert.IsTrue(lineText.StartsWith(expectedLine), "Changed line does not start with expected text")
+            Assert.True(lineText.StartsWith(expectedLine), "Changed line does not start with expected text")
 
-    [<TestCase(true, "")>]
-    [<TestCase(true, "        ")>]
-    [<TestCase(false, "")>]
+    [<Theory>]
+    [<InlineData(true, "")>]
+    [<InlineData(true, "        ")>]
+    [<InlineData(false, "")>]
     member this.TestPasteChanges_PastingOntoIndentedLine(enabled: bool, prefix: string) =
         let checker = FSharpChecker.Create()
-        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions projectOptions
+        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
         let clipboard =
             prefix
@@ -159,16 +146,17 @@ somethingElseHere
             match changesOpt with
             | Some changes ->
                 let changedText = sourceText.WithChanges(changes).ToString()
-                Assert.AreEqual(expected, changedText)
-            | _ -> Assert.Fail(sprintf "Expected text changes, but got %+A" changesOpt)
+                Assert.Equal(expected, changedText)
+            | _ -> failwithf "Expected text changes, but got %+A" changesOpt
         else
-            Assert.AreEqual(None, changesOpt, "Expected no changes as FormatOnPaste is disabled")
+            changesOpt |> Assert.shouldBeEqualWith None "Expected no changes as FormatOnPaste is disabled"
 
-    [<TestCase "">]
-    [<TestCase "        ">]
+    [<Theory>]
+    [<InlineData "">]
+    [<InlineData "        ">]
     member this.TestPasteChanges_PastingOntoEmptyLine(prefix: string) =
         let checker = FSharpChecker.Create()
-        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions projectOptions
+        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
         let clipboard =
             prefix
@@ -220,13 +208,13 @@ somethingElseHere
         match changesOpt with
         | Some changes ->
             let changedText = sourceText.WithChanges(changes).ToString()
-            Assert.AreEqual(expected, changedText)
-        | _ -> Assert.Fail(sprintf "Expected a changes, but got %+A" changesOpt)
+            Assert.Equal(expected, changedText)
+        | _ -> failwithf "Expected a changes, but got %+A" changesOpt
 
-    [<Test>]
+    [<Fact>]
     member this.TestPasteChanges_PastingWithAutoIndentationInPasteSpan() =
         let checker = FSharpChecker.Create()
-        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions projectOptions
+        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
         let clipboard =
             """[<Class>]
@@ -281,5 +269,5 @@ somethingElseHere
         match changesOpt with
         | Some changes ->
             let changedText = sourceText.WithChanges(changes).ToString()
-            Assert.AreEqual(expected, changedText)
-        | _ -> Assert.Fail(sprintf "Expected a changes, but got %+A" changesOpt)
+            Assert.Equal(expected, changedText)
+        | _ -> failwithf "Expected a changes, but got %+A" changesOpt
diff --git a/vsintegration/tests/FSharp.Editor.Tests/FSharp.Editor.Tests.fsproj b/vsintegration/tests/FSharp.Editor.Tests/FSharp.Editor.Tests.fsproj
index 53a86636a80..7c45d65bbce 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/FSharp.Editor.Tests.fsproj
+++ b/vsintegration/tests/FSharp.Editor.Tests/FSharp.Editor.Tests.fsproj
@@ -2,12 +2,16 @@
 
   <PropertyGroup>
     <TargetFramework>net472</TargetFramework>
-    <UnitTestType>nunit</UnitTestType>
+    <UnitTestType>xunit</UnitTestType>
     <IsPackable>false</IsPackable>
     <GenerateProgramFile>false</GenerateProgramFile>
     <DisableImplicitFSharpCoreReference>true</DisableImplicitFSharpCoreReference>
   </PropertyGroup>
 
+  <ItemGroup>
+    <Content Include="xunit.runner.json" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+
   <ItemGroup>
     <Compile Include="Helpers\RoslynHelpers.fs" />
     <Compile Include="Helpers\ProjectOptionsBuilder.fs" />
@@ -31,7 +35,7 @@
     <Compile Include="Hints\OverallHintExperienceTests.fs" />
     <Compile Include="EditorFormattingServiceTests.fs" />
     <Compile Include="RoslynSourceTextTests.fs" />
-    <Compile Include="SemanticColorizationServiceTests.fs" />
+    <Compile Include="SemanticClassificationServiceTests.fs" />
     <Compile Include="SyntacticColorizationServiceTests.fs" />
     <Compile Include="DocumentHighlightsServiceTests.fs" />
   </ItemGroup>
@@ -44,6 +48,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\..\..\tests\FSharp.Test.Utilities\FSharp.Test.Utilities.fsproj" />
     <ProjectReference Include="..\..\src\FSharp.Editor\FSharp.Editor.fsproj" />
   </ItemGroup>
 
diff --git a/vsintegration/tests/FSharp.Editor.Tests/FsxCompletionProviderTests.fs b/vsintegration/tests/FSharp.Editor.Tests/FsxCompletionProviderTests.fs
index b06a009c055..1cbe5025735 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/FsxCompletionProviderTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/FsxCompletionProviderTests.fs
@@ -4,8 +4,7 @@ namespace FSharp.Editor.Tests
 
 open System
 open System.Collections.Generic
-open NUnit.Framework
-open Microsoft.CodeAnalysis.Text
+open Xunit
 open Microsoft.VisualStudio.FSharp.Editor
 open FSharp.Compiler.CodeAnalysis
 open FSharp.Editor.Tests.Helpers
@@ -15,26 +14,13 @@ type Worker() =
 
     let filePath = "C:\\test.fsx"
 
-    let projectOptions =
-        {
-            ProjectFileName = "C:\\test.fsproj"
-            ProjectId = None
-            SourceFiles = [| filePath |]
-            ReferencedProjects = [||]
-            OtherOptions = [||]
-            IsIncompleteTypeCheckEnvironment = true
-            UseScriptResolutionRules = true
-            LoadTime = DateTime.MaxValue
-            OriginalLoadReferences = []
-            UnresolvedReferences = None
-            Stamp = None
-        }
-
     member _.VerifyCompletionListExactly(fileContents: string, marker: string, expected: List<string>) =
         let caretPosition = fileContents.IndexOf(marker) + marker.Length
 
+        let options = { RoslynTestHelpers.DefaultProjectOptions with SourceFiles = [|filePath|] }
         let document =
-            RoslynTestHelpers.CreateSingleDocumentSolution(filePath, SourceText.From(fileContents), options = projectOptions)
+            RoslynTestHelpers.CreateSolution(fileContents, options = options)
+            |> RoslynTestHelpers.GetSingleDocument
 
         let expected = expected |> Seq.toList
 
@@ -52,21 +38,20 @@ type Worker() =
         let actualNames = actual |> List.map (fun x -> x.DisplayText)
 
         if actualNames <> expected then
-            Assert.Fail(
-                sprintf
-                    "Expected:\n%s,\nbut was:\n%s\nactual with sort text:\n%s"
-                    (String.Join("; ", expected |> List.map (sprintf "\"%s\"")))
-                    (String.Join("; ", actualNames |> List.map (sprintf "\"%s\"")))
-                    (String.Join("\n", actual |> List.map (fun x -> sprintf "%s => %s" x.DisplayText x.SortText)))
-            )
+            failwithf
+                "Expected:\n%s,\nbut was:\n%s\nactual with sort text:\n%s"
+                (String.Join("; ", expected |> List.map (sprintf "\"%s\"")))
+                (String.Join("; ", actualNames |> List.map (sprintf "\"%s\"")))
+                (String.Join("\n", actual |> List.map (fun x -> sprintf "%s => %s" x.DisplayText x.SortText)))
 
 module FsxCompletionProviderTests =
 
     let getWorker () = Worker()
 
-    [<Test>]
 #if RELEASE
-    [<Ignore "Fails in some CI, reproduces locally in Release mode, needs investigation">]
+    [<Fact(Skip="Fails in some CI, reproduces locally in Release mode, needs investigation")>]
+#else
+    [<Fact>]
 #endif
     let fsiShouldTriggerCompletionInFsxFile () =
         let fileContents =
diff --git a/vsintegration/tests/FSharp.Editor.Tests/GoToDefinitionServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/GoToDefinitionServiceTests.fs
index 2386e432c4d..f4f534743a1 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/GoToDefinitionServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/GoToDefinitionServiceTests.fs
@@ -2,18 +2,14 @@
 
 namespace FSharp.Editor.Tests
 
-open System
-open System.IO
-open NUnit.Framework
+open Xunit
 open Microsoft.CodeAnalysis
 open Microsoft.CodeAnalysis.Text
 open Microsoft.VisualStudio.FSharp.Editor
-open FSharp.Compiler.CodeAnalysis
 open FSharp.Compiler.EditorServices
 open FSharp.Compiler.Text
 open FSharp.Editor.Tests.Helpers
 
-[<TestFixture>]
 module GoToDefinitionServiceTests =
 
     let userOpName = "GoToDefinitionServiceTests"
@@ -54,47 +50,28 @@ module GoToDefinitionServiceTests =
             | _ -> return! None
         }
 
-    let makeOptions filePath args =
-        {
-            ProjectFileName = "C:\\test.fsproj"
-            ProjectId = None
-            SourceFiles = [| filePath |]
-            ReferencedProjects = [||]
-            OtherOptions = args
-            IsIncompleteTypeCheckEnvironment = true
-            UseScriptResolutionRules = false
-            LoadTime = DateTime.MaxValue
-            OriginalLoadReferences = []
-            UnresolvedReferences = None
-            Stamp = None
-        }
-
-    let GoToDefinitionTest (fileContents: string, caretMarker: string, expected, opts) =
-
-        let filePath = Path.GetTempFileName() + ".fs"
-        File.WriteAllText(filePath, fileContents)
-        let options = makeOptions filePath opts
+    let GoToDefinitionTest (fileContents: string, caretMarker: string, expected) =
 
         let caretPosition = fileContents.IndexOf(caretMarker) + caretMarker.Length - 1 // inside the marker
 
-        let document, sourceText =
-            RoslynTestHelpers.CreateSingleDocumentSolution(filePath, fileContents, options = options)
+        let sourceText = SourceText.From(fileContents)
+        let document =
+            RoslynTestHelpers.CreateSolution(fileContents)
+            |> RoslynTestHelpers.GetSingleDocument
 
         let actual =
             findDefinition (document, sourceText, caretPosition, [])
             |> Option.map (fun range -> (range.StartLine, range.EndLine, range.StartColumn, range.EndColumn))
 
         if actual <> expected then
-            Assert.Fail(
-                sprintf
-                    "Incorrect information returned for fileContents=<<<%s>>>, caretMarker=<<<%s>>>, expected =<<<%A>>>, actual = <<<%A>>>"
-                    fileContents
-                    caretMarker
-                    expected
-                    actual
-            )
-
-    [<Test>]
+            failwithf
+                "Incorrect information returned for fileContents=<<<%s>>>, caretMarker=<<<%s>>>, expected =<<<%A>>>, actual = <<<%A>>>"
+                fileContents
+                caretMarker
+                expected
+                actual
+
+    [<Fact>]
     let ``goto definition smoke test`` () =
 
         let manyTestCases =
@@ -134,9 +111,9 @@ let _ = Module1.foo 1
             for caretMarker, expected in testCases do
 
                 printfn "Test case: caretMarker=<<<%s>>>" caretMarker
-                GoToDefinitionTest(fileContents, caretMarker, expected, [||])
+                GoToDefinitionTest(fileContents, caretMarker, expected)
 
-    [<Test>]
+    [<Fact>]
     let ``goto definition for string interpolation`` () =
 
         let fileContents =
@@ -147,9 +124,9 @@ let yyyy = $"{abc{xxxxx}def}" """
         let caretMarker = "xxxxx"
         let expected = Some(2, 2, 4, 9)
 
-        GoToDefinitionTest(fileContents, caretMarker, expected, [||])
+        GoToDefinitionTest(fileContents, caretMarker, expected)
 
-    [<Test>]
+    [<Fact>]
     let ``goto definition for static abstract method invocation`` () =
 
         let fileContents =
@@ -164,4 +141,4 @@ let f_IWSAM_flex_StaticProperty(x: #IStaticProperty<'T>) =
         let caretMarker = "'T.StaticProperty"
         let expected = Some(3, 3, 20, 34)
 
-        GoToDefinitionTest(fileContents, caretMarker, expected, [| "/langversion:preview" |])
+        GoToDefinitionTest(fileContents, caretMarker, expected)
diff --git a/vsintegration/tests/FSharp.Editor.Tests/HelpContextServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/HelpContextServiceTests.fs
index 1c02be655bf..4f93b1e0ef7 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/HelpContextServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/HelpContextServiceTests.fs
@@ -4,35 +4,14 @@ namespace FSharp.Editor.Tests
 
 open System
 open System.Threading
-open NUnit.Framework
+open Xunit
 open Microsoft.CodeAnalysis
-open FSharp.Compiler.CodeAnalysis
 open Microsoft.VisualStudio.FSharp.Editor
 open Microsoft.IO
 open FSharp.Editor.Tests.Helpers
+open Microsoft.CodeAnalysis.Text
 
-[<TestFixture>]
 type HelpContextServiceTests() =
-    let PathRelativeToTestAssembly p =
-        Path.Combine(Path.GetDirectoryName(Uri(System.Reflection.Assembly.GetExecutingAssembly().CodeBase).LocalPath), p)
-
-    let filePath = "C:\\test.fs"
-
-    let makeOptions args =
-        {
-            ProjectFileName = "C:\\test.fsproj"
-            ProjectId = None
-            SourceFiles = [| filePath |]
-            ReferencedProjects = [||]
-            OtherOptions = args
-            IsIncompleteTypeCheckEnvironment = true
-            UseScriptResolutionRules = false
-            LoadTime = DateTime.MaxValue
-            OriginalLoadReferences = []
-            UnresolvedReferences = None
-            Stamp = None
-        }
-
     let getMarkers (source: string) =
         let mutable cnt = 0
 
@@ -43,14 +22,14 @@ type HelpContextServiceTests() =
                     cnt <- cnt + 1
         ]
 
-    let TestF1KeywordsWithOptions (expectedKeywords: string option list, lines: string list, opts: string[]) =
-        let options = makeOptions opts
-
+    let TestF1KeywordsWithOptions (expectedKeywords: string option list, lines: string list) =
         let fileContentsWithMarkers = String.Join("\r\n", lines)
         let fileContents = fileContentsWithMarkers.Replace("$", "")
 
-        let document, sourceText =
-            RoslynTestHelpers.CreateSingleDocumentSolution(filePath, fileContents, options = options)
+        let sourceText = SourceText.From(fileContents)
+        let document =
+            RoslynTestHelpers.CreateSolution(fileContents)
+            |> RoslynTestHelpers.GetSingleDocument
 
         let markers = getMarkers fileContentsWithMarkers
 
@@ -72,14 +51,15 @@ type HelpContextServiceTests() =
         Assert.True(equalLength)
 
         for (exp, res) in List.zip expectedKeywords res do
-            Assert.AreEqual(exp, res)
+            Assert.Equal(exp, res)
 
     let TestF1Keywords (expectedKeywords, lines) =
-        TestF1KeywordsWithOptions(expectedKeywords, lines, [||])
+        TestF1KeywordsWithOptions(expectedKeywords, lines)
 
-    [<Test>]
 #if RELEASE
-    [<Ignore "Fails in some CI, reproduces locally in Release mode, needs investigation">]
+    [<Fact(Skip="Fails in some CI, reproduces locally in Release mode, needs investigation")>]
+#else
+    [<Fact>]
 #endif
     member _.``F1 help keyword NoKeyword.Negative``() =
         let file =
@@ -94,19 +74,19 @@ type HelpContextServiceTests() =
         let keywords = [ None; None; None ]
         TestF1Keywords(keywords, file)
 
-    [<Test>]
+    [<Fact>]
     member _.``F1 help keyword Preprocessor``() =
         let file = [ "#i$f foobaz"; "#e$ndif" ]
         let keywords = [ Some "#if_FS"; Some "#endif_FS" ]
         TestF1Keywords(keywords, file)
 
-    [<Test>]
+    [<Fact>]
     member _.``F1 help keyword Regression.DotNetMethod.854364``() =
         let file = [ "let i : int = 42"; "i.ToStri$ng()"; "i.ToStri$ng(\"format\")" ]
         let keywords = [ Some "System.Int32.ToString"; Some "System.Int32.ToString" ]
         TestF1Keywords(keywords, file)
 
-    [<Test>]
+    [<Fact>]
     member _.``F1 help keyword Namespaces``() =
         let file =
             [
@@ -122,7 +102,7 @@ type HelpContextServiceTests() =
 
         TestF1Keywords(keywords, file)
 
-    [<Test>]
+    [<Fact>]
     member _.``F1 help keyword Namespaces.BeforeDot``() =
         let file =
             [
@@ -148,7 +128,7 @@ type HelpContextServiceTests() =
 
         TestF1Keywords(keywords, file)
 
-    [<Test>]
+    [<Fact>]
     member _.``F1 help keyword Namespaces.AfterDot``() =
         let file =
             [
@@ -175,7 +155,7 @@ type HelpContextServiceTests() =
 
         TestF1Keywords(keywords, file)
 
-    [<Test>]
+    [<Fact>]
     member _.``F1 help keyword QuotedIdentifiers``() =
         let file =
             [
@@ -202,7 +182,7 @@ type HelpContextServiceTests() =
 
         TestF1Keywords(keywords, file)
 
-    [<Test>]
+    [<Fact>]
     member _.``F1 help keyword Attributes``() =
         let file =
             [
@@ -228,9 +208,10 @@ type HelpContextServiceTests() =
 
         TestF1Keywords(keywords, file)
 
-    [<Test>]
 #if RELEASE
-    [<Ignore "Fails in some CI, reproduces locally in Release mode, needs investigation">]
+    [<Fact(Skip="Fails in some CI, reproduces locally in Release mode, needs investigation")>]
+#else
+    [<Fact>]
 #endif
     //This test case Verify that when F1 is Hit on TypeProvider namespaces it contain the right keyword
     member _.``F1 help keyword TypeProvider.Namespaces``() =
@@ -239,16 +220,13 @@ type HelpContextServiceTests() =
 
         TestF1KeywordsWithOptions(
             keywords,
-            file,
-            [|
-                "-r:"
-                + PathRelativeToTestAssembly(@"DummyProviderForLanguageServiceTesting.dll")
-            |]
+            file
         )
 
-    [<Test>]
 #if RELEASE
-    [<Ignore "Fails in some CI, reproduces locally in Release mode, needs investigation">]
+    [<Fact(Skip="Fails in some CI, reproduces locally in Release mode, needs investigation")>]
+#else
+    [<Fact>]
 #endif
     //This test case Verify that when F1 is Hit on TypeProvider Type it contain the right keyword
     member _.``F1 help keyword TypeProvider.type``() =
@@ -263,26 +241,22 @@ type HelpContextServiceTests() =
 
         TestF1KeywordsWithOptions(
             keywords,
-            file,
-            [|
-                "-r:"
-                + PathRelativeToTestAssembly(@"DummyProviderForLanguageServiceTesting.dll")
-            |]
+            file
         )
 
-    [<Test>]
+    [<Fact>]
     member _.``F1 help keyword EndOfLine``() =
         let file = [ "open System.Net$"; "open System.IO$" ]
         let keywords = [ Some "System.Net"; Some "System.IO" ]
         TestF1Keywords(keywords, file)
 
-    [<Test>]
+    [<Fact>]
     member _.``F1 help keyword EndOfLine2``() =
         let file = [ "module M"; "open System.Net$"; "open System.IO$" ]
         let keywords = [ Some "System.Net"; Some "System.IO" ]
         TestF1Keywords(keywords, file)
 
-    [<Test>]
+    [<Fact>]
     member _.``F1 help keyword Comments``() =
         let file = [ "($* co$mment *$)"; "/$/ com$ment" ]
 
@@ -297,7 +271,7 @@ type HelpContextServiceTests() =
 
         TestF1Keywords(keywords, file)
 
-    [<Test>]
+    [<Fact>]
     member _.``F1 help keyword FSharpEntities``() =
         let file =
             [
@@ -333,7 +307,7 @@ type HelpContextServiceTests() =
 
         TestF1Keywords(keywords, file)
 
-    [<Test>]
+    [<Fact>]
     member _.``F1 help keyword Keywords``() =
         let file =
             [
@@ -349,13 +323,13 @@ type HelpContextServiceTests() =
 
         TestF1Keywords(keywords, file)
 
-    [<Test>]
+    [<Fact>]
     member _.``F1 help keyword Regression.NewInstance.854367``() =
         let file = [ "let q : System.Runtime.Remoting.TypeE$ntry = null" ]
         let keywords = [ Some "System.Runtime.Remoting.TypeEntry" ]
         TestF1Keywords(keywords, file)
 
-    [<Test>]
+    [<Fact>]
     member _.``F1 help keyword Regression.NewInstance.854367.2``() =
         let file =
             [
@@ -365,31 +339,31 @@ type HelpContextServiceTests() =
         let keywords = [ Some "System.Runtime.Remoting.TypeEntry" ]
         TestF1Keywords(keywords, file)
 
-    [<Test>]
+    [<Fact>]
     member _.``F1 help keyword Classes.WebClient``() =
         let file = [ "let w : System.Net.Web$Client = new System.Net.Web$Client()" ]
         let keywords = [ Some "System.Net.WebClient"; Some "System.Net.WebClient.#ctor" ]
         TestF1Keywords(keywords, file)
 
-    [<Test>]
+    [<Fact>]
     member _.``F1 help keyword Classes.Object``() =
         let file = [ "let w : System.Ob$ject = new System.Obj$ect()" ]
         let keywords = [ Some "System.Object"; Some "System.Object.#ctor" ]
         TestF1Keywords(keywords, file)
 
-    [<Test>]
+    [<Fact>]
     member _.``F1 help keyword Classes.Generic``() =
         let file = [ "let x : System.Collections.Generic.L$ist<int> = null" ]
         let keywords = [ Some "System.Collections.Generic.List`1" ]
         TestF1Keywords(keywords, file)
 
-    [<Test>]
+    [<Fact>]
     member _.``F1 help keyword Classes.Abbrev``() =
         let file = [ "let z : Resi$zeArray<int> = null" ]
         let keywords = [ Some "System.Collections.Generic.List`1" ]
         TestF1Keywords(keywords, file)
 
-    [<Test>]
+    [<Fact>]
     member _.``F1 help keyword Members``() =
         let file =
             [
@@ -421,7 +395,7 @@ type HelpContextServiceTests() =
 
         TestF1Keywords(keywords, file)
 
-    [<Test>]
+    [<Fact>]
     member _.``F1 help keyword static abstract interface method``() =
         let file =
             [
diff --git a/vsintegration/tests/FSharp.Editor.Tests/Helpers/ProjectOptionsBuilder.fs b/vsintegration/tests/FSharp.Editor.Tests/Helpers/ProjectOptionsBuilder.fs
index 395493ae148..1b643d0d71b 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/Helpers/ProjectOptionsBuilder.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/Helpers/ProjectOptionsBuilder.fs
@@ -152,21 +152,8 @@ module internal ProjectOptionsBuilder =
 
     let CreateProjectFromMarkup (markup: XElement) =
         match markup.Name.LocalName with
-        | "Project" -> CreateSingleProjectFromMarkup markup
         | "Projects" -> CreateMultipleProjectsFromMarkup markup
         | name -> failwith <| sprintf "Unsupported root node name: %s" name
 
     let CreateProject (markup: string) =
         XDocument.Parse(markup).Root |> CreateProjectFromMarkup
-
-    let SingleFileProject (code: string) =
-        code
-        |> sprintf
-            @"
-<Project Name=""testProject.fsproj"">
-  <File Name=""testFile.fs"">
-    <![CDATA[%s]]>
-  </File>
-</Project>
-"
-        |> CreateProject
diff --git a/vsintegration/tests/FSharp.Editor.Tests/Helpers/RoslynHelpers.fs b/vsintegration/tests/FSharp.Editor.Tests/Helpers/RoslynHelpers.fs
index 7e2af345e20..331a812ddd7 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/Helpers/RoslynHelpers.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/Helpers/RoslynHelpers.fs
@@ -15,6 +15,7 @@ open Microsoft.CodeAnalysis.Text
 open Microsoft.VisualStudio.FSharp.Editor
 open Microsoft.CodeAnalysis.Host.Mef
 open FSharp.Compiler.CodeAnalysis
+open System.Threading
 
 [<AutoOpen>]
 module MefHelpers =
@@ -203,125 +204,84 @@ type TestHostServices() =
 [<AbstractClass; Sealed>]
 type RoslynTestHelpers private () =
 
-    static member CreateSingleDocumentSolution(filePath, text: SourceText, ?options: FSharpProjectOptions) =
-        let isScript =
-            String.Equals(Path.GetExtension(filePath), ".fsx", StringComparison.OrdinalIgnoreCase)
-
+    static member DefaultProjectOptions: FSharpProjectOptions =
+        {
+            ProjectFileName = "C:\\test.fsproj"
+            ProjectId = None
+            SourceFiles = [| "C:\\test.fs" |]
+            ReferencedProjects = [||]
+            OtherOptions = [||]
+            IsIncompleteTypeCheckEnvironment = true
+            UseScriptResolutionRules = false
+            LoadTime = DateTime.MaxValue
+            UnresolvedReferences = None
+            OriginalLoadReferences = []
+            Stamp = None
+        }
+
+    static member private GetSourceCodeKind filePath = 
+        let extension = Path.GetExtension(filePath)
+        match extension with
+        | ".fsx" -> SourceCodeKind.Script
+        | ".fsi" -> SourceCodeKind.Regular
+        | ".fs" -> SourceCodeKind.Regular
+        | _ -> failwith "not supported"
+
+    static member CreateSolution projects =
         let workspace = new AdhocWorkspace(TestHostServices())
-
-        let projId = ProjectId.CreateNewId()
-        let docId = DocumentId.CreateNewId(projId)
-
-        let docInfo =
-            DocumentInfo.Create(
-                docId,
-                filePath,
-                loader = TextLoader.From(text.Container, VersionStamp.Create(DateTime.UtcNow)),
-                filePath = filePath,
-                sourceCodeKind =
-                    if isScript then
-                        SourceCodeKind.Script
-                    else
-                        SourceCodeKind.Regular
-            )
-
-        let projFilePath = "C:\\test.fsproj"
-
-        let projInfo =
-            ProjectInfo.Create(
-                projId,
-                VersionStamp.Create(DateTime.UtcNow),
-                projFilePath,
-                "test.dll",
-                LanguageNames.FSharp,
-                documents = [ docInfo ],
-                filePath = projFilePath
-            )
-
-        let solutionInfo =
-            SolutionInfo.Create(SolutionId.CreateNewId(), VersionStamp.Create(DateTime.UtcNow), "test.sln", [ projInfo ])
-
+        let id = SolutionId.CreateNewId()
+        let versionStamp = VersionStamp.Create(DateTime.UtcNow)
+        let slnPath = "test.sln"
+ 
+        let solutionInfo = SolutionInfo.Create(id, versionStamp, slnPath, projects)
         let solution = workspace.AddSolution(solutionInfo)
-
-        let workspaceService = workspace.Services.GetService<IFSharpWorkspaceService>()
-
-        let document = solution.GetProject(projId).GetDocument(docId)
-
-        match options with
-        | Some options ->
-            let options =
-                { options with
-                    ProjectId = Some(Guid.NewGuid().ToString())
-                }
-
-            workspaceService.FSharpProjectOptionsManager.SetCommandLineOptions(
+        solution
+
+    static member CreateDocumentInfo projId filePath (code: string) =
+        DocumentInfo.Create(
+            DocumentId.CreateNewId(projId),
+            filePath,
+            loader = TextLoader.From(SourceText.From(code).Container, VersionStamp.Create(DateTime.UtcNow)),
+            filePath = filePath,
+            sourceCodeKind = RoslynTestHelpers.GetSourceCodeKind filePath)
+
+    static member CreateProjectInfo id filePath documents =
+        ProjectInfo.Create(
+            id,
+            VersionStamp.Create(DateTime.UtcNow),
+            filePath,
+            "test.dll",
+            LanguageNames.FSharp,
+            documents = documents,
+            filePath = filePath)
+
+    static member SetProjectOptions projId (solution: Solution) (options: FSharpProjectOptions)  = 
+        solution
+            .Workspace
+            .Services
+            .GetService<IFSharpWorkspaceService>()
+            .FSharpProjectOptionsManager
+            .SetCommandLineOptions(
                 projId,
                 options.SourceFiles,
-                options.OtherOptions |> ImmutableArray.CreateRange
-            )
-
-            document.SetFSharpProjectOptionsForTesting(options)
-        | _ -> workspaceService.FSharpProjectOptionsManager.SetCommandLineOptions(projId, [| filePath |], ImmutableArray.Empty)
-
-        document
-
-    static member CreateTwoDocumentSolution(filePath1, text1: SourceText, filePath2, text2: SourceText) =
-        let workspace = new AdhocWorkspace(TestHostServices())
+                options.OtherOptions |> ImmutableArray.CreateRange)
 
+    static member CreateSolution (source, ?options: FSharpProjectOptions) =
         let projId = ProjectId.CreateNewId()
-        let docId1 = DocumentId.CreateNewId(projId)
-        let docId2 = DocumentId.CreateNewId(projId)
-
-        let docInfo1 =
-            DocumentInfo.Create(
-                docId1,
-                filePath1,
-                loader = TextLoader.From(text1.Container, VersionStamp.Create(DateTime.UtcNow)),
-                filePath = filePath1,
-                sourceCodeKind = SourceCodeKind.Regular
-            )
-
-        let docInfo2 =
-            DocumentInfo.Create(
-                docId2,
-                filePath2,
-                loader = TextLoader.From(text2.Container, VersionStamp.Create(DateTime.UtcNow)),
-                filePath = filePath2,
-                sourceCodeKind = SourceCodeKind.Regular
-            )
-
-        let projFilePath = "C:\\test.fsproj"
 
-        let projInfo =
-            ProjectInfo.Create(
-                projId,
-                VersionStamp.Create(DateTime.UtcNow),
-                projFilePath,
-                "test.dll",
-                LanguageNames.FSharp,
-                documents = [ docInfo1; docInfo2 ],
-                filePath = projFilePath
-            )
-
-        let solutionInfo =
-            SolutionInfo.Create(SolutionId.CreateNewId(), VersionStamp.Create(DateTime.UtcNow), "test.sln", [ projInfo ])
-
-        let solution = workspace.AddSolution(solutionInfo)
+        let docInfo = RoslynTestHelpers.CreateDocumentInfo projId "C:\\test.fs" source
 
-        workspace
-            .Services
-            .GetService<IFSharpWorkspaceService>()
-            .FSharpProjectOptionsManager.SetCommandLineOptions(projId, [| filePath1; filePath2 |], ImmutableArray.Empty)
+        let projFilePath = "C:\\test.fsproj"
+        let projInfo = RoslynTestHelpers.CreateProjectInfo projId projFilePath [docInfo]
+        let solution = RoslynTestHelpers.CreateSolution [projInfo]
 
-        let document1 = solution.GetProject(projId).GetDocument(docId1)
-        let document2 = solution.GetProject(projId).GetDocument(docId2)
-        document1, document2
+        options 
+        |> Option.defaultValue RoslynTestHelpers.DefaultProjectOptions
+        |> RoslynTestHelpers.SetProjectOptions projId solution
 
-    static member CreateSingleDocumentSolution(filePath, code: string, ?options) =
-        let text = SourceText.From(code)
-        RoslynTestHelpers.CreateSingleDocumentSolution(filePath, text, ?options = options), text
+        solution
 
-    static member CreateTwoDocumentSolution(filePath1, code1: string, filePath2, code2: string) =
-        let text1 = SourceText.From code1
-        let text2 = SourceText.From code2
-        RoslynTestHelpers.CreateTwoDocumentSolution(filePath1, text1, filePath2, text2)
+    static member GetSingleDocument(solution: Solution) =
+        let project = solution.Projects |> Seq.exactlyOne
+        let document = project.Documents |> Seq.exactlyOne
+        document
\ No newline at end of file
diff --git a/vsintegration/tests/FSharp.Editor.Tests/Hints/HintTestFramework.fs b/vsintegration/tests/FSharp.Editor.Tests/Hints/HintTestFramework.fs
index 751d089720c..7f9a8be3cbf 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/Hints/HintTestFramework.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/Hints/HintTestFramework.fs
@@ -2,10 +2,9 @@
 
 namespace FSharp.Editor.Tests.Hints
 
-open System.Threading
+open Microsoft.CodeAnalysis
 open Microsoft.VisualStudio.FSharp.Editor
 open Microsoft.VisualStudio.FSharp.Editor.Hints
-open Microsoft.CodeAnalysis.Text
 open Hints
 open FSharp.Editor.Tests.Helpers
 
@@ -30,17 +29,28 @@ module HintTestFramework =
         }
 
     let getFsDocument code =
-        use project = SingleFileProject code
-        let fileName = fst project.Files.Head
-        let document, _ = RoslynTestHelpers.CreateSingleDocumentSolution(fileName, code)
-        document
+        // I don't know, without this lib some symbols are just not loaded
+        let options = { RoslynTestHelpers.DefaultProjectOptions with OtherOptions = [| "--targetprofile:netcore" |] }
+        RoslynTestHelpers.CreateSolution(code, options = options)
+        |> RoslynTestHelpers.GetSingleDocument
 
     let getFsiAndFsDocuments (fsiCode: string) (fsCode: string) =
-        RoslynTestHelpers.CreateTwoDocumentSolution("test.fsi", SourceText.From fsiCode, "test.fs", SourceText.From fsCode)
+        let projectId = ProjectId.CreateNewId()
+        let projFilePath = "C:\\test.fsproj"
 
-    let getHints document hintKinds =
+        let fsiDocInfo = RoslynTestHelpers.CreateDocumentInfo projectId "C:\\test.fsi" fsiCode
+        let fsDocInfo = RoslynTestHelpers.CreateDocumentInfo projectId "C:\\test.fs" fsCode
+
+        let projInfo = RoslynTestHelpers.CreateProjectInfo projectId projFilePath [fsiDocInfo; fsDocInfo]
+        let solution = RoslynTestHelpers.CreateSolution [projInfo]
+        let project = solution.Projects |> Seq.exactlyOne
+        project.Documents
+
+    let getHints (document: Document) hintKinds =
         async {
-            let! hints = HintService.getHintsForDocument document hintKinds "test" CancellationToken.None
+            let! ct = Async.CancellationToken
+            let! sourceText = document.GetTextAsync ct |> Async.AwaitTask
+            let! hints = HintService.getHintsForDocument sourceText document hintKinds "test" ct
             return hints |> Seq.map convert
         }
         |> Async.RunSynchronously
@@ -53,5 +63,4 @@ module HintTestFramework =
 
     let getAllHints document =
         let hintKinds = Set.empty.Add(HintKind.TypeHint).Add(HintKind.ParameterNameHint)
-
         getHints document hintKinds
diff --git a/vsintegration/tests/FSharp.Editor.Tests/Hints/InlineParameterNameHintTests.fs b/vsintegration/tests/FSharp.Editor.Tests/Hints/InlineParameterNameHintTests.fs
index 532ce7adfe1..d9da400e4ad 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/Hints/InlineParameterNameHintTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/Hints/InlineParameterNameHintTests.fs
@@ -2,12 +2,12 @@
 
 namespace FSharp.Editor.Tests.Hints
 
-open NUnit.Framework
+open Xunit
 open HintTestFramework
 
 module InlineParameterNameHintTests =
 
-    [<Test>]
+    [<Fact>]
     let ``Hint is shown for a let binding`` () =
         let code =
             """
@@ -27,9 +27,9 @@ let greeting = greet "darkness"
 
         let actual = getParameterNameHints document
 
-        Assert.AreEqual(expected, actual)
+        Assert.Equal(expected, actual)
 
-    [<Test>]
+    [<Fact>]
     let ``Hints are shown for multiple function calls`` () =
         let code =
             """
@@ -54,9 +54,9 @@ let greeting2 = greet "Liam"
 
         let actual = getParameterNameHints document
 
-        Assert.AreEqual(expected, actual)
+        Assert.Equal(expected, actual)
 
-    [<Test>]
+    [<Fact>]
     let ``Hints are shown for multiple parameters`` () =
         let code =
             """
@@ -80,9 +80,9 @@ let greeting = greet "Liam" "Noel"
 
         let actual = getParameterNameHints document
 
-        Assert.AreEqual(expected, actual)
+        Assert.Equal(expected, actual)
 
-    [<Test>]
+    [<Fact>]
     let ``Hints are shown for tuple items`` () =
         let code =
             """
@@ -106,9 +106,9 @@ let greeting = greet ("Liam", "Noel")
 
         let actual = getParameterNameHints document
 
-        Assert.AreEqual(expected, actual)
+        Assert.Equal(expected, actual)
 
-    [<Test>]
+    [<Fact>]
     let ``Hints are shown for active patterns`` () =
         let code =
             """
@@ -141,9 +141,9 @@ let odd = evenOrOdd 41
 
         let actual = getParameterNameHints document
 
-        Assert.AreEqual(expected, actual)
+        Assert.Equal(expected, actual)
 
-    [<Test>] // here we don't want an empty hint before "x"
+    [<Fact>] // here we don't want an empty hint before "x"
     let ``Hints are not shown for nameless parameters`` () =
         let code =
             """
@@ -157,9 +157,9 @@ let exists predicate option =
 
         let result = getParameterNameHints document
 
-        Assert.IsEmpty(result)
+        Assert.Empty(result)
 
-    [<Test>] // here we don't want a useless (?) hint "value = "
+    [<Fact>] // here we don't want a useless (?) hint "value = "
     let ``Hints are not shown for parameters of built-in operators`` () =
         let code =
             """
@@ -170,9 +170,9 @@ let postTrue = not true
 
         let result = getParameterNameHints document
 
-        Assert.IsEmpty(result)
+        Assert.Empty(result)
 
-    [<Test>]
+    [<Fact>]
     let ``Hints are not shown for parameters of custom operators`` () =
         let code =
             """
@@ -185,9 +185,9 @@ let c = "javascript" === "javascript"
 
         let result = getParameterNameHints document
 
-        Assert.IsEmpty(result)
+        Assert.Empty(result)
 
-    [<Test>]
+    [<Fact>]
     let ``Hints are shown for method parameters`` () =
         let code =
             """
@@ -206,9 +206,9 @@ let theAnswer = System.Console.WriteLine 42
 
         let actual = getParameterNameHints document
 
-        Assert.AreEqual(expected, actual)
+        Assert.Equal(expected, actual)
 
-    [<Test>]
+    [<Fact>]
     let ``Hints are shown for parameters of overloaded and curried methods`` () =
         let code =
             """
@@ -253,9 +253,9 @@ let a = c.Normal "hmm"
 
         let actual = getParameterNameHints document
 
-        Assert.AreEqual(expected, actual)
+        Assert.Equal(expected, actual)
 
-    [<Test>]
+    [<Fact>]
     let ``Hints are shown for constructor parameters`` () =
         let code =
             """
@@ -285,9 +285,9 @@ let a = C (1, "")
 
         let actual = getParameterNameHints document
 
-        Assert.AreEqual(expected, actual)
+        Assert.Equal(expected, actual)
 
-    [<Test>]
+    [<Fact>]
     let ``Hints are shown for discriminated union case fields with explicit names`` () =
         let code =
             """
@@ -319,9 +319,9 @@ let b = Rectangle (1, 2)
 
         let actual = getParameterNameHints document
 
-        Assert.AreEqual(expected, actual)
+        Assert.Equal(expected, actual)
 
-    [<Test>]
+    [<Fact>]
     let ``Hints for discriminated union case fields are not shown when names are generated`` () =
         let code =
             """
@@ -349,9 +349,9 @@ let d = Circle 1
 
         let actual = getParameterNameHints document
 
-        Assert.AreEqual(expected, actual)
+        Assert.Equal(expected, actual)
 
-    [<Test>]
+    [<Fact>]
     let ``Hints for discriminated union case fields are not shown when provided arguments don't match the expected count`` () =
         let code =
             """
@@ -366,9 +366,9 @@ let c = Triangle (1, 2)
 
         let actual = getParameterNameHints document
 
-        Assert.IsEmpty(actual)
+        Assert.Empty(actual)
 
-    [<Test>]
+    [<Fact>]
     let ``Hints for discriminated union case fields are not shown for Cons`` () =
         let code =
             """
@@ -380,4 +380,140 @@ type X =
 
         let actual = getParameterNameHints document
 
-        Assert.IsEmpty(actual)
+        Assert.Empty(actual)
+
+    [<Fact>]
+    let ``Hints are not shown in front of indexes`` () =
+        let code =
+            """
+let x = "test".Split("").[0].Split("");
+"""
+
+        let document = getFsDocument code
+
+        let expected =
+            [
+                {
+                    Content = "separator = "
+                    Location = (1, 22)
+                }
+                {
+                    Content = "separator = "
+                    Location = (1, 36)
+                }
+            ]
+
+        let actual = getParameterNameHints document
+
+        Assert.Equal(expected, actual)
+
+    [<Fact>]
+    let ``Hints are not shown for optional parameters with specified names`` () =
+        let code =
+            """
+type MyType() =
+
+    member _.MyMethod(?beep: int, ?bap: int, ?boop: int) = ()
+
+    member this.Foo = this.MyMethod(3, boop = 4)
+"""
+
+        let document = getFsDocument code
+
+        let expected =
+            [
+                {
+                    Content = "beep = "
+                    Location = (5, 37)
+                }
+            ]
+
+        let actual = getParameterNameHints document
+
+        Assert.Equal(expected, actual)
+
+    [<Fact>]
+    let ``Hints are not shown when all optional parameters are named`` () =
+        let code =
+            """
+type MyType() =
+
+    member _.MyMethod(?beep: int, ?bap : int, ?boop : int) = ()
+
+    member this.Foo = this.MyMethod(bap = 3, beep = 4)
+"""
+
+        let document = getFsDocument code
+
+        let actual = getParameterNameHints document
+
+        Assert.Empty(actual)
+        
+    [<Fact>]
+    let ``Hints are shown correctly for inner bindings`` () =
+        let code =
+            """
+let test sequences = 
+    sequences
+    |> Seq.map (fun sequence -> sequence |> Seq.map (fun sequence' -> sequence' |> Seq.map (fun item -> item)))
+"""
+
+        let document = getFsDocument code
+
+        let expected =
+            [
+                {
+                    Content = "mapping = "
+                    Location = (3, 16)
+                }
+                {
+                    Content = "mapping = "
+                    Location = (3, 53)
+                }
+                {
+                    Content = "mapping = "
+                    Location = (3, 92)
+                }
+            ]
+
+        let actual = getParameterNameHints document
+
+        Assert.Equal(expected, actual)
+
+    [<Fact>]
+    let ``Hints are not shown when CustomOperation attribute is detected`` () =
+        let code =
+            """
+let q = query { for x in { 1 .. 10 } do select x }
+"""
+
+        let document = getFsDocument code
+
+        let actual = getParameterNameHints document
+
+        Assert.Empty actual
+
+    [<Fact>]
+    let ``Hints are not shown when parameter names coinside with variable names`` () =
+        let code =
+            """
+let getFullName name surname = $"{name} {surname}"
+
+let name = "Robert"
+let lastName = "Smith"
+let fullName = getFullName name lastName
+"""
+
+        let document = getFsDocument code
+
+        let expected =
+            [
+                {
+                    Content = "surname = "
+                    Location = (5, 33)
+                }
+            ]
+
+        let actual = getParameterNameHints document
+
+        Assert.Equal(expected, actual)
diff --git a/vsintegration/tests/FSharp.Editor.Tests/Hints/InlineTypeHintTests.fs b/vsintegration/tests/FSharp.Editor.Tests/Hints/InlineTypeHintTests.fs
index 0faf11e554c..a8219a3c53a 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/Hints/InlineTypeHintTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/Hints/InlineTypeHintTests.fs
@@ -2,12 +2,13 @@
 
 namespace FSharp.Editor.Tests.Hints
 
-open NUnit.Framework
+open Xunit
 open HintTestFramework
+open FSharp.Test
 
 module InlineTypeHintTests =
 
-    [<Test>]
+    [<Fact>]
     let ``Hint is shown for a let binding`` () =
         let code =
             """
@@ -28,9 +29,9 @@ let s = { Artist = "Moby"; Title = "Porcelain" }
 
         let actual = getTypeHints document
 
-        Assert.AreEqual(expected, actual)
+        Assert.Equal(expected, actual)
 
-    [<Test>]
+    [<Fact>]
     let ``Hint is shown for a parameter`` () =
         let code =
             """
@@ -51,9 +52,9 @@ let whoSings s = s.Artist
 
         let actual = getTypeHints document
 
-        Assert.AreEqual(expected, actual)
+        Assert.Equal(expected, actual)
 
-    [<Test>]
+    [<Fact>]
     let ``Hints are not shown in signature files`` () =
         let fsiCode =
             """
@@ -69,13 +70,13 @@ module Test
 let numbers = [|42|]
 """
 
-        let fsiDocument, _ = getFsiAndFsDocuments fsiCode fsCode
+        let fsiDocument = getFsiAndFsDocuments fsiCode fsCode |> Seq.head
 
         let result = getTypeHints fsiDocument
 
-        Assert.IsEmpty(result)
+        Assert.Empty(result)
 
-    [<Test>]
+    [<Fact>]
     let ``Hints are not shown for let-bound functions yet`` () =
         let code =
             """
@@ -86,9 +87,9 @@ let setConsoleOut = System.Console.SetOut
 
         let result = getTypeHints document
 
-        Assert.IsEmpty(result)
+        Assert.Empty(result)
 
-    [<Test>]
+    [<Fact>]
     let ``Hint is not shown for a let binding when the type is manually specified`` () =
         let code =
             """
@@ -101,9 +102,9 @@ let s: Song = { Artist = "Moby"; Title = "Porcelain" }
 
         let result = getTypeHints document
 
-        Assert.IsEmpty(result)
+        Assert.Empty(result)
 
-    [<Test>]
+    [<Fact>]
     let ``Hint is not shown for a parameter when the type is manually specified`` () =
         let code =
             """
@@ -116,9 +117,9 @@ let whoSings (s: Song) = s.Artist
 
         let result = getTypeHints document
 
-        Assert.IsEmpty(result)
+        Assert.Empty(result)
 
-    [<Test>] // here we don't want a hint after "this"
+    [<Fact>] // here we don't want a hint after "this"
     let ``Hint is not shown for type self-identifiers`` () =
         let code =
             """
@@ -130,9 +131,9 @@ type Song() =
 
         let result = getTypeHints document
 
-        Assert.IsEmpty(result)
+        Assert.Empty(result)
 
-    [<Test>] // here we don't want a hint after "x"
+    [<Fact>] // here we don't want a hint after "x"
     let ``Hint is not shown for type aliases`` () =
         let code =
             """
@@ -144,10 +145,10 @@ type Song() as x =
 
         let result = getTypeHints document
 
-        Assert.IsEmpty(result)
+        Assert.Empty(result)
 
-    [<Test>]
-    let ``Hints are shown for lambdas`` () =
+    [<Fact>]
+    let ``Hints are shown within lambdas`` () =
         let code =
             """
 let iamboring() =
@@ -159,10 +160,10 @@ let iamboring() =
 
         let actual = getTypeHints document
 
-        Assert.AreEqual(expected, actual)
+        Assert.Equal(expected, actual)
 
-    [<Test>]
-    let ``Hints are shown for lambdas with tuples`` () =
+    [<Fact>]
+    let ``Hints are shown within lambdas with tuples`` () =
         let code =
             """
 let zip4 (l1: 'a list) (l2: 'b list) (l3: 'c list) (l4: 'd list) =
@@ -182,9 +183,22 @@ let zip4 (l1: 'a list) (l2: 'b list) (l3: 'c list) (l4: 'd list) =
 
         let actual = getTypeHints document
 
-        CollectionAssert.AreEquivalent(expected, actual)
+        actual |> Assert.shouldBeEquivalentTo expected
 
-    [<Test>]
+    [<Fact>]
+    let ``Hints are not shown for lambda return types`` () =
+        let code =
+            """
+let func = fun () -> 3
+"""
+
+        let document = getFsDocument code
+
+        let result = getTypeHints document
+
+        Assert.Empty(result)
+
+    [<Fact>]
     let ``Hints are not shown for unfinished expressions`` () =
         let code =
             """
@@ -194,9 +208,9 @@ let x
 
         let result = getTypeHints document
 
-        Assert.IsEmpty(result)
+        Assert.Empty(result)
 
-    [<Test>]
+    [<Fact>]
     let ``Hints are not shown for unsolved types in _for_ expressions in collections`` () = 
         let code =
             """
@@ -206,9 +220,9 @@ let _ = [ for x ]
 
         let result = getTypeHints document
 
-        Assert.IsEmpty(result)
+        Assert.Empty(result)
 
-    [<Test>]
+    [<Fact>]
     let ``Hints are not shown for unsolved types in _for_ expressions within computational expressions`` () = 
         let code =
             """
@@ -222,9 +236,9 @@ do task {
 
         let result = getTypeHints document
 
-        Assert.IsEmpty(result)
+        Assert.Empty(result)
 
-    [<Test>]
+    [<Fact>]
     let ``Hints are shown for IWSAM`` () =
         let code =
             """
@@ -246,4 +260,21 @@ type Number<'T when IAddition<'T>>(value: 'T) =
 
         let actual = getTypeHints document
 
-        CollectionAssert.AreEquivalent(expected, actual)
+        actual |> Assert.shouldBeEquivalentTo expected
+
+    [<Fact>]
+    let ``Hints are not shown when type is specified`` () =
+        let code =
+            """
+type MyType() =
+
+    member _.MyMethod(?beep: int, ?bap: int, ?boop: int) = ()
+
+    member this.Foo = this.MyMethod(bap = 3, boop = 4)
+"""
+
+        let document = getFsDocument code
+
+        let result = getTypeHints document
+
+        Assert.Empty(result)
diff --git a/vsintegration/tests/FSharp.Editor.Tests/Hints/OptionParserTests.fs b/vsintegration/tests/FSharp.Editor.Tests/Hints/OptionParserTests.fs
index 778911047c8..da3f4cc8d7c 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/Hints/OptionParserTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/Hints/OptionParserTests.fs
@@ -2,7 +2,7 @@
 
 namespace FSharp.Editor.Tests.Hints
 
-open NUnit.Framework
+open Xunit
 open Microsoft.VisualStudio.FSharp.Editor
 open Microsoft.VisualStudio.FSharp.Editor.Hints
 open Microsoft.VisualStudio.FSharp.Editor.Hints.Hints
@@ -10,7 +10,7 @@ open Microsoft.VisualStudio.FSharp.Editor.Hints.Hints
 // best tests ever - very scalable
 module OptionParserTests =
 
-    [<Test>]
+    [<Fact>]
     let ``Type hints off, parameter name hints off`` () =
         let options =
             { AdvancedOptions.Default with
@@ -22,9 +22,9 @@ module OptionParserTests =
 
         let actual = OptionParser.getHintKinds options
 
-        Assert.AreEqual(expected, actual)
+        Assert.Equal(expected, actual)
 
-    [<Test>]
+    [<Fact>]
     let ``Type hints on, parameter name hints off`` () =
         let options =
             { AdvancedOptions.Default with
@@ -36,9 +36,9 @@ module OptionParserTests =
 
         let actual = OptionParser.getHintKinds options
 
-        Assert.AreEqual(expected, actual)
+        Assert.Equal(expected, actual)
 
-    [<Test>]
+    [<Fact>]
     let ``Type hints off, parameter name hints on`` () =
         let options =
             { AdvancedOptions.Default with
@@ -50,9 +50,9 @@ module OptionParserTests =
 
         let actual = OptionParser.getHintKinds options
 
-        Assert.AreEqual(expected, actual)
+        Assert.Equal(expected, actual)
 
-    [<Test>]
+    [<Fact>]
     let ``Type hints on, parameter name hints on`` () =
         let options =
             { AdvancedOptions.Default with
@@ -64,4 +64,4 @@ module OptionParserTests =
 
         let actual = OptionParser.getHintKinds options
 
-        Assert.AreEqual(expected, actual)
+        Assert.Equal(expected, actual)
diff --git a/vsintegration/tests/FSharp.Editor.Tests/Hints/OverallHintExperienceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/Hints/OverallHintExperienceTests.fs
index cd9c4fa7b14..187cf1c89e9 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/Hints/OverallHintExperienceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/Hints/OverallHintExperienceTests.fs
@@ -2,13 +2,14 @@
 
 namespace FSharp.Editor.Tests.Hints
 
-open NUnit.Framework
+open Xunit
 open HintTestFramework
+open FSharp.Test
 
 // just some kind of higher level testing
 module OverallHintExperienceTests =
 
-    [<Test>]
+    [<Fact>]
     let ``Current baseline hints`` () =
         let code =
             """
@@ -84,4 +85,4 @@ let cc = a.Normal "hmm"
 
         let actual = getAllHints document
 
-        CollectionAssert.AreEquivalent(expected, actual)
+        actual |> Assert.shouldBeEquivalentTo expected
diff --git a/vsintegration/tests/FSharp.Editor.Tests/IndentationServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/IndentationServiceTests.fs
index 6844b27b985..3ef331544c3 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/IndentationServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/IndentationServiceTests.fs
@@ -2,35 +2,20 @@
 
 namespace FSharp.Editor.Tests
 
-open System
-open NUnit.Framework
+open Xunit
 open Microsoft.CodeAnalysis
 open Microsoft.CodeAnalysis.Text
 open Microsoft.VisualStudio.FSharp.Editor
 open FSharp.Compiler.CodeAnalysis
 open Microsoft.CodeAnalysis.Formatting
+open FSharp.Editor.Tests.Helpers
+open FSharp.Test
 
-[<TestFixture>]
 type IndentationServiceTests() =
     let checker = FSharpChecker.Create()
 
     let filePath = "C:\\test.fs"
 
-    let projectOptions: FSharpProjectOptions =
-        {
-            ProjectFileName = "C:\\test.fsproj"
-            ProjectId = None
-            SourceFiles = [| filePath |]
-            ReferencedProjects = [||]
-            OtherOptions = [||]
-            IsIncompleteTypeCheckEnvironment = true
-            UseScriptResolutionRules = false
-            LoadTime = DateTime.MaxValue
-            OriginalLoadReferences = []
-            UnresolvedReferences = None
-            Stamp = None
-        }
-
     let documentId = DocumentId.CreateNewId(ProjectId.CreateNewId())
     let tabSize = 4
     let indentStyle = FormattingOptions.IndentStyle.Smart
@@ -175,12 +160,12 @@ while true do
                 None)
         |> Array.map (fun (lineNumber, expectedIndentation) -> (Some(expectedIndentation), lineNumber, autoIndentTemplate))
 
-    [<Test>]
+    [<Fact>]
     member this.TestIndentation() =
         for (expectedIndentation, lineNumber, template) in testCases do
             let sourceText = SourceText.From(template)
 
-            let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions projectOptions
+            let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
             let actualIndentation =
                 FSharpIndentationService.GetDesiredIndentation(
@@ -194,17 +179,17 @@ while true do
                 )
 
             match expectedIndentation with
-            | None -> Assert.IsTrue(actualIndentation.IsNone, "No indentation was expected at line {0}", lineNumber)
+            | None -> Assert.True(actualIndentation.IsNone, $"No indentation was expected at line {lineNumber}")
             | Some indentation ->
-                Assert.AreEqual(expectedIndentation.Value, actualIndentation.Value, "Indentation on line {0} doesn't match", lineNumber)
+                actualIndentation.Value |> Assert.shouldBeEqualWith indentation  $"Indentation on line {lineNumber} doesn't match"
 
-    [<Test>]
+    [<Fact>]
     member this.TestAutoIndentation() =
         for (expectedIndentation, lineNumber, template) in autoIndentTestCases do
 
             let sourceText = SourceText.From(template)
 
-            let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions projectOptions
+            let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
             let actualIndentation =
                 FSharpIndentationService.GetDesiredIndentation(
@@ -218,6 +203,6 @@ while true do
                 )
 
             match expectedIndentation with
-            | None -> Assert.IsTrue(actualIndentation.IsNone, "No indentation was expected at line {0}", lineNumber)
+            | None -> Assert.True(actualIndentation.IsNone, $"No indentation was expected at line {lineNumber}")
             | Some indentation ->
-                Assert.AreEqual(expectedIndentation.Value, actualIndentation.Value, "Indentation on line {0} doesn't match", lineNumber)
+                actualIndentation.Value |> Assert.shouldBeEqualWith indentation  $"Indentation on line {lineNumber} doesn't match"
diff --git a/vsintegration/tests/FSharp.Editor.Tests/LanguageDebugInfoServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/LanguageDebugInfoServiceTests.fs
index 92e8e1e890c..30a6c8ab79a 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/LanguageDebugInfoServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/LanguageDebugInfoServiceTests.fs
@@ -4,13 +4,12 @@ namespace FSharp.Editor.Tests
 
 open System
 open System.Threading
-open NUnit.Framework
+open Xunit
 open Microsoft.CodeAnalysis.Text
 open Microsoft.CodeAnalysis
 open Microsoft.VisualStudio.FSharp.Editor
 open FSharp.Compiler.Text
 
-[<TestFixture>]
 type LanguageDebugInfoServiceTests() =
     let fileName = "C:\\test.fs"
     let defines = []
@@ -35,7 +34,7 @@ let main argv =
     0 // return an integer exit code
     "
 
-    static member private testCases: Object[][] =
+    static member testCases: Object[][] =
         [|
             [| "123456"; None |] // Numeric literals are not interesting
             [| "is a string"; Some("\"This is a string\"") |]
@@ -44,10 +43,11 @@ let main argv =
             [| "%s"; Some("\"%d %s %A\"") |]
         |]
 
-    [<TestCaseSource("testCases")>]
+    [<Theory>]
+    [<MemberData(nameof(LanguageDebugInfoServiceTests.testCases))>]
     member this.TestDebugInfo(searchToken: string, expectedDataTip: string option) =
         let searchPosition = code.IndexOf(searchToken)
-        Assert.IsTrue(searchPosition >= 0, "SearchToken '{0}' is not found in code", searchToken)
+        Assert.True(searchPosition >= 0, $"SearchToken '{searchToken}' is not found in code")
 
         let sourceText = SourceText.From(code)
         let documentId = DocumentId.CreateNewId(ProjectId.CreateNewId())
@@ -66,14 +66,13 @@ let main argv =
             FSharpLanguageDebugInfoService.GetDataTipInformation(sourceText, searchPosition, classifiedSpans)
 
         match actualDataTipSpanOption with
-        | None -> Assert.IsTrue(expectedDataTip.IsNone, "LanguageDebugInfoService failed to produce a data tip")
+        | None -> Assert.True(expectedDataTip.IsNone, "LanguageDebugInfoService failed to produce a data tip")
         | Some (actualDataTipSpan) ->
             let actualDataTipText = sourceText.GetSubText(actualDataTipSpan).ToString()
 
-            Assert.IsTrue(
+            Assert.True(
                 expectedDataTip.IsSome,
-                "LanguageDebugInfoService produced a data tip while it shouldn't at: {0}",
-                actualDataTipText
+                $"LanguageDebugInfoService produced a data tip while it shouldn't at: {actualDataTipText}"
             )
 
-            Assert.AreEqual(expectedDataTip.Value, actualDataTipText, "Expected and actual data tips should match")
+            Assert.Equal(expectedDataTip.Value, actualDataTipText)
diff --git a/vsintegration/tests/FSharp.Editor.Tests/QuickInfoProviderTests.fs b/vsintegration/tests/FSharp.Editor.Tests/QuickInfoProviderTests.fs
index 0a2c9e4b946..ed7ed67d85e 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/QuickInfoProviderTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/QuickInfoProviderTests.fs
@@ -3,37 +3,21 @@
 namespace FSharp.Editor.Tests
 
 open System
-open NUnit.Framework
+open Xunit
 open FSharp.Compiler.EditorServices
 open FSharp.Compiler.CodeAnalysis
 open Microsoft.VisualStudio.FSharp.Editor
 open FSharp.Editor.Tests.Helpers
+open FSharp.Test
 
-[<SetUpFixture>]
 type public AssemblyResolverTestFixture() =
 
-    [<OneTimeSetUp>]
     member public __.Init() = AssemblyResolver.addResolver ()
 
 module QuickInfoProviderTests =
 
     let filePath = "C:\\test.fs"
 
-    let internal projectOptions =
-        {
-            ProjectFileName = "C:\\test.fsproj"
-            ProjectId = None
-            SourceFiles = [| filePath |]
-            ReferencedProjects = [||]
-            OtherOptions = [||]
-            IsIncompleteTypeCheckEnvironment = true
-            UseScriptResolutionRules = false
-            LoadTime = DateTime.MaxValue
-            OriginalLoadReferences = []
-            UnresolvedReferences = None
-            Stamp = None
-        }
-
     let private normalizeLineEnds (s: string) =
         s.Replace("\r\n", "\n").Replace("\n\n", "\n")
 
@@ -76,28 +60,28 @@ module QuickInfoProviderTests =
         elements |> List.map parseElement |> String.concat "\n" |> normalizeLineEnds
 
     let executeQuickInfoTest (programText: string) testCases =
-        let document, _ =
-            RoslynTestHelpers.CreateSingleDocumentSolution(filePath, programText)
+        let document =
+            RoslynTestHelpers.CreateSolution(programText)
+            |> RoslynTestHelpers.GetSingleDocument
 
-        Assert.Multiple(fun _ ->
-            for (symbol: string, expected: string option) in testCases do
-                let expected =
-                    expected
-                    |> Option.map normalizeLineEnds
-                    |> Option.map (fun s -> s.Replace("___", ""))
+        for (symbol: string, expected: string option) in testCases do
+            let expected =
+                expected
+                |> Option.map normalizeLineEnds
+                |> Option.map (fun s -> s.Replace("___", ""))
 
-                let caretPosition = programText.IndexOf(symbol) + symbol.Length - 1
+            let caretPosition = programText.IndexOf(symbol) + symbol.Length - 1
 
-                let quickInfo =
-                    FSharpAsyncQuickInfoSource.ProvideQuickInfo(document, caretPosition)
-                    |> Async.RunSynchronously
+            let quickInfo =
+                FSharpAsyncQuickInfoSource.ProvideQuickInfo(document, caretPosition)
+                |> Async.RunSynchronously
 
-                let actual =
-                    quickInfo |> Option.map (fun qi -> tooltipTextToRawString qi.StructuredText)
+            let actual =
+                quickInfo |> Option.map (fun qi -> tooltipTextToRawString qi.StructuredText)
 
-                Assert.AreEqual(expected, actual, "Symbol: " + symbol))
+            actual |> Assert.shouldBeEqualWith expected $"Symbol: {symbol}"
 
-    [<Test>]
+    [<Fact>]
     let ShouldShowQuickInfoAtCorrectPositions () =
         let fileContents =
             """
@@ -126,7 +110,7 @@ Full name: Microsoft.FSharp.Core.Operators.(+)
 
         executeQuickInfoTest fileContents testCases
 
-    [<Test>]
+    [<Fact>]
     let ShouldShowQuickKeywordInfoAtCorrectPositionsForSignatureFiles () =
         let fileContents =
             """
@@ -152,7 +136,7 @@ module internal MyModule =
 
         executeQuickInfoTest fileContents testCases
 
-    [<Test>]
+    [<Fact>]
     let ShouldShowQuickKeywordInfoAtCorrectPositionsWithinComputationExpressions () =
         let fileContents =
             """
@@ -178,7 +162,7 @@ let x =
 
         executeQuickInfoTest fileContents testCases
 
-    [<Test>]
+    [<Fact>]
     let ShouldShowQuickInfoForGenericParameters () =
         let fileContents =
             """
diff --git a/vsintegration/tests/FSharp.Editor.Tests/QuickInfoTests.fs b/vsintegration/tests/FSharp.Editor.Tests/QuickInfoTests.fs
index 0d6cac3b5a5..a68e1530847 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/QuickInfoTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/QuickInfoTests.fs
@@ -2,23 +2,38 @@
 
 namespace FSharp.Editor.Tests
 
-open System.IO
 open Microsoft.VisualStudio.FSharp.Editor
-open NUnit.Framework
+open Xunit
 open FSharp.Editor.Tests.Helpers
 
 module QuickInfo =
 
-    let internal GetQuickInfo (project: FSharpProject) (fileName: string) (caretPosition: int) =
+    let private GetCaretPosition (codeWithCaret: string) =
+        let caretSentinel = "$$"
+        let mutable cursorInfo: (int * string) = (0, null)
+
+        // find the '$$' sentinel that represents the cursor location
+        let caretPosition = codeWithCaret.IndexOf(caretSentinel)
+
+        if caretPosition >= 0 then
+            let newContents =
+                codeWithCaret.Substring(0, caretPosition)
+                + codeWithCaret.Substring(caretPosition + caretSentinel.Length)
+
+            cursorInfo <- caretPosition, newContents
+
+        cursorInfo
+
+    let internal GetQuickInfo (code: string) caretPosition =
         async {
-            let code = File.ReadAllText(fileName)
-            let document, _ = RoslynTestHelpers.CreateSingleDocumentSolution(fileName, code)
+            let document = RoslynTestHelpers.CreateSolution(code) |> RoslynTestHelpers.GetSingleDocument
             return! FSharpAsyncQuickInfoSource.ProvideQuickInfo(document, caretPosition)
         }
         |> Async.RunSynchronously
 
-    let GetQuickInfoText (project: FSharpProject) (fileName: string) (caretPosition: int) =
-        let sigHelp = GetQuickInfo project fileName caretPosition
+    let GetQuickInfoTextFromCode (codeWithCaret: string) =
+        let caretPosition, code = GetCaretPosition codeWithCaret
+        let sigHelp = GetQuickInfo code caretPosition
 
         match sigHelp with
         | Some (quickInfo) ->
@@ -36,14 +51,9 @@ module QuickInfo =
             System.String.Join(System.String.Empty, (Seq.concat [ mainTextItems; docTextItems ]))
         | _ -> ""
 
-    let GetQuickInfoTextFromCode (code: string) =
-        use project = SingleFileProject code
-        let fileName, caretPosition = project.GetCaretPosition()
-        GetQuickInfoText project fileName caretPosition
-
     let expectedLines (lines: string list) = System.String.Join("\n", lines)
 
-    [<Test>]
+    [<Fact>]
     let ``Automation.EnumDUInterfacefromFSBrowse.InsideComputationExpression`` () =
         let code =
             """
@@ -67,9 +77,9 @@ module Test =
 
         let quickInfo = GetQuickInfoTextFromCode code
         let expected = "MyColors.Red: MyColors = 0"
-        Assert.AreEqual(expected, quickInfo)
+        Assert.Equal(expected, quickInfo)
 
-    [<Test>]
+    [<Fact>]
     let ``Automation.EnumDUInterfacefromFSBrowse.InsideMatch`` () =
         let code =
             """
@@ -103,9 +113,9 @@ module Test =
                     "Full name: FsTest.MyDistance"
                 ]
 
-        Assert.AreEqual(expected, quickInfo)
+        Assert.Equal(expected, quickInfo)
 
-    [<Test>]
+    [<Fact>]
     let ``Automation.EnumDUInterfacefromFSBrowse.InsideLambda`` () =
         let code =
             """
@@ -133,9 +143,9 @@ module Test =
 
         let quickInfo = GetQuickInfoTextFromCode code
         let expected = "abstract IMyInterface.Represent: unit -> string"
-        Assert.AreEqual(expected, quickInfo)
+        Assert.Equal(expected, quickInfo)
 
-    [<Test>]
+    [<Fact>]
     let ``Automation.RecordAndInterfaceFromFSProj.InsideComputationExpression`` () =
         let code =
             """
@@ -171,10 +181,10 @@ module Test =
                     "Full name: FsTest.MyEmployee"
                 ]
 
-        Assert.AreEqual(expected, quickInfo)
+        Assert.Equal(expected, quickInfo)
         ()
 
-    [<Test>]
+    [<Fact>]
     let ``Automation.RecordAndInterfaceFromFSProj.InsideQuotation`` () =
         let code =
             """
@@ -196,10 +206,10 @@ module Test =
 
         let quickInfo = GetQuickInfoTextFromCode code
         let expected = "val aa: MyEmployee"
-        Assert.AreEqual(expected, quickInfo)
+        Assert.Equal(expected, quickInfo)
         ()
 
-    [<Test>]
+    [<Fact>]
     let ``Automation.RecordAndInterfaceFromFSProj.InsideLambda`` () =
         let code =
             """
@@ -223,10 +233,10 @@ module Test =
 
         let quickInfo = GetQuickInfoTextFromCode code
         let expected = "MyEmployee.IsFTE: bool"
-        Assert.AreEqual(expected, quickInfo)
+        Assert.Equal(expected, quickInfo)
         ()
 
-    [<Test>]
+    [<Fact>]
     let ``Automation.TupleRecordFromFSBrowse.InsideComputationExpression`` () =
         let code =
             """
@@ -249,10 +259,10 @@ module Test =
 
         let quickInfo = GetQuickInfoTextFromCode code
         let expected = "val myTuple: int * string * float * (int -> string * int)"
-        Assert.AreEqual(expected, quickInfo)
+        Assert.Equal(expected, quickInfo)
         ()
 
-    [<Test>]
+    [<Fact>]
     let ``Automation.TupleRecordFromFSBrowse.SequenceOfMethods`` () =
         let code =
             """
@@ -279,10 +289,10 @@ module Test =
 
         let quickInfo = GetQuickInfoTextFromCode code
         let expected = "val methodSeq: seq<(int -> string * int)>"
-        Assert.AreEqual(expected, quickInfo)
+        Assert.Equal(expected, quickInfo)
         ()
 
-    [<Test>]
+    [<Fact>]
     let ``Automation.UnionAndStructFromFSProj.MatchExpression`` () =
         let code =
             """
@@ -303,10 +313,10 @@ module Test =
 
         let quickInfo = GetQuickInfoTextFromCode code
         let expected = "val p1: MyPoint"
-        Assert.AreEqual(expected, quickInfo)
+        Assert.Equal(expected, quickInfo)
         ()
 
-    [<Test>]
+    [<Fact>]
     let ``Automation.UnionAndStructFromFSProj.MatchPattern`` () =
         let code =
             """
@@ -327,10 +337,10 @@ module Test =
 
         let quickInfo = GetQuickInfoTextFromCode code
         let expected = "val p3: MyPoint"
-        Assert.AreEqual(expected, quickInfo)
+        Assert.Equal(expected, quickInfo)
         ()
 
-    [<Test>]
+    [<Fact>]
     let ``Automation.UnionAndStructFromFSProj.UnionIfPredicate`` () =
         let code =
             """
@@ -350,10 +360,10 @@ module Test =
 
         let quickInfo = GetQuickInfoTextFromCode code
         let expected = "val dd: MyDistance"
-        Assert.AreEqual(expected, quickInfo)
+        Assert.Equal(expected, quickInfo)
         ()
 
-    [<Test>]
+    [<Fact>]
     let ``Automation.UnionAndStructFromFSProj.UnionForPattern`` () =
         let code =
             """
@@ -373,10 +383,10 @@ module Test =
 
         let quickInfo = GetQuickInfoTextFromCode code
         let expected = "val distance: MyDistance"
-        Assert.AreEqual(expected, quickInfo)
+        Assert.Equal(expected, quickInfo)
         ()
 
-    [<Test>]
+    [<Fact>]
     let ``Automation.UnionAndStructFromFSProj.UnionMethodPatternMatch`` () =
         let code =
             """
@@ -404,10 +414,10 @@ module Test =
 
         let quickInfo = GetQuickInfoTextFromCode code
         let expected = "static member MyDistance.toMiles: x: MyDistance -> MyDistance"
-        Assert.AreEqual(expected, quickInfo)
+        Assert.Equal(expected, quickInfo)
         ()
 
-    [<Test>]
+    [<Fact>]
     let ``Automation.UnionAndStructFromFSProj.UnionMethodPatternMatchBody`` () =
         let code =
             """
@@ -433,10 +443,10 @@ module Test =
 
         let quickInfo = GetQuickInfoTextFromCode code
         let expected = "member MyDistance.IncreaseBy: dist: float -> MyDistance"
-        Assert.AreEqual(expected, quickInfo)
+        Assert.Equal(expected, quickInfo)
         ()
 
-    [<Test>]
+    [<Fact>]
     let ``Automation.UnionAndStructFromFSProj.UnionPropertyInComputationExpression`` () =
         let code =
             """
@@ -465,10 +475,10 @@ module Test =
 
         let quickInfo = GetQuickInfoTextFromCode code
         let expected = "property MyDistance.asNautical: MyDistance with get"
-        Assert.AreEqual(expected, quickInfo)
+        Assert.Equal(expected, quickInfo)
         ()
 
-    [<Test>]
+    [<Fact>]
     let ``Automation.LetBindings.Module`` () =
         let code =
             """
@@ -482,10 +492,10 @@ module Test =
 
         let tooltip = GetQuickInfoTextFromCode code
 
-        StringAssert.StartsWith(expectedSignature, tooltip)
+        Assert.StartsWith(expectedSignature, tooltip)
         ()
 
-    [<Test>]
+    [<Fact>]
     let ``Automation.LetBindings.InsideType.Instance`` () =
         let code =
             """
@@ -500,9 +510,9 @@ module Test =
 
         let tooltip = GetQuickInfoTextFromCode code
 
-        StringAssert.StartsWith(expectedSignature, tooltip)
+        Assert.StartsWith(expectedSignature, tooltip)
 
-    [<Test>]
+    [<Fact>]
     let ``Automation.LetBindings.InsideType.Static`` () =
         let code =
             """
@@ -517,10 +527,10 @@ module Test =
 
         let tooltip = GetQuickInfoTextFromCode code
 
-        StringAssert.StartsWith(expectedSignature, tooltip)
+        Assert.StartsWith(expectedSignature, tooltip)
         ()
 
-    [<Test>]
+    [<Fact>]
     let ``Automation.LetBindings`` () =
         let code =
             """
@@ -534,9 +544,9 @@ module Test =
 
         let expectedSignature = "val func: x: 'a -> unit"
         let tooltip = GetQuickInfoTextFromCode code
-        StringAssert.StartsWith(expectedSignature, tooltip)
+        Assert.StartsWith(expectedSignature, tooltip)
 
-    [<Test>]
+    [<Fact>]
     let ``quick info for IWSAM property get`` () =
         let code =
             """
@@ -549,9 +559,9 @@ let f_IWSAM_flex_StaticProperty(x: #IStaticProperty<'T>) =
 
         let expectedSignature = "property IStaticProperty.StaticProperty: 'T with get"
         let tooltip = GetQuickInfoTextFromCode code
-        StringAssert.StartsWith(expectedSignature, tooltip)
+        Assert.StartsWith(expectedSignature, tooltip)
 
-    [<Test>]
+    [<Fact>]
     let ``quick info for IWSAM method call`` () =
         let code =
             """
@@ -564,9 +574,9 @@ let f (x: #IStaticMethod<'T>) =
 
         let expectedSignature = "static abstract IStaticMethod.StaticMethod: unit -> 'T"
         let tooltip = GetQuickInfoTextFromCode code
-        StringAssert.StartsWith(expectedSignature, tooltip)
+        Assert.StartsWith(expectedSignature, tooltip)
 
-    [<Test>]
+    [<Fact>]
     let ``quick info for SRTP property get`` () =
         let code =
             """
@@ -577,9 +587,9 @@ let inline f_StaticProperty_SRTP<'T when 'T : (static member StaticProperty: 'T)
 
         let expectedSignature = "'T: (static member StaticProperty: 'T)"
         let tooltip = GetQuickInfoTextFromCode code
-        StringAssert.StartsWith(expectedSignature, tooltip)
+        Assert.StartsWith(expectedSignature, tooltip)
 
-    [<Test>]
+    [<Fact>]
     let ``quick info for SRTP method call`` () =
         let code =
             """
@@ -590,9 +600,9 @@ let inline f_StaticProperty_SRTP<'T when 'T : (static member StaticMethod: unit
 
         let expectedSignature = "'T: (static member StaticMethod: unit -> 'T)"
         let tooltip = GetQuickInfoTextFromCode code
-        StringAssert.StartsWith(expectedSignature, tooltip)
+        Assert.StartsWith(expectedSignature, tooltip)
 
-    [<Test>]
+    [<Fact>]
     let ``Display names for exceptions with backticks preserve backticks`` () =
         let code =
             """
@@ -602,24 +612,24 @@ exception SomeError of ``thing wi$$th space``: string
         let expected = "``thing with space``"
 
         let actual = GetQuickInfoTextFromCode code
-        StringAssert.Contains(expected, actual)
+        Assert.Contains(expected, actual)
         ()
 
-    [<Test>]
+    [<Fact>]
     let ``Display names for anonymous record fields with backticks preserve backticks`` () =
         let code =
             """
 type R = {| ``thing wi$$th space``: string |}
 """
-
+        
         let expected = "``thing with space``"
 
         let actual = GetQuickInfoTextFromCode code
 
-        StringAssert.Contains(expected, actual)
+        Assert.Contains(expected, actual)
         ()
 
-    [<Test>]
+    [<Fact>]
     let ``Display names identifiers for active patterns with backticks preserve backticks`` () =
         let code =
             """
@@ -634,5 +644,5 @@ match 4 with
 
         let actual = GetQuickInfoTextFromCode code
 
-        StringAssert.Contains(expected, actual)
+        Assert.Contains(expected, actual)
         ()
diff --git a/vsintegration/tests/FSharp.Editor.Tests/RoslynSourceTextTests.fs b/vsintegration/tests/FSharp.Editor.Tests/RoslynSourceTextTests.fs
index e06392e5e5e..f2e3a1a0331 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/RoslynSourceTextTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/RoslynSourceTextTests.fs
@@ -3,31 +3,30 @@
 namespace FSharp.Editor.Tests
 
 open System
-open NUnit.Framework
+open Xunit
 open Microsoft.VisualStudio.FSharp.Editor
 open Microsoft.CodeAnalysis.Text
 
-[<TestFixture>]
 module RoslynSourceTextTests =
 
-    [<Test>]
+    [<Fact>]
     let SourceText () =
         let text = "test\ntest2\r\ntest3\n\ntest4\ntest5\rtest6\n"
         let sourceText = SourceText.From(text).ToFSharpSourceText()
 
-        Assert.AreEqual("test", sourceText.GetLineString(0))
-        Assert.AreEqual("test2", sourceText.GetLineString(1))
-        Assert.AreEqual("test3", sourceText.GetLineString(2))
-        Assert.AreEqual("", sourceText.GetLineString(3))
-        Assert.AreEqual("test4", sourceText.GetLineString(4))
-        Assert.AreEqual("test5", sourceText.GetLineString(5))
-        Assert.AreEqual("test6", sourceText.GetLineString(6))
-        Assert.AreEqual("", sourceText.GetLineString(7))
-        Assert.AreEqual(8, sourceText.GetLineCount())
+        Assert.Equal("test", sourceText.GetLineString(0))
+        Assert.Equal("test2", sourceText.GetLineString(1))
+        Assert.Equal("test3", sourceText.GetLineString(2))
+        Assert.Equal("", sourceText.GetLineString(3))
+        Assert.Equal("test4", sourceText.GetLineString(4))
+        Assert.Equal("test5", sourceText.GetLineString(5))
+        Assert.Equal("test6", sourceText.GetLineString(6))
+        Assert.Equal("", sourceText.GetLineString(7))
+        Assert.Equal(8, sourceText.GetLineCount())
 
         let (count, length) = sourceText.GetLastCharacterPosition()
-        Assert.AreEqual(8, count)
-        Assert.AreEqual(0, length)
+        Assert.Equal(8, count)
+        Assert.Equal(0, length)
 
         Assert.True(sourceText.SubTextEquals("test", 0))
         Assert.True(sourceText.SubTextEquals("test2", 5))
diff --git a/vsintegration/tests/FSharp.Editor.Tests/SemanticColorizationServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/SemanticClassificationServiceTests.fs
similarity index 64%
rename from vsintegration/tests/FSharp.Editor.Tests/SemanticColorizationServiceTests.fs
rename to vsintegration/tests/FSharp.Editor.Tests/SemanticClassificationServiceTests.fs
index 3b0a425c325..47c6edac8dc 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/SemanticColorizationServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/SemanticClassificationServiceTests.fs
@@ -2,21 +2,21 @@
 
 namespace FSharp.Editor.Tests
 
-open NUnit.Framework
+open Xunit
 open Microsoft.VisualStudio.FSharp.Editor
 open FSharp.Compiler.EditorServices
 open FSharp.Compiler.Text
 open Microsoft.CodeAnalysis.Text
 open Microsoft.CodeAnalysis.Classification
 open FSharp.Editor.Tests.Helpers
+open FSharp.Test
 
-[<TestFixture>]
 type SemanticClassificationServiceTests() =
-    let filePath = "C:\\test.fs"
-
     let getRanges (source: string) : SemanticClassificationItem list =
         asyncMaybe {
-            let document, _ = RoslynTestHelpers.CreateSingleDocumentSolution(filePath, source)
+            let document = 
+                RoslynTestHelpers.CreateSolution(source)
+                |> RoslynTestHelpers.GetSingleDocument
 
             let! _, checkFileResults =
                 document.GetFSharpParseAndCheckResultsAsync("SemanticClassificationServiceTests")
@@ -39,13 +39,10 @@ type SemanticClassificationServiceTests() =
             Position.mkPos (Line.fromZ line.Line) (line.Character + marker.Length - 1)
 
         match ranges |> List.tryFind (fun item -> Range.rangeContainsPos item.Range markerPos) with
-        | None -> Assert.Fail("Cannot find colorization data for end of marker")
+        | None -> failwith "Cannot find colorization data for end of marker"
         | Some item ->
-            Assert.AreEqual(
-                classificationType,
-                FSharpClassificationTypes.getClassificationTypeName item.Type,
+            FSharpClassificationTypes.getClassificationTypeName item.Type |> Assert.shouldBeEqualWith classificationType
                 "Classification data doesn't match for end of marker"
-            )
 
     let verifyNoClassificationDataAtEndOfMarker (fileContents: string, marker: string, classificationType: string) =
         let text = SourceText.From(fileContents)
@@ -65,13 +62,14 @@ type SemanticClassificationServiceTests() =
 
         Assert.False(anyData, "Classification data was found when it wasn't expected.")
 
-    [<TestCase("(*1*)", ClassificationTypeNames.StructName)>]
-    [<TestCase("(*2*)", ClassificationTypeNames.ClassName)>]
-    [<TestCase("(*3*)", ClassificationTypeNames.StructName)>]
-    [<TestCase("(*4*)", ClassificationTypeNames.ClassName)>]
-    [<TestCase("(*5*)", ClassificationTypeNames.StructName)>]
-    [<TestCase("(*6*)", ClassificationTypeNames.StructName)>]
-    [<TestCase("(*7*)", ClassificationTypeNames.ClassName)>]
+    [<Theory>]
+    [<InlineData("(*1*)", ClassificationTypeNames.StructName)>]
+    [<InlineData("(*2*)", ClassificationTypeNames.ClassName)>]
+    [<InlineData("(*3*)", ClassificationTypeNames.StructName)>]
+    [<InlineData("(*4*)", ClassificationTypeNames.ClassName)>]
+    [<InlineData("(*5*)", ClassificationTypeNames.StructName)>]
+    [<InlineData("(*6*)", ClassificationTypeNames.StructName)>]
+    [<InlineData("(*7*)", ClassificationTypeNames.ClassName)>]
     member _.Measured_Types(marker: string, classificationType: string) =
         verifyClassificationAtEndOfMarker (
             """#light (*Light*)
@@ -95,18 +93,19 @@ type SemanticClassificationServiceTests() =
             classificationType
         )
 
-    [<TestCase("(*1*)", FSharpClassificationTypes.MutableVar)>]
-    [<TestCase("(*2*)", FSharpClassificationTypes.MutableVar)>]
-    [<TestCase("(*3*)", FSharpClassificationTypes.MutableVar)>]
-    [<TestCase("(*4*)", FSharpClassificationTypes.MutableVar)>]
-    [<TestCase("(*5*)", FSharpClassificationTypes.MutableVar)>]
-    [<TestCase("(*6*)", FSharpClassificationTypes.MutableVar)>]
-    [<TestCase("(*7*)", FSharpClassificationTypes.MutableVar)>]
-    [<TestCase("(*8*)", FSharpClassificationTypes.MutableVar)>]
-    [<TestCase("(*9*)", FSharpClassificationTypes.MutableVar)>]
-    [<TestCase("(*10*)", FSharpClassificationTypes.MutableVar)>]
-    [<TestCase("(*11*)", FSharpClassificationTypes.MutableVar)>]
-    [<TestCase("(*12*)", FSharpClassificationTypes.MutableVar)>]
+    [<Theory>]
+    [<InlineData("(*1*)", FSharpClassificationTypes.MutableVar)>]
+    [<InlineData("(*2*)", FSharpClassificationTypes.MutableVar)>]
+    [<InlineData("(*3*)", FSharpClassificationTypes.MutableVar)>]
+    [<InlineData("(*4*)", FSharpClassificationTypes.MutableVar)>]
+    [<InlineData("(*5*)", FSharpClassificationTypes.MutableVar)>]
+    [<InlineData("(*6*)", FSharpClassificationTypes.MutableVar)>]
+    [<InlineData("(*7*)", FSharpClassificationTypes.MutableVar)>]
+    [<InlineData("(*8*)", FSharpClassificationTypes.MutableVar)>]
+    [<InlineData("(*9*)", FSharpClassificationTypes.MutableVar)>]
+    [<InlineData("(*10*)", FSharpClassificationTypes.MutableVar)>]
+    [<InlineData("(*11*)", FSharpClassificationTypes.MutableVar)>]
+    [<InlineData("(*12*)", FSharpClassificationTypes.MutableVar)>]
     member _.MutableValues(marker: string, classificationType: string) =
         let sourceText =
             """
@@ -133,13 +132,14 @@ r.MutableField := 3
 
         verifyClassificationAtEndOfMarker (sourceText, marker, classificationType)
 
-    [<TestCase("(*1*)", FSharpClassificationTypes.DisposableType)>]
-    [<TestCase("(*2*)", FSharpClassificationTypes.DisposableTopLevelValue)>]
-    [<TestCase("(*3*)", FSharpClassificationTypes.DisposableType)>]
-    [<TestCase("(*4*)", FSharpClassificationTypes.DisposableTopLevelValue)>]
-    [<TestCase("(*5*)", FSharpClassificationTypes.DisposableLocalValue)>]
-    [<TestCase("(*6*)", FSharpClassificationTypes.DisposableType)>]
-    [<TestCase("(*7*)", FSharpClassificationTypes.DisposableLocalValue)>]
+    [<Theory>]
+    [<InlineData("(*1*)", FSharpClassificationTypes.DisposableType)>]
+    [<InlineData("(*2*)", FSharpClassificationTypes.DisposableTopLevelValue)>]
+    [<InlineData("(*3*)", FSharpClassificationTypes.DisposableType)>]
+    [<InlineData("(*4*)", FSharpClassificationTypes.DisposableTopLevelValue)>]
+    [<InlineData("(*5*)", FSharpClassificationTypes.DisposableLocalValue)>]
+    [<InlineData("(*6*)", FSharpClassificationTypes.DisposableType)>]
+    [<InlineData("(*7*)", FSharpClassificationTypes.DisposableLocalValue)>]
     member _.Disposables(marker: string, classificationType: string) =
         let sourceText =
             """
@@ -160,12 +160,13 @@ let f() =
 
         verifyClassificationAtEndOfMarker (sourceText, marker, classificationType)
 
-    [<TestCase("(*1*)", FSharpClassificationTypes.MutableVar)>]
-    [<TestCase("(*2*)", FSharpClassificationTypes.MutableVar)>]
-    [<TestCase("(*3*)", FSharpClassificationTypes.MutableVar)>]
-    [<TestCase("(*4*)", FSharpClassificationTypes.MutableVar)>]
-    [<TestCase("(*5*)", FSharpClassificationTypes.MutableVar)>]
-    [<TestCase("(*6*)", FSharpClassificationTypes.MutableVar)>]
+    [<Theory>]
+    [<InlineData("(*1*)", FSharpClassificationTypes.MutableVar)>]
+    [<InlineData("(*2*)", FSharpClassificationTypes.MutableVar)>]
+    [<InlineData("(*3*)", FSharpClassificationTypes.MutableVar)>]
+    [<InlineData("(*4*)", FSharpClassificationTypes.MutableVar)>]
+    [<InlineData("(*5*)", FSharpClassificationTypes.MutableVar)>]
+    [<InlineData("(*6*)", FSharpClassificationTypes.MutableVar)>]
     member _.NoInrefsExpected(marker: string, classificationType: string) =
         let sourceText =
             """
diff --git a/vsintegration/tests/FSharp.Editor.Tests/SignatureHelpProviderTests.fs b/vsintegration/tests/FSharp.Editor.Tests/SignatureHelpProviderTests.fs
index 855c3346321..abec8f8b142 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/SignatureHelpProviderTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/SignatureHelpProviderTests.fs
@@ -3,13 +3,14 @@
 namespace FSharp.Editor.Tests
 
 open System
-open System.IO
-open NUnit.Framework
+open Xunit
 open Microsoft.VisualStudio.FSharp.Editor
 open FSharp.Compiler.CodeAnalysis
 open FSharp.Compiler.Text
 open Microsoft.CodeAnalysis.Text
 open FSharp.Editor.Tests.Helpers
+open Microsoft.CodeAnalysis
+open Microsoft.IO
 
 module SignatureHelpProvider =
     let private DefaultDocumentationProvider =
@@ -22,32 +23,6 @@ module SignatureHelpProvider =
 
     let filePath = "C:\\test.fs"
 
-    let PathRelativeToTestAssembly p =
-        Path.Combine(Path.GetDirectoryName(Uri(System.Reflection.Assembly.GetExecutingAssembly().CodeBase).LocalPath), p)
-
-    let internal projectOptions =
-        {
-            ProjectFileName = "C:\\test.fsproj"
-            ProjectId = None
-            SourceFiles = [| filePath |]
-            ReferencedProjects = [||]
-            OtherOptions =
-                [|
-                    "-r:"
-                    + PathRelativeToTestAssembly(@"DummyProviderForLanguageServiceTesting.dll")
-                |]
-            IsIncompleteTypeCheckEnvironment = true
-            UseScriptResolutionRules = false
-            LoadTime = DateTime.MaxValue
-            OriginalLoadReferences = []
-            UnresolvedReferences = None
-            Stamp = None
-        }
-
-    let internal parsingOptions =
-        { FSharpParsingOptions.Default with
-            SourceFiles = [| filePath |]
-        }
 
     let GetSignatureHelp (project: FSharpProject) (fileName: string) (caretPosition: int) =
         async {
@@ -59,7 +34,8 @@ module SignatureHelpProvider =
             let caretLineColumn = caretLinePos.Character
 
             let document =
-                RoslynTestHelpers.CreateSingleDocumentSolution(fileName, sourceText, options = project.Options)
+                RoslynTestHelpers.CreateSolution(fileContents, options = project.Options)
+                |> RoslynTestHelpers.GetSingleDocument
 
             let parseResults, checkFileResults =
                 document.GetFSharpParseAndCheckResultsAsync("GetSignatureHelp")
@@ -125,7 +101,8 @@ module SignatureHelpProvider =
         let caretLineColumn = caretLinePos.Character
 
         let document =
-            RoslynTestHelpers.CreateSingleDocumentSolution(filePath, sourceText, options = projectOptions)
+            RoslynTestHelpers.CreateSolution(fileContents)
+            |> RoslynTestHelpers.GetSingleDocument
 
         let parseResults, checkFileResults =
             document.GetFSharpParseAndCheckResultsAsync("assertSignatureHelpForMethodCalls")
@@ -157,7 +134,7 @@ module SignatureHelpProvider =
                 | None -> None
                 | Some data -> Some(data.ApplicableSpan.ToString(), data.ArgumentIndex, data.ArgumentCount, data.ArgumentName)
 
-        Assert.AreEqual(expected, actual)
+        Assert.Equal(expected, actual)
 
     let assertSignatureHelpForFunctionApplication
         (fileContents: string)
@@ -168,8 +145,10 @@ module SignatureHelpProvider =
         =
         let caretPosition = fileContents.LastIndexOf(marker) + marker.Length
 
-        let document, sourceText =
-            RoslynTestHelpers.CreateSingleDocumentSolution(filePath, fileContents)
+        let sourceText = SourceText.From(fileContents)
+        let document =
+            RoslynTestHelpers.CreateSolution(fileContents)
+            |> RoslynTestHelpers.GetSingleDocument
 
         let parseResults, checkFileResults =
             document.GetFSharpParseAndCheckResultsAsync("assertSignatureHelpForFunctionApplication")
@@ -201,21 +180,20 @@ module SignatureHelpProvider =
         checker.ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients()
 
         match sigHelp with
-        | None -> Assert.Fail("Expected signature help")
+        | None -> failwith "Expected signature help"
         | Some sigHelp ->
-            Assert.AreEqual(expectedArgumentCount, sigHelp.ArgumentCount)
-            Assert.AreEqual(expectedArgumentIndex, sigHelp.ArgumentIndex)
-            Assert.AreEqual(1, sigHelp.SignatureHelpItems.Length)
-            Assert.IsTrue(expectedArgumentIndex < sigHelp.SignatureHelpItems[0].Parameters.Length)
-            Assert.AreEqual(expectedArgumentName, sigHelp.SignatureHelpItems[0].Parameters[expectedArgumentIndex].ParameterName)
+            Assert.Equal(expectedArgumentCount, sigHelp.ArgumentCount)
+            Assert.Equal(expectedArgumentIndex, sigHelp.ArgumentIndex)
+            Assert.Equal(1, sigHelp.SignatureHelpItems.Length)
+            Assert.True(expectedArgumentIndex < sigHelp.SignatureHelpItems[0].Parameters.Length)
+            Assert.Equal(expectedArgumentName, sigHelp.SignatureHelpItems[0].Parameters[expectedArgumentIndex].ParameterName)
 
 open SignatureHelpProvider
 
-[<TestFixture>]
 module ``Gives signature help in method calls`` =
 
-    [<Test>]
-    let ``dot`` () : unit =
+    [<Fact>]
+    let ``dot`` () =
         let fileContents =
             """
 //1
@@ -225,8 +203,8 @@ System.Console.WriteLine(format="Hello, {0}",arg0="World")
         let marker = "."
         assertSignatureHelpForMethodCalls fileContents marker None
 
-    [<Test>]
-    let ``System`` () : unit =
+    [<Fact>]
+    let ``System`` () =
         let fileContents =
             """
 //1
@@ -236,8 +214,8 @@ System.Console.WriteLine(format="Hello, {0}",arg0="World")
         let marker = "System"
         assertSignatureHelpForMethodCalls fileContents marker None
 
-    [<Test>]
-    let ``WriteLine`` () : unit =
+    [<Fact>]
+    let ``WriteLine`` () =
         let fileContents =
             """
 //1
@@ -247,8 +225,8 @@ System.Console.WriteLine(format="Hello, {0}",arg0="World")
         let marker = "WriteLine"
         assertSignatureHelpForMethodCalls fileContents marker None
 
-    [<Test>]
-    let ``open paren`` () : unit =
+    [<Fact>]
+    let ``open paren`` () =
         let fileContents =
             """
 //1
@@ -258,8 +236,8 @@ System.Console.WriteLine(format="Hello, {0}",arg0="World")
         let marker = "("
         assertSignatureHelpForMethodCalls fileContents marker (Some("[7..64)", 0, 2, Some "format"))
 
-    [<Test>]
-    let ``named arg`` () : unit =
+    [<Fact>]
+    let ``named arg`` () =
         let fileContents =
             """
 //1
@@ -269,8 +247,8 @@ System.Console.WriteLine(format="Hello, {0}",arg0="World")
         let marker = "format"
         assertSignatureHelpForMethodCalls fileContents marker (Some("[7..64)", 0, 2, Some "format"))
 
-    [<Test>]
-    let ``comma`` () : unit =
+    [<Fact>]
+    let ``comma`` () =
         let fileContents =
             """
 //1
@@ -280,8 +258,8 @@ System.Console.WriteLine(format="Hello, {0}",arg0="World")
         let marker = ","
         assertSignatureHelpForMethodCalls fileContents marker None
 
-    [<Test>]
-    let ``second comma`` () : unit =
+    [<Fact>]
+    let ``second comma`` () =
         let fileContents =
             """
 //1
@@ -290,8 +268,8 @@ System.Console.WriteLine(format="Hello, {0}",arg0="World")
 
         assertSignatureHelpForMethodCalls fileContents """",""" (Some("[7..64)", 1, 2, Some "arg0"))
 
-    [<Test>]
-    let ``second named arg`` () : unit =
+    [<Fact>]
+    let ``second named arg`` () =
         let fileContents =
             """
 //1
@@ -301,8 +279,8 @@ System.Console.WriteLine(format="Hello, {0}",arg0="World")
         let marker = "arg0"
         assertSignatureHelpForMethodCalls fileContents marker (Some("[7..64)", 1, 2, Some "arg0"))
 
-    [<Test>]
-    let ``second named arg equals`` () : unit =
+    [<Fact>]
+    let ``second named arg equals`` () =
         let fileContents =
             """
 //1
@@ -312,8 +290,8 @@ System.Console.WriteLine(format="Hello, {0}",arg0="World")
         let marker = "arg0="
         assertSignatureHelpForMethodCalls fileContents marker (Some("[7..64)", 1, 2, Some "arg0"))
 
-    [<Test>]
-    let ``World`` () : unit =
+    [<Fact>]
+    let ``World`` () =
         let fileContents =
             """
 //1
@@ -323,8 +301,8 @@ System.Console.WriteLine(format="Hello, {0}",arg0="World")
         let marker = "World"
         assertSignatureHelpForMethodCalls fileContents marker (Some("[7..64)", 1, 2, Some "arg0"))
 
-    [<Test>]
-    let ``end paren`` () : unit =
+    [<Fact>]
+    let ``end paren`` () =
         let fileContents =
             """
 //1
@@ -334,10 +312,9 @@ System.Console.WriteLine(format="Hello, {0}",arg0="World")
         let marker = ")"
         assertSignatureHelpForMethodCalls fileContents marker (Some("[7..64)", 0, 2, Some "format"))
 
-[<TestFixture>]
 module ``Signature help with list literals, parens, etc`` =
-    [<Test>]
-    let ``Open paren`` () : unit =
+    [<Fact>]
+    let ``Open paren`` () =
         let fileContents =
             """
 //2
@@ -348,8 +325,8 @@ Console.WriteLine([(1,2)])
         let marker = "WriteLine("
         assertSignatureHelpForMethodCalls fileContents marker (Some("[20..45)", 0, 0, None))
 
-    [<Test>]
-    let ``comma`` () : unit =
+    [<Fact>]
+    let ``comma`` () =
         let fileContents =
             """
 //2
@@ -360,8 +337,8 @@ Console.WriteLine([(1,2)])
         let marker = ","
         assertSignatureHelpForMethodCalls fileContents marker None
 
-    [<Test>]
-    let ``list and tuple bracket pair start`` () : unit =
+    [<Fact>]
+    let ``list and tuple bracket pair start`` () =
         let fileContents =
             """
 //2
@@ -372,10 +349,9 @@ Console.WriteLine([(1,2)])
         let marker = "[("
         assertSignatureHelpForMethodCalls fileContents marker (Some("[20..45)", 0, 1, None))
 
-[<TestFixture>]
 module ``Unfinished parentheses`` =
-    [<Test>]
-    let ``Unfinished parentheses`` () : unit =
+    [<Fact>]
+    let ``Unfinished parentheses`` () =
         let fileContents =
             """
 let _ = System.DateTime(
@@ -384,8 +360,8 @@ let _ = System.DateTime(
         let marker = "let _ = System.DateTime("
         assertSignatureHelpForMethodCalls fileContents marker (Some("[10..26)", 0, 0, None))
 
-    [<Test>]
-    let ``Unfinished parentheses with comma`` () : unit =
+    [<Fact>]
+    let ``Unfinished parentheses with comma`` () =
         let fileContents =
             """
 let _ = System.DateTime(1L,
@@ -394,11 +370,12 @@ let _ = System.DateTime(1L,
         let marker = "let _ = System.DateTime(1L,"
         assertSignatureHelpForMethodCalls fileContents marker (Some("[10..31)", 1, 2, None))
 
-    [<Test>]
 #if RELEASE
-    [<Ignore "Fails in some CI, reproduces locally in Release mode, needs investigation">]
+    [<Fact(Skip="Fails in some CI, reproduces locally in Release mode, needs investigation")>]
+#else
+    [<Fact>]
 #endif
-    let ``type provider static parameter tests`` () : unit =
+    let ``type provider static parameter tests`` () =
         // This is old code and I'm too lazy to move it all out. - Phillip Carter
         let manyTestCases =
             [
@@ -458,7 +435,6 @@ type foo5 = N1.T<Param1=1,ParamIgnored= >
             for (marker, expected) in testCases do
                 assertSignatureHelpForMethodCalls fileContents marker expected
 
-[<TestFixture>]
 module ``Function argument applications`` =
     let private DefaultDocumentationProvider =
         { new IDocumentationBuilder with
@@ -466,8 +442,8 @@ module ``Function argument applications`` =
             override doc.AppendDocumentation(_, _, _, _, _, _, _) = ()
         }
 
-    [<Test>]
-    let ``single argument function application`` () : unit =
+    [<Fact>]
+    let ``single argument function application`` () =
         let fileContents =
             """
 sqrt 
@@ -476,8 +452,8 @@ sqrt
         let marker = "sqrt "
         assertSignatureHelpForFunctionApplication fileContents marker 1 0 "value"
 
-    [<Test>]
-    let ``multi-argument function application`` () : unit =
+    [<Fact>]
+    let ``multi-argument function application`` () =
         let fileContents =
             """
 let add2 x y = x + y
@@ -487,8 +463,8 @@ add2 1
         let marker = "add2 1 "
         assertSignatureHelpForFunctionApplication fileContents marker 2 1 "y"
 
-    [<Test>]
-    let ``qualified function application`` () : unit =
+    [<Fact>]
+    let ``qualified function application`` () =
         let fileContents =
             """
 module M =
@@ -499,8 +475,8 @@ M.f
         let marker = "M.f "
         assertSignatureHelpForFunctionApplication fileContents marker 1 0 "x"
 
-    [<Test>]
-    let ``function application in single pipeline with no additional args`` () : unit =
+    [<Fact>]
+    let ``function application in single pipeline with no additional args`` () =
         let fileContents =
             """
 [1..10] |> id 
@@ -509,8 +485,10 @@ M.f
         let marker = "id "
         let caretPosition = fileContents.IndexOf(marker) + marker.Length
 
-        let document, sourceText =
-            RoslynTestHelpers.CreateSingleDocumentSolution(filePath, fileContents)
+        let sourceText = SourceText.From(fileContents)
+        let document =
+            RoslynTestHelpers.CreateSolution(fileContents)
+            |> RoslynTestHelpers.GetSingleDocument
 
         let parseResults, checkFileResults =
             document.GetFSharpParseAndCheckResultsAsync("function application in single pipeline with no additional args")
@@ -543,8 +521,8 @@ M.f
 
         Assert.True(sigHelp.IsNone, "No signature help is expected because there are no additional args to apply.")
 
-    [<Test>]
-    let ``function application in single pipeline with an additional argument`` () : unit =
+    [<Fact>]
+    let ``function application in single pipeline with an additional argument`` () =
         let fileContents =
             """
 [1..10] |> List.map  
@@ -553,8 +531,8 @@ M.f
         let marker = "List.map "
         assertSignatureHelpForFunctionApplication fileContents marker 1 0 "mapping"
 
-    [<Test>]
-    let ``function application in middle of pipeline with an additional argument`` () : unit =
+    [<Fact>]
+    let ``function application in middle of pipeline with an additional argument`` () =
         let fileContents =
             """
 [1..10]
@@ -565,8 +543,8 @@ M.f
         let marker = "List.map "
         assertSignatureHelpForFunctionApplication fileContents marker 1 0 "mapping"
 
-    [<Test>]
-    let ``function application with function as parameter`` () : unit =
+    [<Fact>]
+    let ``function application with function as parameter`` () =
         let fileContents =
             """
 let derp (f: int -> int -> int) x = f x 1
@@ -576,8 +554,8 @@ derp
         let marker = "derp "
         assertSignatureHelpForFunctionApplication fileContents marker 2 0 "f"
 
-    [<Test>]
-    let ``function application with function as second parameter 1`` () : unit =
+    [<Fact>]
+    let ``function application with function as second parameter 1`` () =
         let fileContents =
             """
 let derp (f: int -> int -> int) x = f x 1
@@ -588,8 +566,8 @@ derp add
         let marker = "derp add "
         assertSignatureHelpForFunctionApplication fileContents marker 2 1 "x"
 
-    [<Test>]
-    let ``function application with function as second parameter 2`` () : unit =
+    [<Fact>]
+    let ``function application with function as second parameter 2`` () =
         let fileContents =
             """
 let f (derp: int -> int) x = derp x
@@ -598,8 +576,8 @@ let f (derp: int -> int) x = derp x
         let marker = "derp "
         assertSignatureHelpForFunctionApplication fileContents marker 1 0 "arg0"
 
-    [<Test>]
-    let ``function application with curried function as parameter`` () : unit =
+    [<Fact>]
+    let ``function application with curried function as parameter`` () =
         let fileContents =
             """
 let f (derp: int -> int -> int) x = derp x 
@@ -609,8 +587,8 @@ let f (derp: int -> int -> int) x = derp x
         assertSignatureHelpForFunctionApplication fileContents marker 2 1 "arg1"
 
     // migrated from legacy test
-    [<Test>]
-    let ``Multi.ReferenceToProjectLibrary`` () : unit =
+    [<Fact(Skip = "Needs reimplementation via proper Roslyn API")>]
+    let ``Multi.ReferenceToProjectLibrary`` () =
         let completionNames =
             GetCompletionTypeNamesFromXmlString
                 @"
@@ -639,6 +617,6 @@ let f (derp: int -> int -> int) x = derp x
 
     </Projects>
     "
-
+        
         let expected = [| [| "System.Int32"; "System.Int32" |] |]
-        Assert.AreEqual(expected, completionNames)
+        Assert.Equal<string array array>(expected, completionNames)
diff --git a/vsintegration/tests/FSharp.Editor.Tests/SyntacticColorizationServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/SyntacticColorizationServiceTests.fs
index a6971835e5f..7d988259d33 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/SyntacticColorizationServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/SyntacticColorizationServiceTests.fs
@@ -3,13 +3,13 @@
 namespace FSharp.Editor.Tests
 
 open System.Threading
-open NUnit.Framework
+open Xunit
 open Microsoft.CodeAnalysis.Classification
 open Microsoft.CodeAnalysis
 open Microsoft.CodeAnalysis.Text
 open Microsoft.VisualStudio.FSharp.Editor
+open FSharp.Test
 
-[<TestFixture>]
 type SyntacticClassificationServiceTests() =
 
     member private this.ExtractMarkerData(fileContents: string, marker: string, defines: string list, isScriptFile: Option<bool>) =
@@ -34,7 +34,7 @@ type SyntacticClassificationServiceTests() =
             )
 
         let markerPosition = fileContents.IndexOf(marker)
-        Assert.IsTrue(markerPosition >= 0, "Cannot find marker '{0}' in file contents", marker)
+        Assert.True(markerPosition >= 0, $"Cannot find marker '{marker}' in file contents")
         (tokens, markerPosition)
 
     member private this.VerifyColorizerAtStartOfMarker
@@ -49,9 +49,10 @@ type SyntacticClassificationServiceTests() =
             this.ExtractMarkerData(fileContents, marker, defines, isScriptFile)
 
         match tokens |> Seq.tryFind (fun token -> token.TextSpan.Contains(markerPosition)) with
-        | None -> Assert.Fail("Cannot find colorization data for start of marker")
-        | Some (classifiedSpan) ->
-            Assert.AreEqual(classificationType, classifiedSpan.ClassificationType, "Classification data doesn't match for start of marker")
+        | None -> failwith "Cannot find colorization data for start of marker"
+        | Some classifiedSpan ->
+            classifiedSpan.ClassificationType |> Assert.shouldBeEqualWith classificationType
+                "Classification data doesn't match for start of marker"
 
     member private this.VerifyColorizerAtEndOfMarker
         (
@@ -68,11 +69,12 @@ type SyntacticClassificationServiceTests() =
             tokens
             |> Seq.tryFind (fun token -> token.TextSpan.Contains(markerPosition + marker.Length - 1))
         with
-        | None -> Assert.Fail("Cannot find colorization data for end of marker")
-        | Some (classifiedSpan) ->
-            Assert.AreEqual(classificationType, classifiedSpan.ClassificationType, "Classification data doesn't match for end of marker")
+        | None -> failwith "Cannot find colorization data for end of marker"
+        | Some classifiedSpan ->
+            classifiedSpan.ClassificationType |> Assert.shouldBeEqualWith classificationType
+                "Classification data doesn't match for end of marker"
 
-    [<Test>]
+    [<Fact>]
     member this.Comment_SingleLine() =
         this.VerifyColorizerAtEndOfMarker(
             fileContents =
@@ -83,7 +85,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Comment
         )
 
-    [<Test>]
+    [<Fact>]
     member this.Conment_SingleLine_MultiConments() =
         this.VerifyColorizerAtEndOfMarker(
             fileContents =
@@ -94,7 +96,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Comment
         )
 
-    [<Test>]
+    [<Fact>]
     member this.Comment_MultiLine_AfterAnExpression() =
         this.VerifyColorizerAtEndOfMarker(
             fileContents =
@@ -107,7 +109,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Comment
         )
 
-    [<Test>]
+    [<Fact>]
     member this.Comment_MultiLine_WithLineBreakAndATab() =
         this.VerifyColorizerAtEndOfMarker(
             fileContents =
@@ -121,7 +123,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Comment
         )
 
-    [<Test>]
+    [<Fact>]
     member this.Comment_MultiLine_WithLineBreakAfterQuotExp() =
         this.VerifyColorizerAtEndOfMarker(
             fileContents =
@@ -135,7 +137,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Comment
         )
 
-    [<Test>]
+    [<Fact>]
     member this.Comment_MultiLine_AfterANumber() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -149,7 +151,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.NumericLiteral
         )
 
-    [<Test>]
+    [<Fact>]
     member this.Comment_Nested_Nested01() =
         this.VerifyColorizerAtEndOfMarker(
             fileContents =
@@ -170,7 +172,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Comment
         )
 
-    [<Test>]
+    [<Fact>]
     member this.Comment_Nested_Nested02() =
         this.VerifyColorizerAtEndOfMarker(
             fileContents =
@@ -191,7 +193,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Comment
         )
 
-    [<Test>]
+    [<Fact>]
     member this.Comment_Nested_Nested03() =
         this.VerifyColorizerAtEndOfMarker(
             fileContents =
@@ -212,7 +214,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Comment
         )
 
-    [<Test>]
+    [<Fact>]
     member this.Comment_Nested_IdentAfterNestedComments() =
         this.VerifyColorizerAtEndOfMarker(
             fileContents =
@@ -233,7 +235,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Identifier
         )
 
-    [<Test>]
+    [<Fact>]
     member this.Comment_CommentInString() =
         this.VerifyColorizerAtEndOfMarker(
             fileContents =
@@ -245,7 +247,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.StringLiteral
         )
 
-    [<Test>]
+    [<Fact>]
     member this.Comment_StringInComment() =
         this.VerifyColorizerAtEndOfMarker(
             fileContents =
@@ -258,7 +260,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Comment
         )
 
-    [<Test>]
+    [<Fact>]
     member this.Comment_Unterminated_KeywordBeforeComment() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -273,7 +275,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Keyword
         )
 
-    [<Test>]
+    [<Fact>]
     member this.Comment_Unterminated_KeywordInComment() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -295,7 +297,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Comment
         )
 
-    [<Test>]
+    [<Fact>]
     member this.Comment_Unterminated_NestedComments() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -319,7 +321,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Comment
         )
 
-    [<Test>]
+    [<Fact>]
     member this.String_AtEnd() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -330,7 +332,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.StringLiteral
         )
 
-    [<Test>]
+    [<Fact>]
     member this.String_MultiLines() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -342,7 +344,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.StringLiteral
         )
 
-    [<Test>]
+    [<Fact>]
     member this.String_MultiLines_LineBreak() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -354,7 +356,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.StringLiteral
         )
 
-    [<Test>]
+    [<Fact>]
     member this.String_Literal() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -365,7 +367,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.StringLiteral
         )
 
-    [<Test>]
+    [<Fact>]
     member this.ByteString_AtEnd() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -376,7 +378,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.StringLiteral
         )
 
-    [<Test>]
+    [<Fact>]
     member this.ByteString_MultiLines() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -388,7 +390,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.StringLiteral
         )
 
-    [<Test>]
+    [<Fact>]
     member this.ByteString_Literal() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -399,7 +401,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.StringLiteral
         )
 
-    [<Test>]
+    [<Fact>]
     member this.EscapedIdentifier_word() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents = """let ``this is an escaped identifier 123ASDF@#$"`` = 4""",
@@ -408,7 +410,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Identifier
         )
 
-    [<Test>]
+    [<Fact>]
     member this.EscapedIdentifier_SpecialChar() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents = """let ``this is an escaped identifier 123ASDF@#$"`` = 4""",
@@ -417,7 +419,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Identifier
         )
 
-    [<Test>]
+    [<Fact>]
     member this.EscapedIdentifier_EscapeChar() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents = """let ``this is an escaped identifier 123ASDF@#$"`` = 4""",
@@ -427,7 +429,7 @@ type SyntacticClassificationServiceTests() =
         )
 
     /// Regression for 3609 - Colorizer: __SOURCE__ and others colorized as a string
-    [<Test>]
+    [<Fact>]
     member this.PredefinedIdentifier_SOURCE_DIRECTORY() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -438,7 +440,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Keyword
         )
 
-    [<Test>]
+    [<Fact>]
     member this.PredefinedIdentifier_SOURCE_FILE() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -449,7 +451,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Keyword
         )
 
-    [<Test>]
+    [<Fact>]
     member this.PredefinedIdentifier_LINE() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -461,7 +463,7 @@ type SyntacticClassificationServiceTests() =
         )
 
     // Regression Test for FSB 3566, F# colorizer does not respect numbers
-    [<Test>]
+    [<Fact>]
     member this.Number_InAnExpression() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents = """let f x = x + 9""",
@@ -471,7 +473,7 @@ type SyntacticClassificationServiceTests() =
         )
 
     // Regression Test for FSB 1778 - Colorization seems to be confused after parsing a comment that contains a verbatim string that contains a \
-    [<Test>]
+    [<Fact>]
     member this.Number_AfterCommentWithBackSlash() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents = """let f (* @"\\" *)x = x + 19(*Marker1*)""",
@@ -481,7 +483,7 @@ type SyntacticClassificationServiceTests() =
         )
 
     // Regression Test for FSharp1.0:2539 -- lexing @"" strings inside (* *) comments?
-    [<Test>]
+    [<Fact>]
     member this.Keyword_AfterCommentWithLexingStrings() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -498,7 +500,7 @@ type SyntacticClassificationServiceTests() =
         )
 
     // Regression Test for FSB 1380 - Language Service colorizes anything followed by a bang as a keyword
-    [<Test>]
+    [<Fact>]
     member this.Keyword_LetBang() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -514,7 +516,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Keyword
         )
 
-    [<Test>]
+    [<Fact>]
     member this.Keyword_Yield() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -530,7 +532,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Keyword
         )
 
-    [<Test>]
+    [<Fact>]
     member this.Keyword_Do() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -546,7 +548,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Keyword
         )
 
-    [<Test>]
+    [<Fact>]
     member this.Keyword_Invalid_Bang() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -560,7 +562,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Identifier
         )
 
-    [<Test>]
+    [<Fact>]
     //This test case Verify that the color of const is the keyword color
     member this.TypeProvider_StaticParameters_Keyword_const() =
         this.VerifyColorizerAtStartOfMarker(
@@ -573,7 +575,7 @@ type SyntacticClassificationServiceTests() =
         )
 
     // Regression test for FSB 3696 - Colorization doesn't treat #if/else/endif correctly when embedded in a string literal
-    [<Test>]
+    [<Fact>]
     member this.PreProcessor_InStringLiteral01() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -590,7 +592,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.ExcludedCode
         )
 
-    [<Test>]
+    [<Fact>]
     member this.PreProcessor_InStringLiteral02() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -607,7 +609,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.ExcludedCode
         )
 
-    [<Test>]
+    [<Fact>]
     member this.PreProcessor_ElseKeyword() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -624,7 +626,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.PreprocessorKeyword
         )
 
-    [<Test>]
+    [<Fact>]
     member this.PreProcessor_InStringLiteral03() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -641,7 +643,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.StringLiteral
         )
 
-    [<Test>]
+    [<Fact>]
     member this.PreProcessor_InStringLiteral04() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -659,7 +661,7 @@ type SyntacticClassificationServiceTests() =
         )
 
     // Regression test for FSHARP1.0:4279
-    [<Test>]
+    [<Fact>]
     member this.Keyword_OCaml_asr() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -673,7 +675,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Keyword
         )
 
-    [<Test>]
+    [<Fact>]
     member this.Keyword_OCaml_land() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -687,7 +689,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Keyword
         )
 
-    [<Test>]
+    [<Fact>]
     member this.Keyword_OCaml_lor() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -701,7 +703,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Keyword
         )
 
-    [<Test>]
+    [<Fact>]
     member this.Keyword_OCaml_lsl() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -715,7 +717,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Keyword
         )
 
-    [<Test>]
+    [<Fact>]
     member this.Keyword_OCaml_lsr() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -729,7 +731,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Keyword
         )
 
-    [<Test>]
+    [<Fact>]
     member this.Keyword_OCaml_lxor() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -743,7 +745,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Keyword
         )
 
-    [<Test>]
+    [<Fact>]
     member this.Keyword_OCaml_mod() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -757,7 +759,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Keyword
         )
 
-    [<Test>]
+    [<Fact>]
     member this.Keyword_OCaml_sig() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -771,20 +773,21 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Keyword
         )
 
-    [<TestCase("Active Code1*)le", ClassificationTypeNames.Keyword)>]
-    [<TestCase("Active Code2*)le", ClassificationTypeNames.Keyword)>]
-    [<TestCase("Active Code3*)le", ClassificationTypeNames.Keyword)>]
-    [<TestCase("Active Code4*)le", ClassificationTypeNames.Keyword)>]
-    [<TestCase("Active Code5*)le", ClassificationTypeNames.Keyword)>]
-    [<TestCase("Active Code6*)le", ClassificationTypeNames.Keyword)>]
-    [<TestCase("Active Code7*)le", ClassificationTypeNames.Keyword)>]
-    [<TestCase("Inactive Code1*)le", ClassificationTypeNames.ExcludedCode)>]
-    [<TestCase("Inactive Code2*)le", ClassificationTypeNames.ExcludedCode)>]
-    [<TestCase("Inactive Code3*)le", ClassificationTypeNames.ExcludedCode)>]
-    [<TestCase("Inactive Code4*)le", ClassificationTypeNames.ExcludedCode)>]
-    [<TestCase("Inactive Code5*)le", ClassificationTypeNames.ExcludedCode)>]
-    [<TestCase("Inactive Code6*)le", ClassificationTypeNames.ExcludedCode)>]
-    [<TestCase("Inactive Code7*)le", ClassificationTypeNames.ExcludedCode)>]
+    [<Theory>]
+    [<InlineData("Active Code1*)le", ClassificationTypeNames.Keyword)>]
+    [<InlineData("Active Code2*)le", ClassificationTypeNames.Keyword)>]
+    [<InlineData("Active Code3*)le", ClassificationTypeNames.Keyword)>]
+    [<InlineData("Active Code4*)le", ClassificationTypeNames.Keyword)>]
+    [<InlineData("Active Code5*)le", ClassificationTypeNames.Keyword)>]
+    [<InlineData("Active Code6*)le", ClassificationTypeNames.Keyword)>]
+    [<InlineData("Active Code7*)le", ClassificationTypeNames.Keyword)>]
+    [<InlineData("Inactive Code1*)le", ClassificationTypeNames.ExcludedCode)>]
+    [<InlineData("Inactive Code2*)le", ClassificationTypeNames.ExcludedCode)>]
+    [<InlineData("Inactive Code3*)le", ClassificationTypeNames.ExcludedCode)>]
+    [<InlineData("Inactive Code4*)le", ClassificationTypeNames.ExcludedCode)>]
+    [<InlineData("Inactive Code5*)le", ClassificationTypeNames.ExcludedCode)>]
+    [<InlineData("Inactive Code6*)le", ClassificationTypeNames.ExcludedCode)>]
+    [<InlineData("Inactive Code7*)le", ClassificationTypeNames.ExcludedCode)>]
     member this.InactiveCode(marker: string, classificationType: string) =
         let fileContents =
             """
@@ -829,7 +832,7 @@ type SyntacticClassificationServiceTests() =
 
         this.VerifyColorizerAtEndOfMarker(fileContents, marker, [ "DEFINED" ], classificationType)
 
-    [<Test>]
+    [<Fact>]
     member public this.Colorizer_AtString() =
         this.VerifyColorizerAtEndOfMarker(
             "let s = @\"Bob\"",
@@ -838,9 +841,10 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.StringLiteral
         )
 
-    [<TestCase("__(*Test1*)", ClassificationTypeNames.Keyword)>]
-    [<TestCase("__(*Test2*)", ClassificationTypeNames.Keyword)>]
-    [<TestCase("__(*Test3*)", ClassificationTypeNames.Keyword)>]
+    [<Theory>]
+    [<InlineData("__(*Test1*)", ClassificationTypeNames.Keyword)>]
+    [<InlineData("__(*Test2*)", ClassificationTypeNames.Keyword)>]
+    [<InlineData("__(*Test3*)", ClassificationTypeNames.Keyword)>]
     member public this.Regression_Bug4860(marker: string, classificationType: string) =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -853,30 +857,31 @@ type SyntacticClassificationServiceTests() =
             classificationType = classificationType
         )
 
-    [<TestCase("let n = 1", ClassificationTypeNames.NumericLiteral)>]
-    [<TestCase("let l = [1", ClassificationTypeNames.NumericLiteral)>]
-    [<TestCase("let l = [12..1", ClassificationTypeNames.NumericLiteral)>]
-    [<TestCase("let l2 = [1", ClassificationTypeNames.NumericLiteral)>]
-    [<TestCase("let l2 = [12 .. 1", ClassificationTypeNames.NumericLiteral)>]
-    [<TestCase("let l3 = [ 1", ClassificationTypeNames.NumericLiteral)>]
-    [<TestCase("let l3 = [ 12 .. 1", ClassificationTypeNames.NumericLiteral)>]
-    [<TestCase("0x4", ClassificationTypeNames.NumericLiteral)>]
-    [<TestCase("0b0100", ClassificationTypeNames.NumericLiteral)>]
-    [<TestCase("4L", ClassificationTypeNames.NumericLiteral)>]
-    [<TestCase("4UL", ClassificationTypeNames.NumericLiteral)>]
-    [<TestCase("4u", ClassificationTypeNames.NumericLiteral)>]
-    [<TestCase("4s", ClassificationTypeNames.NumericLiteral)>]
-    [<TestCase("4us", ClassificationTypeNames.NumericLiteral)>]
-    [<TestCase("4y", ClassificationTypeNames.NumericLiteral)>]
-    [<TestCase("4uy", ClassificationTypeNames.NumericLiteral)>]
-    [<TestCase("4.0", ClassificationTypeNames.NumericLiteral)>]
-    [<TestCase("4.0f", ClassificationTypeNames.NumericLiteral)>]
-    [<TestCase("4N", ClassificationTypeNames.NumericLiteral)>]
-    [<TestCase("4I", ClassificationTypeNames.NumericLiteral)>]
-    [<TestCase("1M", ClassificationTypeNames.NumericLiteral)>]
-    [<TestCase("123", ClassificationTypeNames.NumericLiteral)>]
-    [<TestCase("// comment1: 12", ClassificationTypeNames.Comment)>]
-    [<TestCase("(* comment2: 12", ClassificationTypeNames.Comment)>]
+    [<Theory>]
+    [<InlineData("let n = 1", ClassificationTypeNames.NumericLiteral)>]
+    [<InlineData("let l = [1", ClassificationTypeNames.NumericLiteral)>]
+    [<InlineData("let l = [12..1", ClassificationTypeNames.NumericLiteral)>]
+    [<InlineData("let l2 = [1", ClassificationTypeNames.NumericLiteral)>]
+    [<InlineData("let l2 = [12 .. 1", ClassificationTypeNames.NumericLiteral)>]
+    [<InlineData("let l3 = [ 1", ClassificationTypeNames.NumericLiteral)>]
+    [<InlineData("let l3 = [ 12 .. 1", ClassificationTypeNames.NumericLiteral)>]
+    [<InlineData("0x4", ClassificationTypeNames.NumericLiteral)>]
+    [<InlineData("0b0100", ClassificationTypeNames.NumericLiteral)>]
+    [<InlineData("4L", ClassificationTypeNames.NumericLiteral)>]
+    [<InlineData("4UL", ClassificationTypeNames.NumericLiteral)>]
+    [<InlineData("4u", ClassificationTypeNames.NumericLiteral)>]
+    [<InlineData("4s", ClassificationTypeNames.NumericLiteral)>]
+    [<InlineData("4us", ClassificationTypeNames.NumericLiteral)>]
+    [<InlineData("4y", ClassificationTypeNames.NumericLiteral)>]
+    [<InlineData("4uy", ClassificationTypeNames.NumericLiteral)>]
+    [<InlineData("4.0", ClassificationTypeNames.NumericLiteral)>]
+    [<InlineData("4.0f", ClassificationTypeNames.NumericLiteral)>]
+    [<InlineData("4N", ClassificationTypeNames.NumericLiteral)>]
+    [<InlineData("4I", ClassificationTypeNames.NumericLiteral)>]
+    [<InlineData("1M", ClassificationTypeNames.NumericLiteral)>]
+    [<InlineData("123", ClassificationTypeNames.NumericLiteral)>]
+    [<InlineData("// comment1: 12", ClassificationTypeNames.Comment)>]
+    [<InlineData("(* comment2: 12", ClassificationTypeNames.Comment)>]
     member public this.Number_Regression_Bug3566(marker: string, classificationType: string) =
         this.VerifyColorizerAtEndOfMarker(
             fileContents =
@@ -893,7 +898,8 @@ type SyntacticClassificationServiceTests() =
         )
 
     /// FEATURE: Hash commands in .fsx files are colorized in PreprocessorKeyword color
-    [<TestCase("I <--hash I", ClassificationTypeNames.PreprocessorKeyword)>]
+    [<Theory>]
+    [<InlineData("I <--hash I", ClassificationTypeNames.PreprocessorKeyword)>]
     member public this.Preprocessor_InFsxFile_StartOfMarker(marker: string, classificationType: string) =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -908,9 +914,10 @@ type SyntacticClassificationServiceTests() =
         )
 
     /// FEATURE: Hash commands in .fsx files are colorized in PreprocessorKeyword color
-    [<TestCase("#ref", ClassificationTypeNames.PreprocessorKeyword)>]
-    [<TestCase("#loa", ClassificationTypeNames.PreprocessorKeyword)>]
-    [<TestCase("#ti", ClassificationTypeNames.PreprocessorKeyword)>]
+    [<Theory>]
+    [<InlineData("#ref", ClassificationTypeNames.PreprocessorKeyword)>]
+    [<InlineData("#loa", ClassificationTypeNames.PreprocessorKeyword)>]
+    [<InlineData("#ti", ClassificationTypeNames.PreprocessorKeyword)>]
     member public this.Preprocessor_InFsxFile_EndOfMarker(marker: string, classificationType: string) =
         this.VerifyColorizerAtEndOfMarker(
             fileContents =
@@ -925,7 +932,8 @@ type SyntacticClassificationServiceTests() =
         )
 
     /// FEATURE: Script-specific hash commands do not show up in blue in .fs files.
-    [<TestCase(" <--hash I", ClassificationTypeNames.Text)>]
+    [<Theory>]
+    [<InlineData(" <--hash I", ClassificationTypeNames.Text)>]
     member public this.Preprocessor_InFsFile_StartOfMarker(marker: string, classificationType: string) =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -939,9 +947,10 @@ type SyntacticClassificationServiceTests() =
         )
 
     /// FEATURE: Script-specific hash commands do not show up in blue in .fs files.
-    [<TestCase("#ref", ClassificationTypeNames.Text)>]
-    [<TestCase("#loa", ClassificationTypeNames.Text)>]
-    [<TestCase("#ti", ClassificationTypeNames.Text)>]
+    [<Theory>]
+    [<InlineData("#ref", ClassificationTypeNames.Text)>]
+    [<InlineData("#loa", ClassificationTypeNames.Text)>]
+    [<InlineData("#ti", ClassificationTypeNames.Text)>]
     member public this.Preprocessor_InFsFile_EndOfMarker(marker: string, classificationType: string) =
         this.VerifyColorizerAtEndOfMarker(
             fileContents =
@@ -955,9 +964,10 @@ type SyntacticClassificationServiceTests() =
         )
 
     /// FEATURE: Nested (* *) comments are allowed and will be colorized with CommentColor. Only the final *) causes the comment to close.
-    [<TestCase("(*Bob*)t", ClassificationTypeNames.Keyword)>]
-    [<TestCase("(*Alice*)t", ClassificationTypeNames.Comment)>]
-    [<TestCase("(*Charles*)t", ClassificationTypeNames.Keyword)>]
+    [<Theory>]
+    [<InlineData("(*Bob*)t", ClassificationTypeNames.Keyword)>]
+    [<InlineData("(*Alice*)t", ClassificationTypeNames.Comment)>]
+    [<InlineData("(*Charles*)t", ClassificationTypeNames.Keyword)>]
     member public this.Comment_AfterCommentBlock(marker: string, classificationType: string) =
         this.VerifyColorizerAtEndOfMarker(
             fileContents =
@@ -974,7 +984,7 @@ type SyntacticClassificationServiceTests() =
         )
 
     /// BUG: The comment used to be colored in black.
-    [<Test>]
+    [<Fact>]
     member public this.Regression_Bug1596() =
         this.VerifyColorizerAtEndOfMarker(
             fileContents = " let 2d (* Identifiers cannot start with numbers *)",
@@ -984,12 +994,13 @@ type SyntacticClassificationServiceTests() =
         )
 
     /// FEATURE: Code inside #if\#else\#endif blocks is colored with InactiveCodeColor depending on defines. This works for nested #if blocks as well.
-    [<TestCase("(*Bob*)t", ClassificationTypeNames.Keyword)>]
-    [<TestCase("(*Alice*)t", ClassificationTypeNames.ExcludedCode)>]
-    [<TestCase("(*Tom*)t", ClassificationTypeNames.ExcludedCode)>]
-    [<TestCase("(*Maurice*)t", ClassificationTypeNames.ExcludedCode)>]
-    [<TestCase("(*Larry*)t", ClassificationTypeNames.Keyword)>]
-    [<TestCase("(*Charles*)t", ClassificationTypeNames.Keyword)>]
+    [<Theory>]
+    [<InlineData("(*Bob*)t", ClassificationTypeNames.Keyword)>]
+    [<InlineData("(*Alice*)t", ClassificationTypeNames.ExcludedCode)>]
+    [<InlineData("(*Tom*)t", ClassificationTypeNames.ExcludedCode)>]
+    [<InlineData("(*Maurice*)t", ClassificationTypeNames.ExcludedCode)>]
+    [<InlineData("(*Larry*)t", ClassificationTypeNames.Keyword)>]
+    [<InlineData("(*Charles*)t", ClassificationTypeNames.Keyword)>]
     member public this.Preprocessor_AfterPreprocessorBlock(marker: string, classificationType: string) =
         this.VerifyColorizerAtEndOfMarker(
             fileContents =
@@ -1014,8 +1025,9 @@ type SyntacticClassificationServiceTests() =
         )
 
     // Wrong "#else" in "#if" should be ignored
-    [<TestCase("(*Alice*)t", ClassificationTypeNames.ExcludedCode)>]
-    [<TestCase("(*Larry*)t", ClassificationTypeNames.ExcludedCode)>]
+    [<Theory>]
+    [<InlineData("(*Alice*)t", ClassificationTypeNames.ExcludedCode)>]
+    [<InlineData("(*Larry*)t", ClassificationTypeNames.ExcludedCode)>]
     member public this.Preprocessor_InvalidElseDirectiveIgnored(marker: string, classificationType: string) =
         this.VerifyColorizerAtEndOfMarker(
             fileContents =
@@ -1030,12 +1042,13 @@ type SyntacticClassificationServiceTests() =
         )
 
     /// FEATURE: Code inside #if\#else\#endif blocks is colored with InactiveCodeColor depending on defines. This works for nested #if blocks as well.
-    [<TestCase("(*Bob*)t", ClassificationTypeNames.Keyword)>]
-    [<TestCase("(*Alice*)t", ClassificationTypeNames.ExcludedCode)>]
-    [<TestCase("(*Tom*)t", ClassificationTypeNames.ExcludedCode)>]
-    [<TestCase("(*Maurice*)t", ClassificationTypeNames.ExcludedCode)>]
-    [<TestCase("(*Larry*)t", ClassificationTypeNames.Keyword)>]
-    [<TestCase("(*Charles*)t", ClassificationTypeNames.Keyword)>]
+    [<Theory>]
+    [<InlineData("(*Bob*)t", ClassificationTypeNames.Keyword)>]
+    [<InlineData("(*Alice*)t", ClassificationTypeNames.ExcludedCode)>]
+    [<InlineData("(*Tom*)t", ClassificationTypeNames.ExcludedCode)>]
+    [<InlineData("(*Maurice*)t", ClassificationTypeNames.ExcludedCode)>]
+    [<InlineData("(*Larry*)t", ClassificationTypeNames.Keyword)>]
+    [<InlineData("(*Charles*)t", ClassificationTypeNames.Keyword)>]
     member public this.Preprocessor_AfterPreprocessorBlockWithDefines(marker: string, classificationType: string) =
         this.VerifyColorizerAtEndOfMarker(
             fileContents =
@@ -1061,16 +1074,17 @@ type SyntacticClassificationServiceTests() =
 
     /// FEATURE: Preprocessor keywords #light\#if\#else\#endif are colored with the PreprocessorKeyword color.
     /// FEATURE: All code in the inactive side of #if\#else\#endif is colored with with InactiveCode color.
-    [<TestCase("light (*Light*)", ClassificationTypeNames.PreprocessorKeyword)>]
-    [<TestCase("(*Inactive*)", ClassificationTypeNames.ExcludedCode)>]
-    [<TestCase("if UNDEFINED //(*If*)", ClassificationTypeNames.PreprocessorKeyword)>]
-    [<TestCase("FINED //(*If*)", ClassificationTypeNames.Identifier)>]
-    [<TestCase("(*If*)", ClassificationTypeNames.Comment)>]
-    [<TestCase("else //(*Else*)", ClassificationTypeNames.PreprocessorKeyword)>]
-    [<TestCase("t(*Active*)", ClassificationTypeNames.Keyword)>]
-    [<TestCase("endif //(*Endif*)", ClassificationTypeNames.PreprocessorKeyword)>]
-    [<TestCase("(*Else*)", ClassificationTypeNames.Comment)>]
-    [<TestCase("(*Endif*)", ClassificationTypeNames.Comment)>]
+    [<Theory>]
+    [<InlineData("light (*Light*)", ClassificationTypeNames.PreprocessorKeyword)>]
+    [<InlineData("(*Inactive*)", ClassificationTypeNames.ExcludedCode)>]
+    [<InlineData("if UNDEFINED //(*If*)", ClassificationTypeNames.PreprocessorKeyword)>]
+    [<InlineData("FINED //(*If*)", ClassificationTypeNames.Identifier)>]
+    [<InlineData("(*If*)", ClassificationTypeNames.Comment)>]
+    [<InlineData("else //(*Else*)", ClassificationTypeNames.PreprocessorKeyword)>]
+    [<InlineData("t(*Active*)", ClassificationTypeNames.Keyword)>]
+    [<InlineData("endif //(*Endif*)", ClassificationTypeNames.PreprocessorKeyword)>]
+    [<InlineData("(*Else*)", ClassificationTypeNames.Comment)>]
+    [<InlineData("(*Endif*)", ClassificationTypeNames.Comment)>]
     member public this.Preprocessor_Keywords(marker: string, classificationType: string) =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -1087,7 +1101,7 @@ type SyntacticClassificationServiceTests() =
 
     /// FEATURE: Preprocessor extended grammar basic check.
     /// FEATURE:  More extensive grammar test is done in compiler unit tests
-    [<Test>]
+    [<Fact>]
     member public this.Preprocesso_ExtendedIfGrammar_Basic01() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -1103,7 +1117,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.StringLiteral
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.Preprocessor_ExtendedIfGrammar_Basic02() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -1120,7 +1134,7 @@ type SyntacticClassificationServiceTests() =
         )
 
     /// #else / #endif in multiline strings is ignored
-    [<Test>]
+    [<Fact>]
     member public this.Preprocessor_DirectivesInString() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -1138,9 +1152,10 @@ type SyntacticClassificationServiceTests() =
         )
 
     /// Bug 2076 - String literals were causing the endif stack information to be discarded
-    [<TestCase("if UNDEFINED //(*If*)", ClassificationTypeNames.PreprocessorKeyword)>]
-    [<TestCase("else //(*Else*)", ClassificationTypeNames.PreprocessorKeyword)>]
-    [<TestCase("endif //(*Endif*)", ClassificationTypeNames.PreprocessorKeyword)>]
+    [<Theory>]
+    [<InlineData("if UNDEFINED //(*If*)", ClassificationTypeNames.PreprocessorKeyword)>]
+    [<InlineData("else //(*Else*)", ClassificationTypeNames.PreprocessorKeyword)>]
+    [<InlineData("endif //(*Endif*)", ClassificationTypeNames.PreprocessorKeyword)>]
     member public this.Preprocessor_KeywordsWithStrings(marker: string, classificationType: string) =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -1157,7 +1172,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = classificationType
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.Comment_VerbatimStringInComment_Bug1778() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -1168,7 +1183,7 @@ type SyntacticClassificationServiceTests() =
             classificationType = ClassificationTypeNames.Keyword
         )
 
-    [<Test>]
+    [<Fact>]
     member public this.Preprocessor_KeywordsWrongIf_Bug1577() =
         this.VerifyColorizerAtStartOfMarker(
             fileContents =
@@ -1180,7 +1195,7 @@ type SyntacticClassificationServiceTests() =
         )
 
     // This was an off-by-one bug in the replacement Colorizer
-    [<Test>]
+    [<Fact>]
     member public this.Keyword_LastCharacterOfKeyword() =
         this.VerifyColorizerAtEndOfMarker(
             fileContents = "(*Bob*)type Bob() = int",
diff --git a/vsintegration/tests/FSharp.Editor.Tests/xunit.runner.json b/vsintegration/tests/FSharp.Editor.Tests/xunit.runner.json
new file mode 100644
index 00000000000..2d07715ae5f
--- /dev/null
+++ b/vsintegration/tests/FSharp.Editor.Tests/xunit.runner.json
@@ -0,0 +1,7 @@
+{
+    "$schema": "https://xunit.net/schema/current/xunit.runner.schema.json",
+    "appDomain": "ifAvailable",
+    "shadowCopy": false,
+    "parallelizeTestCollections": false,
+    "maxParallelThreads": 1
+}
diff --git a/vsintegration/tests/UnitTests/DocCommentIdParserTests.fs b/vsintegration/tests/UnitTests/DocCommentIdParserTests.fs
new file mode 100644
index 00000000000..b9cc39f66dc
--- /dev/null
+++ b/vsintegration/tests/UnitTests/DocCommentIdParserTests.fs
@@ -0,0 +1,39 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+[<NUnit.Framework.TestFixture>]
+module Tests.ServiceAnalysis.DocCommentIdParser
+
+open NUnit.Framework
+open Microsoft.VisualStudio.FSharp.Editor
+
+
+
+
+[<Test>]
+let ``Test DocCommentId parser``() =
+    let testData = dict [
+        "T:N.X.Nested", DocCommentId.Type ["N"; "X"; "Nested"];
+        "M:N.X.#ctor", DocCommentId.Member ({ EntityPath = ["N"; "X"]; MemberOrValName = "``.ctor``"; GenericParameters = 0 }, SymbolMemberType.Constructor);
+        "M:N.X.#ctor(System.Int32)", DocCommentId.Member ({ EntityPath = ["N"; "X"]; MemberOrValName = "``.ctor``"; GenericParameters = 0 }, SymbolMemberType.Constructor);
+        "M:N.X.f", DocCommentId.Member ({ EntityPath = ["N"; "X"]; MemberOrValName = "f"; GenericParameters = 0 }, SymbolMemberType.Method);
+        "M:N.X.bb(System.String,System.Int32@)", DocCommentId.Member ({ EntityPath = ["N"; "X"]; MemberOrValName = "bb"; GenericParameters = 0 }, SymbolMemberType.Method);
+        "M:N.X.gg(System.Int16[],System.Int32[0:,0:])", DocCommentId.Member ({ EntityPath = ["N"; "X"]; MemberOrValName = "gg"; GenericParameters = 0 }, SymbolMemberType.Method);
+        "M:N.X.op_Addition(N.X,N.X)", DocCommentId.Member ({ EntityPath = ["N"; "X"]; MemberOrValName = "op_Addition"; GenericParameters = 0 }, SymbolMemberType.Method);
+        "M:N.X.op_Explicit(N.X)~System.Int32", DocCommentId.Member ({ EntityPath = ["N"; "X"]; MemberOrValName = "op_Explicit"; GenericParameters = 0 }, SymbolMemberType.Method);
+        "M:N.GenericMethod.WithNestedType``1(N.GenericType{``0}.NestedType)", DocCommentId.Member ({ EntityPath = ["N"; "GenericMethod"]; MemberOrValName = "WithNestedType"; GenericParameters = 1 }, SymbolMemberType.Method);
+        "M:N.GenericMethod.WithIntOfNestedType``1(N.GenericType{System.Int32}.NestedType)", DocCommentId.Member ({ EntityPath = ["N"; "GenericMethod"]; MemberOrValName = "WithIntOfNestedType"; GenericParameters = 1 }, SymbolMemberType.Method);
+        "E:N.X.d", DocCommentId.Member ({ EntityPath = ["N"; "X"]; MemberOrValName = "d"; GenericParameters = 0 }, SymbolMemberType.Event);
+        "F:N.X.q", DocCommentId.Field { EntityPath = ["N"; "X"]; MemberOrValName = "q"; GenericParameters = 0 };
+        "P:N.X.prop", DocCommentId.Member ({ EntityPath = ["N"; "X"]; MemberOrValName = "prop"; GenericParameters = 0 }, SymbolMemberType.Property);
+    ]
+
+    let mutable res = ""
+    for pair in testData do
+        let docId = pair.Key
+        let expected = pair.Value
+        let actual = FSharpCrossLanguageSymbolNavigationService.DocCommentIdToPath(docId)
+        if actual <> expected then
+            res <- res + $"DocumentId: {docId}; Expected = %A{expected} = Actual = %A{actual}\n"
+
+    if res <> "" then
+        failwith res
+    ()
\ No newline at end of file
diff --git a/vsintegration/tests/UnitTests/VisualFSharp.UnitTests.fsproj b/vsintegration/tests/UnitTests/VisualFSharp.UnitTests.fsproj
index 8bfcdc25ff1..1ee9d2b4a4a 100644
--- a/vsintegration/tests/UnitTests/VisualFSharp.UnitTests.fsproj
+++ b/vsintegration/tests/UnitTests/VisualFSharp.UnitTests.fsproj
@@ -57,6 +57,9 @@
     <Compile Include="LegacyProjectSystem\Tests.ProjectSystem.References.fs" />
     <Compile Include="LegacyProjectSystem\Tests.ProjectSystem.RoundTrip.fs" />
     <Compile Include="LegacyProjectSystem\Tests.ProjectSystem.UpToDate.fs" />
+	  <Compile Include="DocCommentIdParserTests.fs">
+		  <Link>CompilerService\DocCommentIdParserTests.fs</Link>
+	  </Compile>
     <Compile Include="UnusedOpensTests.fs">
       <Link>CompilerService\UnusedOpensTests.fs</Link>
     </Compile>

From 83ddb3dcbc82ca998e489a529ee751ebd626a712 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Thu, 26 Jan 2023 08:30:19 +0000
Subject: [PATCH 21/42] Fantomas

---
 src/Compiler/Driver/OptimizeInputs.fs | 397 +++++++++++++++-----------
 1 file changed, 236 insertions(+), 161 deletions(-)

diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index 9baa8b4a96e..4fad1a3b41e 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -54,28 +54,32 @@ let GetInitialOptimizationEnv (tcImports: TcImports, tcGlobals: TcGlobals) =
     optEnv
 
 type private OptimizeDuringCodeGen = bool -> Expr -> Expr
+
 type PhaseRes =
     {
-        OptEnvFirstLoop : Optimizer.IncrementalOptimizationEnv
-        OptInfo : Optimizer.ImplFileOptimizationInfo
-        OptEnvExtraLoop : Optimizer.IncrementalOptimizationEnv
-        OptEnvFinalSimplify : Optimizer.IncrementalOptimizationEnv
-        HidingInfo : SignatureHidingInfo
-        OptDuringCodeGen : OptimizeDuringCodeGen
+        OptEnvFirstLoop: Optimizer.IncrementalOptimizationEnv
+        OptInfo: Optimizer.ImplFileOptimizationInfo
+        OptEnvExtraLoop: Optimizer.IncrementalOptimizationEnv
+        OptEnvFinalSimplify: Optimizer.IncrementalOptimizationEnv
+        HidingInfo: SignatureHidingInfo
+        OptDuringCodeGen: OptimizeDuringCodeGen
     }
+
 type PhaseRess = CheckedImplFile * PhaseRes
 
 type PhaseIdx = int
-type F<'In,'Out> = 'In -> 'Out
+type F<'In, 'Out> = 'In -> 'Out
+
 type PhaseInputs =
     {
-        File : CheckedImplFile
-        FileIdx : int
+        File: CheckedImplFile
+        FileIdx: int
         // State returned by processing the previous phase for the current file.
-        PrevPhase : PhaseRes
+        PrevPhase: PhaseRes
         // State returned by processing the current phase for the previous file.
-        PrevFile : PhaseRes
+        PrevFile: PhaseRes
     }
+
 type PhaseFunc = PhaseInputs -> CheckedImplFile * PhaseRes
 
 /// <summary>
@@ -85,25 +89,22 @@ type PhaseFunc = PhaseInputs -> CheckedImplFile * PhaseRes
 /// </summary>
 type Phase =
     {
-        Idx : PhaseIdx
-        Name : string
+        Idx: PhaseIdx
+        Name: string
     }
+
     override this.ToString() = $"{this.Idx}-{this.Name}"
 
-type PhaseInfo =
-    {
-        Phase : Phase
-        Func : PhaseFunc
-    }
+type PhaseInfo = { Phase: Phase; Func: PhaseFunc }
 
 type PhaseInfos = PhaseInfo[]
 
 [<RequireQualifiedAccess>]
 module private ParallelOptimization =
     open Optimizer
-    
+
     /// Identifies a work item scheduled independently of others - consists of a (file) index and OptimizationPhase.
-    /// There are (NumberOfFiles * NumberOfPhases) nodes in the whole optimization process. 
+    /// There are (NumberOfFiles * NumberOfPhases) nodes in the whole optimization process.
     type private Node =
         {
             FileIdx: int
@@ -118,32 +119,29 @@ module private ParallelOptimization =
         : (CheckedImplFileAfterOptimization * ImplFileOptimizationInfo)[] * IncrementalOptimizationEnv =
         let finalFileResults =
             fileResults
-            |> Array.map
-                (fun (file, res) ->
-                    let implFile =
-                        {
-                            ImplFile = file
-                            OptimizeDuringCodeGen = res.OptDuringCodeGen
-                        }
+            |> Array.map (fun (file, res) ->
+                let implFile =
+                    {
+                        ImplFile = file
+                        OptimizeDuringCodeGen = res.OptDuringCodeGen
+                    }
 
-                    implFile, res.OptInfo)
+                implFile, res.OptInfo)
 
         let lastFileFirstLoopEnv =
-            fileResults
-            |> Array.last
-            |> fun (_file, res) -> res.OptEnvFirstLoop
+            fileResults |> Array.last |> (fun (_file, res) -> res.OptEnvFirstLoop)
 
         finalFileResults, lastFileFirstLoopEnv
 
     let private raiseNoResultsExn (node: Node) =
         raise (exn $"Unexpected lack of results for {node}")
-    
+
     let optimizeFilesInParallel2
         (env0: IncrementalOptimizationEnv)
-        (phases : PhaseInfos)
+        (phases: PhaseInfos)
         (files: CheckedImplFile list)
         : (CheckedImplFileAfterOptimization * ImplFileOptimizationInfo)[] * IncrementalOptimizationEnv =
-        
+
         /// Initial state for processing the current file.
         let initialState =
             {
@@ -155,41 +153,46 @@ module private ParallelOptimization =
                 // A no-op optimizer
                 OptDuringCodeGen = fun _ expr -> expr
             }
-        
+
         // Functions for accessing a set of node jobs and their results
         let getTask, setTask =
-            let tasks : Task<PhaseRess>[,] = Array2D.zeroCreate files.Length phases.Length
-            let getTask (node : Node) =
-                tasks[node.FileIdx, node.Phase]
-            let setTask (node : Node) (task : Task<PhaseRess>) =
-                tasks[node.FileIdx, node.Phase] <- task
+            let tasks: Task<PhaseRess>[,] = Array2D.zeroCreate files.Length phases.Length
+            let getTask (node: Node) = tasks[node.FileIdx, node.Phase]
+            let setTask (node: Node) (task: Task<PhaseRess>) = tasks[node.FileIdx, node.Phase] <- task
             getTask, setTask
-            
-        let getNodeInputs (node : Node) =
+
+        let getNodeInputs (node: Node) =
             task {
                 let prevPhaseTask =
                     if node.Phase > 0 then
-                        getTask {node with Phase = node.Phase-1}
+                        getTask { node with Phase = node.Phase - 1 }
                     else
                         // First phase uses input file without modifications
-                        (files[node.FileIdx], initialState)
-                        |> Task.FromResult
+                        (files[node.FileIdx], initialState) |> Task.FromResult
+
                 let prevFileTask =
                     if node.FileIdx > 0 then
-                        getTask {node with FileIdx = node.FileIdx-1}
+                        getTask { node with FileIdx = node.FileIdx - 1 }
                     else
-                        // We don't use the file result in this case, but we need something, so just take the first input file as a placeholder. 
-                        (files[0], initialState)
-                        |> Task.FromResult
-                
-                let! results = [|prevPhaseTask; prevFileTask|] |> Task.WhenAll
+                        // We don't use the file result in this case, but we need something, so just take the first input file as a placeholder.
+                        (files[0], initialState) |> Task.FromResult
+
+                let! results = [| prevPhaseTask; prevFileTask |] |> Task.WhenAll
                 let prevPhaseFile, prevPhaseRes = results[0]
                 let _prevFileFile, prevFileRes = results[1]
-                let inputs = {File = prevPhaseFile; FileIdx = node.FileIdx; PrevPhase = prevPhaseRes; PrevFile = prevFileRes}
+
+                let inputs =
+                    {
+                        File = prevPhaseFile
+                        FileIdx = node.FileIdx
+                        PrevPhase = prevPhaseRes
+                        PrevFile = prevFileRes
+                    }
+
                 return inputs
             }
-        
-        let startNodeTask (phase : PhaseInfo) (node : Node) =
+
+        let startNodeTask (phase: PhaseInfo) (node: Node) =
             // A workaround to make sure that the initial part of each task is scheduled asynchronously
             async {
                 let nodeTask =
@@ -198,69 +201,90 @@ module private ParallelOptimization =
                         let res = phase.Func inputs
                         return res
                     }
+
                 return! nodeTask |> Async.AwaitTask
-            } |> Async.StartAsTask
-        
-        let fileIndices = [|0..files.Length-1|]
-        
+            }
+            |> Async.StartAsTask
+
+        let fileIndices = [| 0 .. files.Length - 1 |]
+
         for fileIdx in fileIndices do
             for phase in phases do
-                let node = {Node.Phase = phase.Phase.Idx; FileIdx = fileIdx}
+                let node =
+                    {
+                        Node.Phase = phase.Phase.Idx
+                        FileIdx = fileIdx
+                    }
+
                 let task = startNodeTask phase node
                 setTask node task
-        
+
         let lastPhaseResultsTask =
-            let lastPhaseIndex = phases[phases.Length-1].Phase.Idx
+            let lastPhaseIndex = phases[phases.Length - 1].Phase.Idx
+
             fileIndices
-            |> Array.map (fun fileIdx -> getTask {Node.FileIdx = fileIdx; Phase = lastPhaseIndex})
+            |> Array.map (fun fileIdx ->
+                getTask
+                    {
+                        Node.FileIdx = fileIdx
+                        Phase = lastPhaseIndex
+                    })
             |> Task.WhenAll
-        
+
         let lastPhaseResults =
             try
                 lastPhaseResultsTask.GetAwaiter().GetResult()
             // If multiple exceptions returned by multiple tasks, ignore all but the first one.
             with :? System.AggregateException as ex when ex.InnerExceptions.Count > 0 ->
                 raise ex.InnerExceptions[0]
-            
+
         collectFinalResults lastPhaseResults
 
-let optimizeFilesSequentially optEnv (phases : PhaseInfos) implFiles =
+let optimizeFilesSequentially optEnv (phases: PhaseInfos) implFiles =
     let results, (optEnvFirstLoop, _, _, _) =
         let implFiles = implFiles |> List.mapi (fun i file -> i, file)
+
         ((optEnv, optEnv, optEnv, SignatureHidingInfo.Empty), implFiles)
 
-        ||> List.mapFold (fun (optEnvFirstLoop: Optimizer.IncrementalOptimizationEnv, optEnvExtraLoop, optEnvFinalSimplify, hidden) (fileIdx, implFile) ->
-            
-            /// Initial state for processing the current file.
-            let state =
-                implFile,
-                {
-                    OptEnvFirstLoop = optEnvFirstLoop
-                    OptInfo = lazy failwith "This dummy value wrapped in a Lazy was not expected to be evaluated before being replaced."
-                    OptEnvExtraLoop = optEnvExtraLoop
-                    OptEnvFinalSimplify = optEnvFinalSimplify
-                    HidingInfo = hidden
-                    // A no-op optimizer
-                    OptDuringCodeGen = fun _ expr -> expr
-                }
-            
-            let runPhase (file : CheckedImplFile, state : PhaseRes) (phase : PhaseInfo) =
-                // In the sequential mode we always process all phases of the previous file before processing the current file.
-                // This is why the state returned by the previous phase of the current file contains all changes made in the previous file,
-                // and we can use it in both places.
-                let input = {File = file; FileIdx = fileIdx; PrevPhase = state; PrevFile = state}
-                phase.Func input
-            
-            let implFile, state = Array.fold runPhase state phases
-
-            let file =
-                {
-                    ImplFile = implFile
-                    OptimizeDuringCodeGen = state.OptDuringCodeGen
-                }
-            
-            (file, state.OptInfo), (state.OptEnvFirstLoop, state.OptEnvExtraLoop, state.OptEnvFinalSimplify, state.HidingInfo)
-        )
+        ||> List.mapFold
+            (fun (optEnvFirstLoop: Optimizer.IncrementalOptimizationEnv, optEnvExtraLoop, optEnvFinalSimplify, hidden) (fileIdx, implFile) ->
+
+                /// Initial state for processing the current file.
+                let state =
+                    implFile,
+                    {
+                        OptEnvFirstLoop = optEnvFirstLoop
+                        OptInfo = lazy failwith "This dummy value wrapped in a Lazy was not expected to be evaluated before being replaced."
+                        OptEnvExtraLoop = optEnvExtraLoop
+                        OptEnvFinalSimplify = optEnvFinalSimplify
+                        HidingInfo = hidden
+                        // A no-op optimizer
+                        OptDuringCodeGen = fun _ expr -> expr
+                    }
+
+                let runPhase (file: CheckedImplFile, state: PhaseRes) (phase: PhaseInfo) =
+                    // In the sequential mode we always process all phases of the previous file before processing the current file.
+                    // This is why the state returned by the previous phase of the current file contains all changes made in the previous file,
+                    // and we can use it in both places.
+                    let input =
+                        {
+                            File = file
+                            FileIdx = fileIdx
+                            PrevPhase = state
+                            PrevFile = state
+                        }
+
+                    phase.Func input
+
+                let implFile, state = Array.fold runPhase state phases
+
+                let file =
+                    {
+                        ImplFile = implFile
+                        OptimizeDuringCodeGen = state.OptDuringCodeGen
+                    }
+
+                (file, state.OptInfo), (state.OptEnvFirstLoop, state.OptEnvExtraLoop, state.OptEnvFinalSimplify, state.HidingInfo))
 
     results, optEnvFirstLoop
 
@@ -307,74 +331,98 @@ let ApplyAllOptimizations
         }
 
     let measurements = ConcurrentDictionary<string, int64>()
+
     let measure (name: string) =
         let sw = Stopwatch.StartNew()
-        {
-            new System.IDisposable with
-                member this.Dispose() =
-                    lock measurements (fun () ->
-                        if measurements.ContainsKey name = false then measurements[name] <- 0L
-                        measurements[name] <- measurements[name] + sw.ElapsedMilliseconds
-                    )
+
+        { new System.IDisposable with
+            member this.Dispose() =
+                lock measurements (fun () ->
+                    if measurements.ContainsKey name = false then
+                        measurements[name] <- 0L
+
+                    measurements[name] <- measurements[name] + sw.ElapsedMilliseconds)
         }
-   
-    let wrapPhaseFunc (f : PhaseFunc) (info : Phase) =
-        fun (inputs : PhaseInputs) ->
+
+    let wrapPhaseFunc (f: PhaseFunc) (info: Phase) =
+        fun (inputs: PhaseInputs) ->
             use _ = measure info.Name
+
             use _ =
                 let tags =
                     [|
                         "QualifiedNameOfFile", inputs.File.QualifiedNameOfFile.Text
                         "OptimisationPhase", info.Name
                     |]
+
                 FSharp.Compiler.Diagnostics.Activity.start $"file-{inputs.FileIdx}_phase-{info.Name}" tags
+
             f inputs
-    
+
     let phases = List<PhaseInfo>()
-    
-    let addPhase (name : string) (phaseFunc : PhaseFunc) =
-        let phase =
-            {
-                Idx = phases.Count
-                Name = name
-            }
+
+    let addPhase (name: string) (phaseFunc: PhaseFunc) =
+        let phase = { Idx = phases.Count; Name = name }
+
         let phaseInfo =
             {
                 Phase = phase
                 Func = wrapPhaseFunc phaseFunc phase
             }
+
         phases.Add(phaseInfo)
-    
-    let firstLoop ({File = file; PrevPhase = prevPhase; PrevFile = prevFile} : PhaseInputs) : PhaseRess =
-        let (env, file, optInfo, hidingInfo), optDuringCodeGen = Optimizer.OptimizeImplFile(
-            phase1Settings,
-            ccu,
-            tcGlobals,
-            tcVal,
-            importMap,
-            prevFile.OptEnvFirstLoop,
-            isIncrementalFragment,
-            tcConfig.fsiMultiAssemblyEmit,
-            tcConfig.emitTailcalls,
-            prevFile.HidingInfo,
-            file
-        )
+
+    let firstLoop
+        ({
+             File = file
+             PrevPhase = prevPhase
+             PrevFile = prevFile
+         }: PhaseInputs)
+        : PhaseRess =
+        let (env, file, optInfo, hidingInfo), optDuringCodeGen =
+            Optimizer.OptimizeImplFile(
+                phase1Settings,
+                ccu,
+                tcGlobals,
+                tcVal,
+                importMap,
+                prevFile.OptEnvFirstLoop,
+                isIncrementalFragment,
+                tcConfig.fsiMultiAssemblyEmit,
+                tcConfig.emitTailcalls,
+                prevFile.HidingInfo,
+                file
+            )
+
         file,
-        {
-            prevPhase with
-                OptEnvFirstLoop = env
-                OptInfo = optInfo
-                HidingInfo = hidingInfo
-                OptDuringCodeGen = optDuringCodeGen
+        { prevPhase with
+            OptEnvFirstLoop = env
+            OptInfo = optInfo
+            HidingInfo = hidingInfo
+            OptDuringCodeGen = optDuringCodeGen
         }
+
     addPhase "firstLoop" firstLoop
-            
-    let lowerLocalMutables ({File = file; PrevPhase = prevPhase; PrevFile = _prevFile} : PhaseInputs) : PhaseRess =
+
+    let lowerLocalMutables
+        ({
+             File = file
+             PrevPhase = prevPhase
+             PrevFile = _prevFile
+         }: PhaseInputs)
+        : PhaseRess =
         let file = LowerLocalMutables.TransformImplFile tcGlobals importMap file
         file, prevPhase
+
     addPhase "lowerLocalMutables" lowerLocalMutables
-        
-    let extraLoop ({File = file; PrevPhase = prevPhase; PrevFile = prevFile} : PhaseInputs) : PhaseRess =
+
+    let extraLoop
+        ({
+             File = file
+             PrevPhase = prevPhase
+             PrevFile = prevFile
+         }: PhaseInputs)
+        : PhaseRess =
         let (optEnvExtraLoop, file, _, _), _ =
             Optimizer.OptimizeImplFile(
                 phase2And3Settings,
@@ -391,34 +439,61 @@ let ApplyAllOptimizations
             )
 
         file,
-        {
-            prevPhase with
-                OptEnvExtraLoop = optEnvExtraLoop
+        { prevPhase with
+            OptEnvExtraLoop = optEnvExtraLoop
         }
-    
+
     if tcConfig.extraOptimizationIterations > 0 then
         addPhase "ExtraLoop" extraLoop
-    
-    let detuple ({File = file; PrevPhase = prevPhase; PrevFile = _prevFile} : PhaseInputs) : PhaseRess =
+
+    let detuple
+        ({
+             File = file
+             PrevPhase = prevPhase
+             PrevFile = _prevFile
+         }: PhaseInputs)
+        : PhaseRess =
         let file = file |> Detuple.DetupleImplFile ccu tcGlobals
         file, prevPhase
+
     if tcConfig.doDetuple then
         addPhase "Detuple" detuple
-    
-    let innerLambdasToToplevelFuncs ({File = file; PrevPhase = prevPhase; PrevFile = _prevFile} : PhaseInputs) : PhaseRess =
+
+    let innerLambdasToToplevelFuncs
+        ({
+             File = file
+             PrevPhase = prevPhase
+             PrevFile = _prevFile
+         }: PhaseInputs)
+        : PhaseRess =
         let file =
             file
             |> InnerLambdasToTopLevelFuncs.MakeTopLevelRepresentationDecisions ccu tcGlobals
+
         file, prevPhase
+
     if tcConfig.doTLR then
         addPhase "InnerLambdasToToplevelFuncs" innerLambdasToToplevelFuncs
-    
-    let lowerCalls ({File = file; PrevPhase = prevPhase; PrevFile = _prevFile} : PhaseInputs) : PhaseRess =
+
+    let lowerCalls
+        ({
+             File = file
+             PrevPhase = prevPhase
+             PrevFile = _prevFile
+         }: PhaseInputs)
+        : PhaseRess =
         let file = LowerCalls.LowerImplFile tcGlobals file
         file, prevPhase
+
     addPhase "LowerCalls" lowerCalls
-    
-    let finalSimplify ({File = file; PrevPhase = prevPhase; PrevFile = prevFile} : PhaseInputs) : PhaseRess =
+
+    let finalSimplify
+        ({
+             File = file
+             PrevPhase = prevPhase
+             PrevFile = prevFile
+         }: PhaseInputs)
+        : PhaseRess =
         let (optEnvFinalSimplify, file, _, _), _ =
             Optimizer.OptimizeImplFile(
                 phase2And3Settings,
@@ -435,24 +510,24 @@ let ApplyAllOptimizations
             )
 
         file,
-        {
-            prevPhase with
-                OptEnvFinalSimplify = optEnvFinalSimplify
+        { prevPhase with
+            OptEnvFinalSimplify = optEnvFinalSimplify
         }
+
     if tcConfig.doFinalSimplify then
-        addPhase "FinalSimplify" finalSimplify    
-    
+        addPhase "FinalSimplify" finalSimplify
+
     let phases = phases.ToArray()
-    
+
     let results, optEnvFirstLoop =
         match tcConfig.optSettings.processingMode with
         | Optimizer.OptimizationProcessingMode.PartiallyParallel ->
             let results, optEnvFirstPhase =
                 ParallelOptimization.optimizeFilesInParallel2 optEnv phases implFiles
+
             results |> Array.toList, optEnvFirstPhase
-        | Optimizer.OptimizationProcessingMode.Sequential ->
-            optimizeFilesSequentially optEnv phases implFiles
-    
+        | Optimizer.OptimizationProcessingMode.Sequential -> optimizeFilesSequentially optEnv phases implFiles
+
     for kvp in measurements do
         printfn $"[{kvp.Key}] = {kvp.Value}"
 

From ef843e716773958d18c30388b58b7225887cbca9 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Thu, 26 Jan 2023 08:31:26 +0000
Subject: [PATCH 22/42] Rename

---
 src/Compiler/Driver/OptimizeInputs.fs | 32 +++++++++++++--------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index 4fad1a3b41e..cdfc14671ad 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -55,7 +55,7 @@ let GetInitialOptimizationEnv (tcImports: TcImports, tcGlobals: TcGlobals) =
 
 type private OptimizeDuringCodeGen = bool -> Expr -> Expr
 
-type PhaseRes =
+type PhaseContext =
     {
         OptEnvFirstLoop: Optimizer.IncrementalOptimizationEnv
         OptInfo: Optimizer.ImplFileOptimizationInfo
@@ -65,7 +65,7 @@ type PhaseRes =
         OptDuringCodeGen: OptimizeDuringCodeGen
     }
 
-type PhaseRess = CheckedImplFile * PhaseRes
+type PhaseRes = CheckedImplFile * PhaseContext
 
 type PhaseIdx = int
 type F<'In, 'Out> = 'In -> 'Out
@@ -75,12 +75,12 @@ type PhaseInputs =
         File: CheckedImplFile
         FileIdx: int
         // State returned by processing the previous phase for the current file.
-        PrevPhase: PhaseRes
+        PrevPhase: PhaseContext
         // State returned by processing the current phase for the previous file.
-        PrevFile: PhaseRes
+        PrevFile: PhaseContext
     }
 
-type PhaseFunc = PhaseInputs -> CheckedImplFile * PhaseRes
+type PhaseFunc = PhaseInputs -> CheckedImplFile * PhaseContext
 
 /// <summary>
 /// Each file's optimization can be split into three different phases, executed one after another.
@@ -115,7 +115,7 @@ module private ParallelOptimization =
 
     /// Final processing of file results to produce output needed for further compilation steps.
     let private collectFinalResults
-        (fileResults: PhaseRess[])
+        (fileResults: PhaseRes[])
         : (CheckedImplFileAfterOptimization * ImplFileOptimizationInfo)[] * IncrementalOptimizationEnv =
         let finalFileResults =
             fileResults
@@ -156,9 +156,9 @@ module private ParallelOptimization =
 
         // Functions for accessing a set of node jobs and their results
         let getTask, setTask =
-            let tasks: Task<PhaseRess>[,] = Array2D.zeroCreate files.Length phases.Length
+            let tasks: Task<PhaseRes>[,] = Array2D.zeroCreate files.Length phases.Length
             let getTask (node: Node) = tasks[node.FileIdx, node.Phase]
-            let setTask (node: Node) (task: Task<PhaseRess>) = tasks[node.FileIdx, node.Phase] <- task
+            let setTask (node: Node) (task: Task<PhaseRes>) = tasks[node.FileIdx, node.Phase] <- task
             getTask, setTask
 
         let getNodeInputs (node: Node) =
@@ -262,7 +262,7 @@ let optimizeFilesSequentially optEnv (phases: PhaseInfos) implFiles =
                         OptDuringCodeGen = fun _ expr -> expr
                     }
 
-                let runPhase (file: CheckedImplFile, state: PhaseRes) (phase: PhaseInfo) =
+                let runPhase (file: CheckedImplFile, state: PhaseContext) (phase: PhaseInfo) =
                     // In the sequential mode we always process all phases of the previous file before processing the current file.
                     // This is why the state returned by the previous phase of the current file contains all changes made in the previous file,
                     // and we can use it in both places.
@@ -378,7 +378,7 @@ let ApplyAllOptimizations
              PrevPhase = prevPhase
              PrevFile = prevFile
          }: PhaseInputs)
-        : PhaseRess =
+        : PhaseRes =
         let (env, file, optInfo, hidingInfo), optDuringCodeGen =
             Optimizer.OptimizeImplFile(
                 phase1Settings,
@@ -410,7 +410,7 @@ let ApplyAllOptimizations
              PrevPhase = prevPhase
              PrevFile = _prevFile
          }: PhaseInputs)
-        : PhaseRess =
+        : PhaseRes =
         let file = LowerLocalMutables.TransformImplFile tcGlobals importMap file
         file, prevPhase
 
@@ -422,7 +422,7 @@ let ApplyAllOptimizations
              PrevPhase = prevPhase
              PrevFile = prevFile
          }: PhaseInputs)
-        : PhaseRess =
+        : PhaseRes =
         let (optEnvExtraLoop, file, _, _), _ =
             Optimizer.OptimizeImplFile(
                 phase2And3Settings,
@@ -452,7 +452,7 @@ let ApplyAllOptimizations
              PrevPhase = prevPhase
              PrevFile = _prevFile
          }: PhaseInputs)
-        : PhaseRess =
+        : PhaseRes =
         let file = file |> Detuple.DetupleImplFile ccu tcGlobals
         file, prevPhase
 
@@ -465,7 +465,7 @@ let ApplyAllOptimizations
              PrevPhase = prevPhase
              PrevFile = _prevFile
          }: PhaseInputs)
-        : PhaseRess =
+        : PhaseRes =
         let file =
             file
             |> InnerLambdasToTopLevelFuncs.MakeTopLevelRepresentationDecisions ccu tcGlobals
@@ -481,7 +481,7 @@ let ApplyAllOptimizations
              PrevPhase = prevPhase
              PrevFile = _prevFile
          }: PhaseInputs)
-        : PhaseRess =
+        : PhaseRes =
         let file = LowerCalls.LowerImplFile tcGlobals file
         file, prevPhase
 
@@ -493,7 +493,7 @@ let ApplyAllOptimizations
              PrevPhase = prevPhase
              PrevFile = prevFile
          }: PhaseInputs)
-        : PhaseRess =
+        : PhaseRes =
         let (optEnvFinalSimplify, file, _, _), _ =
             Optimizer.OptimizeImplFile(
                 phase2And3Settings,

From fce6e828afd70d6b7b4127fa1057321d580bb93e Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Thu, 26 Jan 2023 08:39:21 +0000
Subject: [PATCH 23/42] Enable parallel optimization with
 FSharpExperimentalFeaturesEnabledAutomatically

---
 src/Compiler/Driver/CompilerConfig.fs  | 10 +++++++++-
 src/Compiler/Driver/CompilerOptions.fs |  2 +-
 src/Compiler/Driver/OptimizeInputs.fs  |  2 +-
 src/Compiler/Optimize/Optimizer.fs     |  5 +----
 src/Compiler/Optimize/Optimizer.fsi    |  5 ++++-
 5 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/src/Compiler/Driver/CompilerConfig.fs b/src/Compiler/Driver/CompilerConfig.fs
index aee2d46e095..f94f27ed86f 100644
--- a/src/Compiler/Driver/CompilerConfig.fs
+++ b/src/Compiler/Driver/CompilerConfig.fs
@@ -7,6 +7,7 @@ open System
 open System.Collections.Concurrent
 open System.Runtime.InteropServices
 open System.IO
+open FSharp.Compiler.Optimizer
 open Internal.Utilities
 open Internal.Utilities.FSharpEnvironment
 open Internal.Utilities.Library
@@ -733,7 +734,14 @@ type TcConfigBuilder =
             doTLR = false
             doFinalSimplify = false
             optsOn = false
-            optSettings = Optimizer.OptimizationSettings.Defaults
+            optSettings =
+                { OptimizationSettings.Defaults with
+                    processingMode =
+                        if FSharpExperimentalFeaturesEnabledAutomatically then
+                            OptimizationProcessingMode.Parallel
+                        else
+                            OptimizationProcessingMode.Sequential
+                }
             emitTailcalls = true
             deterministic = false
             concurrentBuild = true
diff --git a/src/Compiler/Driver/CompilerOptions.fs b/src/Compiler/Driver/CompilerOptions.fs
index b9c97e17bfa..dfad268bd18 100644
--- a/src/Compiler/Driver/CompilerOptions.fs
+++ b/src/Compiler/Driver/CompilerOptions.fs
@@ -1378,7 +1378,7 @@ let testFlag tcConfigB =
             | "ParallelOptimization" ->
                 tcConfigB.optSettings <-
                     { tcConfigB.optSettings with
-                        processingMode = OptimizationProcessingMode.PartiallyParallel
+                        processingMode = OptimizationProcessingMode.Parallel
                     }
 #if DEBUG
             | "ShowParserStackOnParseError" -> showParserStackOnParseError <- true
diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index cdfc14671ad..b9b8f77997d 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -521,7 +521,7 @@ let ApplyAllOptimizations
 
     let results, optEnvFirstLoop =
         match tcConfig.optSettings.processingMode with
-        | Optimizer.OptimizationProcessingMode.PartiallyParallel ->
+        | Optimizer.OptimizationProcessingMode.Parallel ->
             let results, optEnvFirstPhase =
                 ParallelOptimization.optimizeFilesInParallel2 optEnv phases implFiles
 
diff --git a/src/Compiler/Optimize/Optimizer.fs b/src/Compiler/Optimize/Optimizer.fs
index e2e64126db2..01d74daafea 100644
--- a/src/Compiler/Optimize/Optimizer.fs
+++ b/src/Compiler/Optimize/Optimizer.fs
@@ -292,11 +292,8 @@ let [<Literal>] debugPointsForPipeRightDefault = true
 
 [<RequireQualifiedAccess>]
 type OptimizationProcessingMode =
-    /// Process files sequentially, on a single thread, doing all three optimization phases for each file next to each other.
     | Sequential
-    /// Use multiple threads.
-    /// As soon as a given phase for a file has finished, start processing the next phase of the current file and the same phase of the next file.
-    | PartiallyParallel
+    | Parallel
 
 type OptimizationSettings = 
     { 
diff --git a/src/Compiler/Optimize/Optimizer.fsi b/src/Compiler/Optimize/Optimizer.fsi
index 1f68f4dcb04..fc35dc278c5 100644
--- a/src/Compiler/Optimize/Optimizer.fsi
+++ b/src/Compiler/Optimize/Optimizer.fsi
@@ -11,8 +11,11 @@ open FSharp.Compiler.TypedTreePickle
 
 [<RequireQualifiedAccess>]
 type OptimizationProcessingMode =
+    /// Process files sequentially, on a single thread, doing all three optimization phases for each file next to each other.
     | Sequential
-    | PartiallyParallel
+    /// Use multiple threads.
+    /// As soon as a given phase for a file has finished, start processing the next phase of the current file and the same phase of the next file.
+    | Parallel
 
 type OptimizationSettings =
     {

From 55635266ca5f7fc465a27e539dd10410f4123946 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Thu, 26 Jan 2023 18:27:33 +0000
Subject: [PATCH 24/42] PR feedback

---
 src/Compiler/Driver/OptimizeInputs.fs | 38 +++++----------------------
 1 file changed, 7 insertions(+), 31 deletions(-)

diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index b9b8f77997d..bbe01b66f11 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -74,19 +74,15 @@ type PhaseInputs =
     {
         File: CheckedImplFile
         FileIdx: int
-        // State returned by processing the previous phase for the current file.
+        // State returned by processing the previous phase for the current file, or initial state.
         PrevPhase: PhaseContext
-        // State returned by processing the current phase for the previous file.
+        // State returned by processing the current phase for the previous file, or initial state.
         PrevFile: PhaseContext
     }
 
 type PhaseFunc = PhaseInputs -> CheckedImplFile * PhaseContext
 
-/// <summary>
-/// Each file's optimization can be split into three different phases, executed one after another.
-/// Each phase calls 'Optimizer.OptimizeImplFile' and performs some other tasks.
-/// Each phase uses outputs of the previous phase and outputs of previous file's optimization for the same phase.
-/// </summary>
+/// Each file's optimization can be split into up to seven different phases, executed one after another.
 type Phase =
     {
         Idx: PhaseIdx
@@ -133,15 +129,14 @@ module private ParallelOptimization =
 
         finalFileResults, lastFileFirstLoopEnv
 
-    let private raiseNoResultsExn (node: Node) =
-        raise (exn $"Unexpected lack of results for {node}")
-
-    let optimizeFilesInParallel2
+    let optimizeFilesInParallel
         (env0: IncrementalOptimizationEnv)
         (phases: PhaseInfos)
         (files: CheckedImplFile list)
         : (CheckedImplFileAfterOptimization * ImplFileOptimizationInfo)[] * IncrementalOptimizationEnv =
 
+        let files = files |> List.toArray
+        
         /// Initial state for processing the current file.
         let initialState =
             {
@@ -330,24 +325,8 @@ let ApplyAllOptimizations
             reportingPhase = false
         }
 
-    let measurements = ConcurrentDictionary<string, int64>()
-
-    let measure (name: string) =
-        let sw = Stopwatch.StartNew()
-
-        { new System.IDisposable with
-            member this.Dispose() =
-                lock measurements (fun () ->
-                    if measurements.ContainsKey name = false then
-                        measurements[name] <- 0L
-
-                    measurements[name] <- measurements[name] + sw.ElapsedMilliseconds)
-        }
-
     let wrapPhaseFunc (f: PhaseFunc) (info: Phase) =
         fun (inputs: PhaseInputs) ->
-            use _ = measure info.Name
-
             use _ =
                 let tags =
                     [|
@@ -523,14 +502,11 @@ let ApplyAllOptimizations
         match tcConfig.optSettings.processingMode with
         | Optimizer.OptimizationProcessingMode.Parallel ->
             let results, optEnvFirstPhase =
-                ParallelOptimization.optimizeFilesInParallel2 optEnv phases implFiles
+                ParallelOptimization.optimizeFilesInParallel optEnv phases implFiles
 
             results |> Array.toList, optEnvFirstPhase
         | Optimizer.OptimizationProcessingMode.Sequential -> optimizeFilesSequentially optEnv phases implFiles
 
-    for kvp in measurements do
-        printfn $"[{kvp.Key}] = {kvp.Value}"
-
 #if DEBUG
     if tcConfig.showOptimizationData then
         results

From e78dc09f18c996128bf91c6b0869184dd09d24b2 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Thu, 26 Jan 2023 18:39:06 +0000
Subject: [PATCH 25/42] PR feedback + Fantomas

---
 src/Compiler/Driver/OptimizeInputs.fs        |  2 +-
 src/Compiler/FSharp.Compiler.Service.fsproj  |  1 -
 src/Compiler/Utilities/ParallelProcessing.fs | 53 --------------------
 3 files changed, 1 insertion(+), 55 deletions(-)
 delete mode 100644 src/Compiler/Utilities/ParallelProcessing.fs

diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index bbe01b66f11..d2a6e8e8e6c 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -136,7 +136,7 @@ module private ParallelOptimization =
         : (CheckedImplFileAfterOptimization * ImplFileOptimizationInfo)[] * IncrementalOptimizationEnv =
 
         let files = files |> List.toArray
-        
+
         /// Initial state for processing the current file.
         let initialState =
             {
diff --git a/src/Compiler/FSharp.Compiler.Service.fsproj b/src/Compiler/FSharp.Compiler.Service.fsproj
index 9ad8af1ee5c..95c92f9bdc1 100644
--- a/src/Compiler/FSharp.Compiler.Service.fsproj
+++ b/src/Compiler/FSharp.Compiler.Service.fsproj
@@ -135,7 +135,6 @@
     <Compile Include="Utilities\RidHelpers.fs" />
     <Compile Include="Utilities\range.fsi" />
     <Compile Include="Utilities\range.fs" />
-    <Compile Include="Utilities\ParallelProcessing.fs" />
     <EmbeddedText Include="Facilities\UtilsStrings.txt" />
     <Compile Include="Facilities\LanguageFeatures.fsi" />
     <Compile Include="Facilities\LanguageFeatures.fs" />
diff --git a/src/Compiler/Utilities/ParallelProcessing.fs b/src/Compiler/Utilities/ParallelProcessing.fs
deleted file mode 100644
index 74cd1508c07..00000000000
--- a/src/Compiler/Utilities/ParallelProcessing.fs
+++ /dev/null
@@ -1,53 +0,0 @@
-module internal FSharp.Compiler.Service.Utilities.ParallelProcessing
-
-#nowarn "1182"
-
-open System
-open System.Collections.Concurrent
-open System.Threading
-open FSharp.Compiler.Diagnostics
-open Internal.Utilities.Library.Extras
-
-/// <summary>
-/// Process items in parallel, allow more work to be scheduled as a result of finished work,
-/// limit parallelisation to 'parallelism' threads.
-/// </summary>
-/// <remarks>
-/// Could be replace with MailboxProcessor+Tasks/Asyncs instead of BlockingCollection + Threads.
-/// See http://www.fssnip.net/nX/title/Limit-degree-of-parallelism-using-an-agent for an example.
-/// </remarks>
-let processInParallel
-    (opName: string)
-    (firstItems: 'Item[])
-    (work: 'Item -> 'Item[])
-    (parallelism: int)
-    (shouldStop: unit -> bool)
-    (ct: CancellationToken)
-    (_itemToString: 'Item -> string)
-    : unit =
-
-    use _ =
-        Activity.start
-            $"processInParallel - {opName}"
-            [|
-                "firstItemsCount", firstItems.Length.ToString()
-                "parallelism", parallelism.ToString()
-            |]
-
-    let toProcess = new BlockingCollection<'Item>()
-    firstItems |> Array.iter toProcess.Add
-
-    let processItem item =
-        let toSchedule = work item
-        toSchedule |> Array.iter toProcess.Add
-
-    let worker () : unit =
-        for node in toProcess.GetConsumingEnumerable(ct) do
-            if not ct.IsCancellationRequested then
-                processItem node
-
-                if shouldStop () then
-                    toProcess.CompleteAdding()
-
-    let parallelism = min parallelism Environment.ProcessorCount
-    ArrayParallel.iter worker (Array.create parallelism ())

From 66c6fa8e5c94e788dd831176f258308d022358ee Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Fri, 27 Jan 2023 18:09:04 +0000
Subject: [PATCH 26/42] Fix asynchronous scheduling with Task.Yield

---
 src/Compiler/Driver/OptimizeInputs.fs | 29 +++++++++++++++------------
 1 file changed, 16 insertions(+), 13 deletions(-)

diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index d2a6e8e8e6c..a1e136332d9 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -158,16 +158,25 @@ module private ParallelOptimization =
 
         let getNodeInputs (node: Node) =
             task {
+                let prevPhaseNode = { node with Phase = node.Phase - 1 }
+                let prevFileNode = { node with FileIdx = node.FileIdx - 1 }
+
                 let prevPhaseTask =
                     if node.Phase > 0 then
-                        getTask { node with Phase = node.Phase - 1 }
+                        task {
+                            do! Task.Yield()
+                            return! getTask prevPhaseNode
+                        }
                     else
                         // First phase uses input file without modifications
                         (files[node.FileIdx], initialState) |> Task.FromResult
 
                 let prevFileTask =
                     if node.FileIdx > 0 then
-                        getTask { node with FileIdx = node.FileIdx - 1 }
+                        task {
+                            do! Task.Yield()
+                            return! getTask prevFileNode
+                        }
                     else
                         // We don't use the file result in this case, but we need something, so just take the first input file as a placeholder.
                         (files[0], initialState) |> Task.FromResult
@@ -188,18 +197,12 @@ module private ParallelOptimization =
             }
 
         let startNodeTask (phase: PhaseInfo) (node: Node) =
-            // A workaround to make sure that the initial part of each task is scheduled asynchronously
-            async {
-                let nodeTask =
-                    task {
-                        let! inputs = getNodeInputs node
-                        let res = phase.Func inputs
-                        return res
-                    }
-
-                return! nodeTask |> Async.AwaitTask
+            task {
+                do! Task.Yield()
+                let! inputs = getNodeInputs node
+                let res = phase.Func inputs
+                return res
             }
-            |> Async.StartAsTask
 
         let fileIndices = [| 0 .. files.Length - 1 |]
 

From 1937e9783a1722de279f0e3749e326c49902f663 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Fri, 27 Jan 2023 18:14:39 +0000
Subject: [PATCH 27/42] Auto-disable parallel optimization in deterministic
 builds

---
 src/Compiler/Driver/OptimizeInputs.fs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index a1e136332d9..4412d6d104c 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -503,11 +503,13 @@ let ApplyAllOptimizations
 
     let results, optEnvFirstLoop =
         match tcConfig.optSettings.processingMode with
-        | Optimizer.OptimizationProcessingMode.Parallel ->
+        // Parallel optimization breaks determinism - turn it off in deterministic builds.
+        | Optimizer.OptimizationProcessingMode.Parallel when (not tcConfig.deterministic) ->
             let results, optEnvFirstPhase =
                 ParallelOptimization.optimizeFilesInParallel optEnv phases implFiles
 
             results |> Array.toList, optEnvFirstPhase
+        | Optimizer.OptimizationProcessingMode.Parallel
         | Optimizer.OptimizationProcessingMode.Sequential -> optimizeFilesSequentially optEnv phases implFiles
 
 #if DEBUG

From eca78b4ea6cc24775c95282869e3f96e79e6efe2 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Fri, 27 Jan 2023 22:03:05 +0000
Subject: [PATCH 28/42] Add comments

---
 src/Compiler/Driver/OptimizeInputs.fs | 34 ++++++++++++---------------
 1 file changed, 15 insertions(+), 19 deletions(-)

diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index 4412d6d104c..d5332275fca 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -2,11 +2,8 @@
 
 module internal FSharp.Compiler.OptimizeInputs
 
-open System.Collections.Concurrent
 open System.Collections.Generic
-open System.Diagnostics
 open System.IO
-open System.Threading
 open System.Threading.Tasks
 open Internal.Utilities.Library
 open FSharp.Compiler
@@ -53,8 +50,7 @@ let GetInitialOptimizationEnv (tcImports: TcImports, tcGlobals: TcGlobals) =
     let optEnv = List.fold (AddExternalCcuToOptimizationEnv tcGlobals) optEnv ccuinfos
     optEnv
 
-type private OptimizeDuringCodeGen = bool -> Expr -> Expr
-
+/// All the state optimization phases can produce (except 'CheckedImplFile') and most of what they require as input.
 type PhaseContext =
     {
         OptEnvFirstLoop: Optimizer.IncrementalOptimizationEnv
@@ -62,14 +58,16 @@ type PhaseContext =
         OptEnvExtraLoop: Optimizer.IncrementalOptimizationEnv
         OptEnvFinalSimplify: Optimizer.IncrementalOptimizationEnv
         HidingInfo: SignatureHidingInfo
-        OptDuringCodeGen: OptimizeDuringCodeGen
+        OptDuringCodeGen: bool -> Expr -> Expr
     }
 
+/// The result of running a single Optimization Phase.
 type PhaseRes = CheckedImplFile * PhaseContext
 
+/// 0-based index of an Optimization Phase.
 type PhaseIdx = int
-type F<'In, 'Out> = 'In -> 'Out
 
+/// All inputs required to evaluate each Optimization Phase.
 type PhaseInputs =
     {
         File: CheckedImplFile
@@ -80,6 +78,7 @@ type PhaseInputs =
         PrevFile: PhaseContext
     }
 
+/// Signature of each optimization phase.
 type PhaseFunc = PhaseInputs -> CheckedImplFile * PhaseContext
 
 /// Each file's optimization can be split into up to seven different phases, executed one after another.
@@ -93,8 +92,6 @@ type Phase =
 
 type PhaseInfo = { Phase: Phase; Func: PhaseFunc }
 
-type PhaseInfos = PhaseInfo[]
-
 [<RequireQualifiedAccess>]
 module private ParallelOptimization =
     open Optimizer
@@ -131,7 +128,7 @@ module private ParallelOptimization =
 
     let optimizeFilesInParallel
         (env0: IncrementalOptimizationEnv)
-        (phases: PhaseInfos)
+        (phases: PhaseInfo[])
         (files: CheckedImplFile list)
         : (CheckedImplFileAfterOptimization * ImplFileOptimizationInfo)[] * IncrementalOptimizationEnv =
 
@@ -156,6 +153,7 @@ module private ParallelOptimization =
             let setTask (node: Node) (task: Task<PhaseRes>) = tasks[node.FileIdx, node.Phase] <- task
             getTask, setTask
 
+        /// Asynchronously wait for dependencies of a node
         let getNodeInputs (node: Node) =
             task {
                 let prevPhaseNode = { node with Phase = node.Phase - 1 }
@@ -238,7 +236,7 @@ module private ParallelOptimization =
 
         collectFinalResults lastPhaseResults
 
-let optimizeFilesSequentially optEnv (phases: PhaseInfos) implFiles =
+let optimizeFilesSequentially optEnv (phases: PhaseInfo[]) implFiles =
     let results, (optEnvFirstLoop, _, _, _) =
         let implFiles = implFiles |> List.mapi (fun i file -> i, file)
 
@@ -314,7 +312,7 @@ let ApplyAllOptimizations
 
     ReportTime tcConfig "Optimizations"
 
-    let phase1Settings =
+    let firstLoopSettings =
         { tcConfig.optSettings with
             // Only do abstractBigTargets in the first phase, and only when TLR is on.
             abstractBigTargets = tcConfig.doTLR
@@ -323,12 +321,12 @@ let ApplyAllOptimizations
 
     // Only do these two steps in the first phase.
     let phase2And3Settings =
-        { phase1Settings with
+        { firstLoopSettings with
             abstractBigTargets = false
             reportingPhase = false
         }
 
-    let wrapPhaseFunc (f: PhaseFunc) (info: Phase) =
+    let addPhaseDiagnostics (f: PhaseFunc) (info: Phase) =
         fun (inputs: PhaseInputs) ->
             use _ =
                 let tags =
@@ -349,7 +347,7 @@ let ApplyAllOptimizations
         let phaseInfo =
             {
                 Phase = phase
-                Func = wrapPhaseFunc phaseFunc phase
+                Func = addPhaseDiagnostics phaseFunc phase
             }
 
         phases.Add(phaseInfo)
@@ -363,7 +361,7 @@ let ApplyAllOptimizations
         : PhaseRes =
         let (env, file, optInfo, hidingInfo), optDuringCodeGen =
             Optimizer.OptimizeImplFile(
-                phase1Settings,
+                firstLoopSettings,
                 ccu,
                 tcGlobals,
                 tcVal,
@@ -505,9 +503,7 @@ let ApplyAllOptimizations
         match tcConfig.optSettings.processingMode with
         // Parallel optimization breaks determinism - turn it off in deterministic builds.
         | Optimizer.OptimizationProcessingMode.Parallel when (not tcConfig.deterministic) ->
-            let results, optEnvFirstPhase =
-                ParallelOptimization.optimizeFilesInParallel optEnv phases implFiles
-
+            let results, optEnvFirstPhase = ParallelOptimization.optimizeFilesInParallel optEnv phases implFiles
             results |> Array.toList, optEnvFirstPhase
         | Optimizer.OptimizationProcessingMode.Parallel
         | Optimizer.OptimizationProcessingMode.Sequential -> optimizeFilesSequentially optEnv phases implFiles

From b43a6400f522ff34d2e54243c47c73f7972f40b6 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Sat, 28 Jan 2023 10:20:30 +0000
Subject: [PATCH 29/42] Extract 'FirstLoopRes'

---
 src/Compiler/Driver/OptimizeInputs.fs | 77 ++++++++++++++++-----------
 1 file changed, 46 insertions(+), 31 deletions(-)

diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index d5332275fca..42de55bd337 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -50,17 +50,23 @@ let GetInitialOptimizationEnv (tcImports: TcImports, tcGlobals: TcGlobals) =
     let optEnv = List.fold (AddExternalCcuToOptimizationEnv tcGlobals) optEnv ccuinfos
     optEnv
 
-/// All the state optimization phases can produce (except 'CheckedImplFile') and most of what they require as input.
-type PhaseContext =
+/// Result of the 'FirstLoop' phase
+type FirstLoopRes =
     {
-        OptEnvFirstLoop: Optimizer.IncrementalOptimizationEnv
+        OptEnv: Optimizer.IncrementalOptimizationEnv
         OptInfo: Optimizer.ImplFileOptimizationInfo
-        OptEnvExtraLoop: Optimizer.IncrementalOptimizationEnv
-        OptEnvFinalSimplify: Optimizer.IncrementalOptimizationEnv
         HidingInfo: SignatureHidingInfo
         OptDuringCodeGen: bool -> Expr -> Expr
     }
 
+/// All the state optimization phases can produce (except 'CheckedImplFile') and most of what they require as input.
+type PhaseContext =
+    {
+        FirstLoopRes : FirstLoopRes
+        OptEnvExtraLoop : Optimizer.IncrementalOptimizationEnv
+        OptEnvFinalSimplify : Optimizer.IncrementalOptimizationEnv
+    }
+
 /// The result of running a single Optimization Phase.
 type PhaseRes = CheckedImplFile * PhaseContext
 
@@ -72,9 +78,9 @@ type PhaseInputs =
     {
         File: CheckedImplFile
         FileIdx: int
-        // State returned by processing the previous phase for the current file, or initial state.
+        /// State returned by processing the previous phase for the current file, or initial state.
         PrevPhase: PhaseContext
-        // State returned by processing the current phase for the previous file, or initial state.
+        /// State returned by processing the current phase for the previous file, or initial state.
         PrevFile: PhaseContext
     }
 
@@ -116,13 +122,13 @@ module private ParallelOptimization =
                 let implFile =
                     {
                         ImplFile = file
-                        OptimizeDuringCodeGen = res.OptDuringCodeGen
+                        OptimizeDuringCodeGen = res.FirstLoopRes.OptDuringCodeGen
                     }
 
-                implFile, res.OptInfo)
+                implFile, res.FirstLoopRes.OptInfo)
 
         let lastFileFirstLoopEnv =
-            fileResults |> Array.last |> (fun (_file, res) -> res.OptEnvFirstLoop)
+            fileResults |> Array.last |> (fun (_file, res) -> res.FirstLoopRes.OptEnv)
 
         finalFileResults, lastFileFirstLoopEnv
 
@@ -137,13 +143,16 @@ module private ParallelOptimization =
         /// Initial state for processing the current file.
         let initialState =
             {
-                OptEnvFirstLoop = env0
-                OptInfo = lazy failwith "This dummy value wrapped in a Lazy was not expected to be evaluated before being replaced."
+                FirstLoopRes =
+                    {
+                        OptEnv = env0
+                        OptInfo = lazy failwith "This dummy value wrapped in a Lazy was not expected to be evaluated before being replaced."
+                        HidingInfo = SignatureHidingInfo.Empty
+                        // A no-op optimizer
+                        OptDuringCodeGen = fun _ expr -> expr
+                    }
                 OptEnvExtraLoop = env0
                 OptEnvFinalSimplify = env0
-                HidingInfo = SignatureHidingInfo.Empty
-                // A no-op optimizer
-                OptDuringCodeGen = fun _ expr -> expr
             }
 
         // Functions for accessing a set of node jobs and their results
@@ -249,13 +258,16 @@ let optimizeFilesSequentially optEnv (phases: PhaseInfo[]) implFiles =
                 let state =
                     implFile,
                     {
-                        OptEnvFirstLoop = optEnvFirstLoop
-                        OptInfo = lazy failwith "This dummy value wrapped in a Lazy was not expected to be evaluated before being replaced."
+                        FirstLoopRes =
+                            {
+                                OptEnv = optEnvFirstLoop
+                                OptInfo = lazy failwith "This dummy value wrapped in a Lazy was not expected to be evaluated before being replaced."
+                                HidingInfo = hidden
+                                // A no-op optimizer
+                                OptDuringCodeGen = fun _ expr -> expr
+                            }
                         OptEnvExtraLoop = optEnvExtraLoop
                         OptEnvFinalSimplify = optEnvFinalSimplify
-                        HidingInfo = hidden
-                        // A no-op optimizer
-                        OptDuringCodeGen = fun _ expr -> expr
                     }
 
                 let runPhase (file: CheckedImplFile, state: PhaseContext) (phase: PhaseInfo) =
@@ -277,10 +289,10 @@ let optimizeFilesSequentially optEnv (phases: PhaseInfo[]) implFiles =
                 let file =
                     {
                         ImplFile = implFile
-                        OptimizeDuringCodeGen = state.OptDuringCodeGen
+                        OptimizeDuringCodeGen = state.FirstLoopRes.OptDuringCodeGen
                     }
 
-                (file, state.OptInfo), (state.OptEnvFirstLoop, state.OptEnvExtraLoop, state.OptEnvFinalSimplify, state.HidingInfo))
+                (file, state.FirstLoopRes.OptInfo), (state.FirstLoopRes.OptEnv, state.OptEnvExtraLoop, state.OptEnvFinalSimplify, state.FirstLoopRes.HidingInfo))
 
     results, optEnvFirstLoop
 
@@ -366,20 +378,23 @@ let ApplyAllOptimizations
                 tcGlobals,
                 tcVal,
                 importMap,
-                prevFile.OptEnvFirstLoop,
+                prevFile.FirstLoopRes.OptEnv,
                 isIncrementalFragment,
                 tcConfig.fsiMultiAssemblyEmit,
                 tcConfig.emitTailcalls,
-                prevFile.HidingInfo,
+                prevFile.FirstLoopRes.HidingInfo,
                 file
             )
 
         file,
         { prevPhase with
-            OptEnvFirstLoop = env
-            OptInfo = optInfo
-            HidingInfo = hidingInfo
-            OptDuringCodeGen = optDuringCodeGen
+            FirstLoopRes =
+                {
+                    OptEnv = env
+                    OptInfo = optInfo
+                    HidingInfo = hidingInfo
+                    OptDuringCodeGen = optDuringCodeGen
+                }
         }
 
     addPhase "firstLoop" firstLoop
@@ -414,7 +429,7 @@ let ApplyAllOptimizations
                 isIncrementalFragment,
                 tcConfig.fsiMultiAssemblyEmit,
                 tcConfig.emitTailcalls,
-                prevPhase.HidingInfo,
+                prevPhase.FirstLoopRes.HidingInfo,
                 file
             )
 
@@ -485,7 +500,7 @@ let ApplyAllOptimizations
                 isIncrementalFragment,
                 tcConfig.fsiMultiAssemblyEmit,
                 tcConfig.emitTailcalls,
-                prevPhase.HidingInfo,
+                prevPhase.FirstLoopRes.HidingInfo,
                 file
             )
 
@@ -574,7 +589,7 @@ let GenerateIlxCode
             isInteractive = tcConfig.isInteractive
             isInteractiveItExpr = isInteractiveItExpr
             alwaysCallVirt = tcConfig.alwaysCallVirt
-            parallelIlxGenEnabled = tcConfig.parallelIlxGen && not (tcConfig.deterministic)
+            parallelIlxGenEnabled = tcConfig.parallelIlxGen && not tcConfig.deterministic
         }
 
     ilxGenerator.GenerateCode(ilxGenOpts, optimizedImpls, topAttrs.assemblyAttrs, topAttrs.netModuleAttrs)

From 355015296146fd1e4e9c1cdfdfeb88f4c13acaf0 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Fri, 10 Feb 2023 21:40:30 +0000
Subject: [PATCH 30/42] Fantomas

---
 src/Compiler/Driver/OptimizeInputs.fs         | 18 ++++++----
 .../BraceMatchingServiceTests.fs              | 14 +++++---
 .../BreakpointResolutionServiceTests.fs       |  6 ++--
 .../CompletionProviderTests.fs                |  8 +++--
 .../DocumentDiagnosticAnalyzerTests.fs        | 34 ++++++++++++++-----
 .../DocumentHighlightsServiceTests.fs         |  2 +-
 .../EditorFormattingServiceTests.fs           | 18 +++++++---
 .../FsxCompletionProviderTests.fs             |  8 +++--
 .../GoToDefinitionServiceTests.fs             |  1 +
 .../HelpContextServiceTests.fs                | 17 ++++------
 .../Helpers/RoslynHelpers.fs                  | 26 ++++++++------
 .../Hints/HintTestFramework.fs                | 16 ++++++---
 .../Hints/InlineParameterNameHintTests.fs     |  2 +-
 .../Hints/InlineTypeHintTests.fs              | 18 +++++++---
 .../IndentationServiceTests.fs                | 12 ++++---
 .../LanguageDebugInfoServiceTests.fs          |  7 ++--
 .../QuickInfoProviderTests.fs                 | 34 +++++++++----------
 .../FSharp.Editor.Tests/QuickInfoTests.fs     |  6 ++--
 .../SemanticClassificationServiceTests.fs     |  9 +++--
 .../SignatureHelpProviderTests.fs             |  7 ++--
 .../SyntacticColorizationServiceTests.fs      |  8 ++---
 21 files changed, 168 insertions(+), 103 deletions(-)

diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index 42de55bd337..9b04f503ca9 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -62,9 +62,9 @@ type FirstLoopRes =
 /// All the state optimization phases can produce (except 'CheckedImplFile') and most of what they require as input.
 type PhaseContext =
     {
-        FirstLoopRes : FirstLoopRes
-        OptEnvExtraLoop : Optimizer.IncrementalOptimizationEnv
-        OptEnvFinalSimplify : Optimizer.IncrementalOptimizationEnv
+        FirstLoopRes: FirstLoopRes
+        OptEnvExtraLoop: Optimizer.IncrementalOptimizationEnv
+        OptEnvFinalSimplify: Optimizer.IncrementalOptimizationEnv
     }
 
 /// The result of running a single Optimization Phase.
@@ -261,7 +261,10 @@ let optimizeFilesSequentially optEnv (phases: PhaseInfo[]) implFiles =
                         FirstLoopRes =
                             {
                                 OptEnv = optEnvFirstLoop
-                                OptInfo = lazy failwith "This dummy value wrapped in a Lazy was not expected to be evaluated before being replaced."
+                                OptInfo =
+                                    lazy
+                                        failwith
+                                            "This dummy value wrapped in a Lazy was not expected to be evaluated before being replaced."
                                 HidingInfo = hidden
                                 // A no-op optimizer
                                 OptDuringCodeGen = fun _ expr -> expr
@@ -292,7 +295,8 @@ let optimizeFilesSequentially optEnv (phases: PhaseInfo[]) implFiles =
                         OptimizeDuringCodeGen = state.FirstLoopRes.OptDuringCodeGen
                     }
 
-                (file, state.FirstLoopRes.OptInfo), (state.FirstLoopRes.OptEnv, state.OptEnvExtraLoop, state.OptEnvFinalSimplify, state.FirstLoopRes.HidingInfo))
+                (file, state.FirstLoopRes.OptInfo),
+                (state.FirstLoopRes.OptEnv, state.OptEnvExtraLoop, state.OptEnvFinalSimplify, state.FirstLoopRes.HidingInfo))
 
     results, optEnvFirstLoop
 
@@ -518,7 +522,9 @@ let ApplyAllOptimizations
         match tcConfig.optSettings.processingMode with
         // Parallel optimization breaks determinism - turn it off in deterministic builds.
         | Optimizer.OptimizationProcessingMode.Parallel when (not tcConfig.deterministic) ->
-            let results, optEnvFirstPhase = ParallelOptimization.optimizeFilesInParallel optEnv phases implFiles
+            let results, optEnvFirstPhase =
+                ParallelOptimization.optimizeFilesInParallel optEnv phases implFiles
+
             results |> Array.toList, optEnvFirstPhase
         | Optimizer.OptimizationProcessingMode.Parallel
         | Optimizer.OptimizationProcessingMode.Sequential -> optimizeFilesSequentially optEnv phases implFiles
diff --git a/vsintegration/tests/FSharp.Editor.Tests/BraceMatchingServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/BraceMatchingServiceTests.fs
index a5278a27c02..9e8bce2aba3 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/BraceMatchingServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/BraceMatchingServiceTests.fs
@@ -19,14 +19,15 @@ type BraceMatchingServiceTests() =
         let position = fileContents.IndexOf(marker)
         Assert.True(position >= 0, $"Cannot find marker '{marker}' in file contents")
 
-        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
+        let parsingOptions, _ =
+            checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
         match
             FSharpBraceMatchingService.GetBraceMatchingResult(checker, sourceText, fileName, parsingOptions, position, "UnitTest")
             |> Async.RunImmediateExceptOnUI
         with
         | None -> ()
-        | Some (left, right) ->  failwith $"Found match for brace '{marker}'"
+        | Some (left, right) -> failwith $"Found match for brace '{marker}'"
 
     member private this.VerifyBraceMatch(fileContents: string, startMarker: string, endMarker: string) =
         let sourceText = SourceText.From(fileContents)
@@ -36,7 +37,8 @@ type BraceMatchingServiceTests() =
         Assert.True(startMarkerPosition >= 0, $"Cannot find start marker '{startMarkerPosition}' in file contents")
         Assert.True(endMarkerPosition >= 0, $"Cannot find end marker '{endMarkerPosition}' in file contents")
 
-        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
+        let parsingOptions, _ =
+            checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
         match
             FSharpBraceMatchingService.GetBraceMatchingResult(
@@ -202,7 +204,9 @@ let main argv =
     [<InlineData("let a8 = seq { yield() }", 13, 23)>]
     member this.DoNotMatchOnInnerSide(fileContents: string, [<ParamArray>] matchingPositions: int[]) =
         let sourceText = SourceText.From(fileContents)
-        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
+
+        let parsingOptions, _ =
+            checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
         for position in matchingPositions do
             match
@@ -215,4 +219,4 @@ let main argv =
                 | 0 -> ""
                 | _ -> fileContents.[position - 1] |> sprintf " (previous character '%c')"
                 |> sprintf "Didn't find a matching brace at position '%d' %s" position
-                |> raise (exn())
+                |> raise (exn ())
diff --git a/vsintegration/tests/FSharp.Editor.Tests/BreakpointResolutionServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/BreakpointResolutionServiceTests.fs
index 548991e3d5f..7322e981aba 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/BreakpointResolutionServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/BreakpointResolutionServiceTests.fs
@@ -45,15 +45,15 @@ let main argv =
         |]
 
     [<Theory>]
-    [<MemberData(nameof(BreakpointResolutionServiceTests.testCases))>]
+    [<MemberData(nameof (BreakpointResolutionServiceTests.testCases))>]
     member this.TestBreakpointResolution(searchToken: string, expectedResolution: string option) =
         let searchPosition = code.IndexOf(searchToken)
         Assert.True(searchPosition >= 0, $"SearchToken '{searchToken}' is not found in code")
 
         let sourceText = SourceText.From(code)
+
         let document =
-            RoslynTestHelpers.CreateSolution(code)
-            |> RoslynTestHelpers.GetSingleDocument
+            RoslynTestHelpers.CreateSolution(code) |> RoslynTestHelpers.GetSingleDocument
 
         let searchSpan =
             TextSpan.FromBounds(searchPosition, searchPosition + searchToken.Length)
diff --git a/vsintegration/tests/FSharp.Editor.Tests/CompletionProviderTests.fs b/vsintegration/tests/FSharp.Editor.Tests/CompletionProviderTests.fs
index 2be760394f9..aa122deca01 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/CompletionProviderTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/CompletionProviderTests.fs
@@ -141,7 +141,9 @@ System.Console.WriteLine(x + y)
                     IntelliSenseOptions.Default
                 )
 
-            triggered |> Assert.shouldBeEqualWith shouldBeTriggered 
+            triggered
+            |> Assert.shouldBeEqualWith
+                shouldBeTriggered
                 "FSharpCompletionProvider.ShouldTriggerCompletionAux() should compute the correct result"
 
     [<Fact>]
@@ -242,7 +244,9 @@ let z = $"abc  {System.Console.WriteLine(x + y)} def"
                     IntelliSenseOptions.Default
                 )
 
-            triggered |> Assert.shouldBeEqualWith shouldBeTriggered 
+            triggered
+            |> Assert.shouldBeEqualWith
+                shouldBeTriggered
                 $"FSharpCompletionProvider.ShouldTriggerCompletionAux() should compute the correct result for marker '{marker}"
 
     [<Fact>]
diff --git a/vsintegration/tests/FSharp.Editor.Tests/DocumentDiagnosticAnalyzerTests.fs b/vsintegration/tests/FSharp.Editor.Tests/DocumentDiagnosticAnalyzerTests.fs
index 51fdf2be248..f5a3bd134fe 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/DocumentDiagnosticAnalyzerTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/DocumentDiagnosticAnalyzerTests.fs
@@ -36,17 +36,25 @@ type DocumentDiagnosticAnalyzerTests() =
             |> Seq.filter (fun e -> e.Severity = DiagnosticSeverity.Error)
             |> Seq.toArray
 
-        errors.Length |> Assert.shouldBeEqualWith 1 "There should be exactly one error generated"
+        errors.Length
+        |> Assert.shouldBeEqualWith 1 "There should be exactly one error generated"
+
         let actualError = errors.[0]
 
         if expectedMessage.IsSome then
-            actualError.GetMessage() |> Assert.shouldBeEqualWith expectedMessage.Value "Error messages should match"
+            actualError.GetMessage()
+            |> Assert.shouldBeEqualWith expectedMessage.Value "Error messages should match"
 
         Assert.Equal(DiagnosticSeverity.Error, actualError.Severity)
         let expectedStart = fileContents.IndexOf(expectedMarker)
-        actualError.Location.SourceSpan.Start |> Assert.shouldBeEqualWith expectedStart "Error start positions should match"
+
+        actualError.Location.SourceSpan.Start
+        |> Assert.shouldBeEqualWith expectedStart "Error start positions should match"
+
         let expectedEnd = expectedStart + expectedMarker.Length
-        actualError.Location.SourceSpan.End |> Assert.shouldBeEqualWith expectedEnd "Error end positions should match"
+
+        actualError.Location.SourceSpan.End
+        |> Assert.shouldBeEqualWith expectedEnd "Error end positions should match"
 
     member private this.VerifyDiagnosticBetweenMarkers
         (
@@ -59,14 +67,24 @@ type DocumentDiagnosticAnalyzerTests() =
             |> Seq.filter (fun e -> e.Severity = expectedSeverity)
             |> Seq.toArray
 
-        errors.Length |> Assert.shouldBeEqualWith 1 "There should be exactly one error generated"
+        errors.Length
+        |> Assert.shouldBeEqualWith 1 "There should be exactly one error generated"
+
         let actualError = errors.[0]
         Assert.Equal(expectedSeverity, actualError.Severity)
-        actualError.GetMessage() |> Assert.shouldBeEqualWith expectedMessage "Error messages should match"
+
+        actualError.GetMessage()
+        |> Assert.shouldBeEqualWith expectedMessage "Error messages should match"
+
         let expectedStart = fileContents.IndexOf(startMarker) + startMarker.Length
-        actualError.Location.SourceSpan.Start |> Assert.shouldBeEqualWith expectedStart "Error start positions should match"
+
+        actualError.Location.SourceSpan.Start
+        |> Assert.shouldBeEqualWith expectedStart "Error start positions should match"
+
         let expectedEnd = fileContents.IndexOf(endMarker)
-        actualError.Location.SourceSpan.End |> Assert.shouldBeEqualWith expectedEnd "Error end positions should match"
+
+        actualError.Location.SourceSpan.End
+        |> Assert.shouldBeEqualWith expectedEnd "Error end positions should match"
 
     member private this.VerifyErrorBetweenMarkers(fileContents: string, expectedMessage: string) =
         this.VerifyDiagnosticBetweenMarkers(fileContents, expectedMessage, DiagnosticSeverity.Error)
diff --git a/vsintegration/tests/FSharp.Editor.Tests/DocumentHighlightsServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/DocumentHighlightsServiceTests.fs
index f590c76df1b..08a61bfcd9c 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/DocumentHighlightsServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/DocumentHighlightsServiceTests.fs
@@ -15,7 +15,7 @@ module DocumentHighlightsServiceTests =
     let filePath = "C:\\test.fs"
 
     let private getSpans (fileContents: string) (caretPosition: int) =
-        let document = 
+        let document =
             RoslynTestHelpers.CreateSolution(fileContents)
             |> RoslynTestHelpers.GetSingleDocument
 
diff --git a/vsintegration/tests/FSharp.Editor.Tests/EditorFormattingServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/EditorFormattingServiceTests.fs
index 2e917447cdf..12d0369a4b2 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/EditorFormattingServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/EditorFormattingServiceTests.fs
@@ -66,7 +66,8 @@ marker4"""
         let lineNumber =
             sourceText.Lines |> Seq.findIndex (fun line -> line.Span.Contains position)
 
-        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
+        let parsingOptions, _ =
+            checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
         let changesOpt =
             FSharpEditorFormattingService.GetFormattingChanges(
@@ -93,7 +94,9 @@ marker4"""
     [<InlineData(false, "")>]
     member this.TestPasteChanges_PastingOntoIndentedLine(enabled: bool, prefix: string) =
         let checker = FSharpChecker.Create()
-        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
+
+        let parsingOptions, _ =
+            checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
         let clipboard =
             prefix
@@ -149,14 +152,17 @@ somethingElseHere
                 Assert.Equal(expected, changedText)
             | _ -> failwithf "Expected text changes, but got %+A" changesOpt
         else
-            changesOpt |> Assert.shouldBeEqualWith None "Expected no changes as FormatOnPaste is disabled"
+            changesOpt
+            |> Assert.shouldBeEqualWith None "Expected no changes as FormatOnPaste is disabled"
 
     [<Theory>]
     [<InlineData "">]
     [<InlineData "        ">]
     member this.TestPasteChanges_PastingOntoEmptyLine(prefix: string) =
         let checker = FSharpChecker.Create()
-        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
+
+        let parsingOptions, _ =
+            checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
         let clipboard =
             prefix
@@ -214,7 +220,9 @@ somethingElseHere
     [<Fact>]
     member this.TestPasteChanges_PastingWithAutoIndentationInPasteSpan() =
         let checker = FSharpChecker.Create()
-        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
+
+        let parsingOptions, _ =
+            checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
         let clipboard =
             """[<Class>]
diff --git a/vsintegration/tests/FSharp.Editor.Tests/FsxCompletionProviderTests.fs b/vsintegration/tests/FSharp.Editor.Tests/FsxCompletionProviderTests.fs
index 1cbe5025735..48276422bdd 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/FsxCompletionProviderTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/FsxCompletionProviderTests.fs
@@ -17,7 +17,11 @@ type Worker() =
     member _.VerifyCompletionListExactly(fileContents: string, marker: string, expected: List<string>) =
         let caretPosition = fileContents.IndexOf(marker) + marker.Length
 
-        let options = { RoslynTestHelpers.DefaultProjectOptions with SourceFiles = [|filePath|] }
+        let options =
+            { RoslynTestHelpers.DefaultProjectOptions with
+                SourceFiles = [| filePath |]
+            }
+
         let document =
             RoslynTestHelpers.CreateSolution(fileContents, options = options)
             |> RoslynTestHelpers.GetSingleDocument
@@ -49,7 +53,7 @@ module FsxCompletionProviderTests =
     let getWorker () = Worker()
 
 #if RELEASE
-    [<Fact(Skip="Fails in some CI, reproduces locally in Release mode, needs investigation")>]
+    [<Fact(Skip = "Fails in some CI, reproduces locally in Release mode, needs investigation")>]
 #else
     [<Fact>]
 #endif
diff --git a/vsintegration/tests/FSharp.Editor.Tests/GoToDefinitionServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/GoToDefinitionServiceTests.fs
index f4f534743a1..87abb259e0d 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/GoToDefinitionServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/GoToDefinitionServiceTests.fs
@@ -55,6 +55,7 @@ module GoToDefinitionServiceTests =
         let caretPosition = fileContents.IndexOf(caretMarker) + caretMarker.Length - 1 // inside the marker
 
         let sourceText = SourceText.From(fileContents)
+
         let document =
             RoslynTestHelpers.CreateSolution(fileContents)
             |> RoslynTestHelpers.GetSingleDocument
diff --git a/vsintegration/tests/FSharp.Editor.Tests/HelpContextServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/HelpContextServiceTests.fs
index 4f93b1e0ef7..c48506c78b3 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/HelpContextServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/HelpContextServiceTests.fs
@@ -27,6 +27,7 @@ type HelpContextServiceTests() =
         let fileContents = fileContentsWithMarkers.Replace("$", "")
 
         let sourceText = SourceText.From(fileContents)
+
         let document =
             RoslynTestHelpers.CreateSolution(fileContents)
             |> RoslynTestHelpers.GetSingleDocument
@@ -57,7 +58,7 @@ type HelpContextServiceTests() =
         TestF1KeywordsWithOptions(expectedKeywords, lines)
 
 #if RELEASE
-    [<Fact(Skip="Fails in some CI, reproduces locally in Release mode, needs investigation")>]
+    [<Fact(Skip = "Fails in some CI, reproduces locally in Release mode, needs investigation")>]
 #else
     [<Fact>]
 #endif
@@ -209,7 +210,7 @@ type HelpContextServiceTests() =
         TestF1Keywords(keywords, file)
 
 #if RELEASE
-    [<Fact(Skip="Fails in some CI, reproduces locally in Release mode, needs investigation")>]
+    [<Fact(Skip = "Fails in some CI, reproduces locally in Release mode, needs investigation")>]
 #else
     [<Fact>]
 #endif
@@ -218,13 +219,10 @@ type HelpContextServiceTests() =
         let file = [ "open N$1" ]
         let keywords = [ Some "N1" ]
 
-        TestF1KeywordsWithOptions(
-            keywords,
-            file
-        )
+        TestF1KeywordsWithOptions(keywords, file)
 
 #if RELEASE
-    [<Fact(Skip="Fails in some CI, reproduces locally in Release mode, needs investigation")>]
+    [<Fact(Skip = "Fails in some CI, reproduces locally in Release mode, needs investigation")>]
 #else
     [<Fact>]
 #endif
@@ -239,10 +237,7 @@ type HelpContextServiceTests() =
 
         let keywords = [ Some "N1.T" ]
 
-        TestF1KeywordsWithOptions(
-            keywords,
-            file
-        )
+        TestF1KeywordsWithOptions(keywords, file)
 
     [<Fact>]
     member _.``F1 help keyword EndOfLine``() =
diff --git a/vsintegration/tests/FSharp.Editor.Tests/Helpers/RoslynHelpers.fs b/vsintegration/tests/FSharp.Editor.Tests/Helpers/RoslynHelpers.fs
index 331a812ddd7..9efa3ecc055 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/Helpers/RoslynHelpers.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/Helpers/RoslynHelpers.fs
@@ -219,8 +219,9 @@ type RoslynTestHelpers private () =
             Stamp = None
         }
 
-    static member private GetSourceCodeKind filePath = 
+    static member private GetSourceCodeKind filePath =
         let extension = Path.GetExtension(filePath)
+
         match extension with
         | ".fsx" -> SourceCodeKind.Script
         | ".fsi" -> SourceCodeKind.Regular
@@ -232,7 +233,7 @@ type RoslynTestHelpers private () =
         let id = SolutionId.CreateNewId()
         let versionStamp = VersionStamp.Create(DateTime.UtcNow)
         let slnPath = "test.sln"
- 
+
         let solutionInfo = SolutionInfo.Create(id, versionStamp, slnPath, projects)
         let solution = workspace.AddSolution(solutionInfo)
         solution
@@ -243,7 +244,8 @@ type RoslynTestHelpers private () =
             filePath,
             loader = TextLoader.From(SourceText.From(code).Container, VersionStamp.Create(DateTime.UtcNow)),
             filePath = filePath,
-            sourceCodeKind = RoslynTestHelpers.GetSourceCodeKind filePath)
+            sourceCodeKind = RoslynTestHelpers.GetSourceCodeKind filePath
+        )
 
     static member CreateProjectInfo id filePath documents =
         ProjectInfo.Create(
@@ -253,9 +255,10 @@ type RoslynTestHelpers private () =
             "test.dll",
             LanguageNames.FSharp,
             documents = documents,
-            filePath = filePath)
+            filePath = filePath
+        )
 
-    static member SetProjectOptions projId (solution: Solution) (options: FSharpProjectOptions)  = 
+    static member SetProjectOptions projId (solution: Solution) (options: FSharpProjectOptions) =
         solution
             .Workspace
             .Services
@@ -264,18 +267,19 @@ type RoslynTestHelpers private () =
             .SetCommandLineOptions(
                 projId,
                 options.SourceFiles,
-                options.OtherOptions |> ImmutableArray.CreateRange)
+                options.OtherOptions |> ImmutableArray.CreateRange
+            )
 
-    static member CreateSolution (source, ?options: FSharpProjectOptions) =
+    static member CreateSolution(source, ?options: FSharpProjectOptions) =
         let projId = ProjectId.CreateNewId()
 
         let docInfo = RoslynTestHelpers.CreateDocumentInfo projId "C:\\test.fs" source
 
         let projFilePath = "C:\\test.fsproj"
-        let projInfo = RoslynTestHelpers.CreateProjectInfo projId projFilePath [docInfo]
-        let solution = RoslynTestHelpers.CreateSolution [projInfo]
+        let projInfo = RoslynTestHelpers.CreateProjectInfo projId projFilePath [ docInfo ]
+        let solution = RoslynTestHelpers.CreateSolution [ projInfo ]
 
-        options 
+        options
         |> Option.defaultValue RoslynTestHelpers.DefaultProjectOptions
         |> RoslynTestHelpers.SetProjectOptions projId solution
 
@@ -284,4 +288,4 @@ type RoslynTestHelpers private () =
     static member GetSingleDocument(solution: Solution) =
         let project = solution.Projects |> Seq.exactlyOne
         let document = project.Documents |> Seq.exactlyOne
-        document
\ No newline at end of file
+        document
diff --git a/vsintegration/tests/FSharp.Editor.Tests/Hints/HintTestFramework.fs b/vsintegration/tests/FSharp.Editor.Tests/Hints/HintTestFramework.fs
index 7f9a8be3cbf..70f06bb0940 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/Hints/HintTestFramework.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/Hints/HintTestFramework.fs
@@ -30,7 +30,11 @@ module HintTestFramework =
 
     let getFsDocument code =
         // I don't know, without this lib some symbols are just not loaded
-        let options = { RoslynTestHelpers.DefaultProjectOptions with OtherOptions = [| "--targetprofile:netcore" |] }
+        let options =
+            { RoslynTestHelpers.DefaultProjectOptions with
+                OtherOptions = [| "--targetprofile:netcore" |]
+            }
+
         RoslynTestHelpers.CreateSolution(code, options = options)
         |> RoslynTestHelpers.GetSingleDocument
 
@@ -38,11 +42,15 @@ module HintTestFramework =
         let projectId = ProjectId.CreateNewId()
         let projFilePath = "C:\\test.fsproj"
 
-        let fsiDocInfo = RoslynTestHelpers.CreateDocumentInfo projectId "C:\\test.fsi" fsiCode
+        let fsiDocInfo =
+            RoslynTestHelpers.CreateDocumentInfo projectId "C:\\test.fsi" fsiCode
+
         let fsDocInfo = RoslynTestHelpers.CreateDocumentInfo projectId "C:\\test.fs" fsCode
 
-        let projInfo = RoslynTestHelpers.CreateProjectInfo projectId projFilePath [fsiDocInfo; fsDocInfo]
-        let solution = RoslynTestHelpers.CreateSolution [projInfo]
+        let projInfo =
+            RoslynTestHelpers.CreateProjectInfo projectId projFilePath [ fsiDocInfo; fsDocInfo ]
+
+        let solution = RoslynTestHelpers.CreateSolution [ projInfo ]
         let project = solution.Projects |> Seq.exactlyOne
         project.Documents
 
diff --git a/vsintegration/tests/FSharp.Editor.Tests/Hints/InlineParameterNameHintTests.fs b/vsintegration/tests/FSharp.Editor.Tests/Hints/InlineParameterNameHintTests.fs
index d9da400e4ad..7a44467afcf 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/Hints/InlineParameterNameHintTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/Hints/InlineParameterNameHintTests.fs
@@ -448,7 +448,7 @@ type MyType() =
         let actual = getParameterNameHints document
 
         Assert.Empty(actual)
-        
+
     [<Fact>]
     let ``Hints are shown correctly for inner bindings`` () =
         let code =
diff --git a/vsintegration/tests/FSharp.Editor.Tests/Hints/InlineTypeHintTests.fs b/vsintegration/tests/FSharp.Editor.Tests/Hints/InlineTypeHintTests.fs
index a8219a3c53a..d995223fbd3 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/Hints/InlineTypeHintTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/Hints/InlineTypeHintTests.fs
@@ -204,6 +204,7 @@ let func = fun () -> 3
             """
 let x
 """
+
         let document = getFsDocument code
 
         let result = getTypeHints document
@@ -211,11 +212,12 @@ let x
         Assert.Empty(result)
 
     [<Fact>]
-    let ``Hints are not shown for unsolved types in _for_ expressions in collections`` () = 
+    let ``Hints are not shown for unsolved types in _for_ expressions in collections`` () =
         let code =
             """
 let _ = [ for x ]
 """
+
         let document = getFsDocument code
 
         let result = getTypeHints document
@@ -223,7 +225,7 @@ let _ = [ for x ]
         Assert.Empty(result)
 
     [<Fact>]
-    let ``Hints are not shown for unsolved types in _for_ expressions within computational expressions`` () = 
+    let ``Hints are not shown for unsolved types in _for_ expressions within computational expressions`` () =
         let code =
             """
 do task {
@@ -232,6 +234,7 @@ do task {
     do! Task.Delay 0
     }
 """
+
         let document = getFsDocument code
 
         let result = getTypeHints document
@@ -250,12 +253,19 @@ type Number<'T when IAddition<'T>>(value: 'T) =
     interface IAddition<Number<'T>> with
         static member op_Addition(a, b) = Number(a.Value + b.Value)
 """
+
         let document = getFsDocument code
 
         let expected =
             [
-                { Content = ": Number<'T>"; Location = (7, 36) }
-                { Content = ": Number<'T>"; Location = (7, 39) }
+                {
+                    Content = ": Number<'T>"
+                    Location = (7, 36)
+                }
+                {
+                    Content = ": Number<'T>"
+                    Location = (7, 39)
+                }
             ]
 
         let actual = getTypeHints document
diff --git a/vsintegration/tests/FSharp.Editor.Tests/IndentationServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/IndentationServiceTests.fs
index 3ef331544c3..81f2bfc7f09 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/IndentationServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/IndentationServiceTests.fs
@@ -165,7 +165,8 @@ while true do
         for (expectedIndentation, lineNumber, template) in testCases do
             let sourceText = SourceText.From(template)
 
-            let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
+            let parsingOptions, _ =
+                checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
             let actualIndentation =
                 FSharpIndentationService.GetDesiredIndentation(
@@ -181,7 +182,8 @@ while true do
             match expectedIndentation with
             | None -> Assert.True(actualIndentation.IsNone, $"No indentation was expected at line {lineNumber}")
             | Some indentation ->
-                actualIndentation.Value |> Assert.shouldBeEqualWith indentation  $"Indentation on line {lineNumber} doesn't match"
+                actualIndentation.Value
+                |> Assert.shouldBeEqualWith indentation $"Indentation on line {lineNumber} doesn't match"
 
     [<Fact>]
     member this.TestAutoIndentation() =
@@ -189,7 +191,8 @@ while true do
 
             let sourceText = SourceText.From(template)
 
-            let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
+            let parsingOptions, _ =
+                checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
             let actualIndentation =
                 FSharpIndentationService.GetDesiredIndentation(
@@ -205,4 +208,5 @@ while true do
             match expectedIndentation with
             | None -> Assert.True(actualIndentation.IsNone, $"No indentation was expected at line {lineNumber}")
             | Some indentation ->
-                actualIndentation.Value |> Assert.shouldBeEqualWith indentation  $"Indentation on line {lineNumber} doesn't match"
+                actualIndentation.Value
+                |> Assert.shouldBeEqualWith indentation $"Indentation on line {lineNumber} doesn't match"
diff --git a/vsintegration/tests/FSharp.Editor.Tests/LanguageDebugInfoServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/LanguageDebugInfoServiceTests.fs
index 30a6c8ab79a..e24c4e93d30 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/LanguageDebugInfoServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/LanguageDebugInfoServiceTests.fs
@@ -44,7 +44,7 @@ let main argv =
         |]
 
     [<Theory>]
-    [<MemberData(nameof(LanguageDebugInfoServiceTests.testCases))>]
+    [<MemberData(nameof (LanguageDebugInfoServiceTests.testCases))>]
     member this.TestDebugInfo(searchToken: string, expectedDataTip: string option) =
         let searchPosition = code.IndexOf(searchToken)
         Assert.True(searchPosition >= 0, $"SearchToken '{searchToken}' is not found in code")
@@ -70,9 +70,6 @@ let main argv =
         | Some (actualDataTipSpan) ->
             let actualDataTipText = sourceText.GetSubText(actualDataTipSpan).ToString()
 
-            Assert.True(
-                expectedDataTip.IsSome,
-                $"LanguageDebugInfoService produced a data tip while it shouldn't at: {actualDataTipText}"
-            )
+            Assert.True(expectedDataTip.IsSome, $"LanguageDebugInfoService produced a data tip while it shouldn't at: {actualDataTipText}")
 
             Assert.Equal(expectedDataTip.Value, actualDataTipText)
diff --git a/vsintegration/tests/FSharp.Editor.Tests/QuickInfoProviderTests.fs b/vsintegration/tests/FSharp.Editor.Tests/QuickInfoProviderTests.fs
index ed7ed67d85e..f39c0a748d2 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/QuickInfoProviderTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/QuickInfoProviderTests.fs
@@ -197,93 +197,93 @@ let res8 = abs 5.0<kg>
                  Some
                      "(extension) System.Collections.Generic.IEnumerable.GroupBy<'TSource,'TKey>(keySelector: System.Func<'TSource,'TKey>) : System.Collections.Generic.IEnumerable<IGrouping<'TKey,'TSource>>
 'TSource is int * string
-'TKey is int");
+'TKey is int")
                 ("Sort",
                  Some
                      "System.Array.Sort<'T>(array: 'T array) : unit
-'T is int");
+'T is int")
                 ("let test4 x = C().FSharpGenericMethodExplitTypeParams",
                  Some
                      "member C.FSharpGenericMethodExplitTypeParams: a: 'T0 * y: 'T0 -> 'T0 * 'T0
-'T is 'a list");
+'T is 'a list")
                 ("let test5<'U> (x: 'U) = C().FSharpGenericMethodExplitTypeParams",
                  Some
                      "member C.FSharpGenericMethodExplitTypeParams: a: 'T0 * y: 'T0 -> 'T0 * 'T0
-'T is 'U list");
+'T is 'U list")
                 ("let test6 = C().FSharpGenericMethodExplitTypeParams",
                  Some
                      "member C.FSharpGenericMethodExplitTypeParams: a: 'T0 * y: 'T0 -> 'T0 * 'T0
-'T is int");
+'T is int")
                 ("let test7 x = C().FSharpGenericMethodInferredTypeParams",
                  Some
                      "member C.FSharpGenericMethodInferredTypeParams: a: 'a1 * y: 'b2 -> 'a1 * 'b2
 'a is 'a0 list
-'b is 'a0 list");
+'b is 'a0 list")
                 ("let test8 = C().FSharpGenericMethodInferredTypeParams",
                  Some
                      "member C.FSharpGenericMethodInferredTypeParams: a: 'a0 * y: 'b1 -> 'a0 * 'b1
 'a is int
-'b is int");
+'b is int")
                 ("let test9<'U> (x: 'U) = C().FSharpGenericMethodInferredTypeParams",
                  Some
                      "member C.FSharpGenericMethodInferredTypeParams: a: 'a0 * y: 'b1 -> 'a0 * 'b1
 'a is 'U list
-'b is 'U list");
+'b is 'U list")
                 ("let res3 = [1] |>",
                  Some
                      "val (|>) : arg: 'T1 -> func: ('T1 -> 'U) -> 'U
 Full name: Microsoft.FSharp.Core.Operators.(|>)
 'T1 is int list
-'U is int list");
+'U is int list")
                 ("let res3 = [1] |> List.map id",
                  Some
                      "val id: x: 'T -> 'T
 Full name: Microsoft.FSharp.Core.Operators.id
-'T is int");
+'T is int")
                 ("let res4 = (1.0,[1]) ||>",
                  Some
                      "val (||>) : arg1: 'T1 * arg2: 'T2 -> func: ('T1 -> 'T2 -> 'U) -> 'U
 Full name: Microsoft.FSharp.Core.Operators.(||>)
 'T1 is float
 'T2 is int list
-'U is float");
+'U is float")
                 ("let res4 = (1.0,[1]) ||> List.fold",
                  Some
                      "val fold: folder: ('State -> 'T -> 'State) -> state: 'State -> list: 'T list -> 'State
 Full name: Microsoft.FSharp.Collections.List.fold
 'T is int
-'State is float");
+'State is float")
                 ("let res4 = (1.0,[1]) ||> List.fold (fun s x -> string s +",
                  Some
                      "val (+) : x: 'T1 -> y: 'T2 -> 'T3 (requires member (+))
 Full name: Microsoft.FSharp.Core.Operators.(+)
 'T1 is string
 'T2 is string
-'T3 is float");
+'T3 is float")
                 ("let res5 = 1 +",
                  Some
                      "val (+) : x: 'T1 -> y: 'T2 -> 'T3 (requires member (+))
 Full name: Microsoft.FSharp.Core.Operators.(+)
 'T1 is int
 'T2 is int
-'T3 is int");
+'T3 is int")
                 ("let res6 = System.DateTime.Now +",
                  Some
                      "val (+) : x: 'T1 -> y: 'T2 -> 'T3 (requires member (+))
 Full name: Microsoft.FSharp.Core.Operators.(+)
 'T1 is System.DateTime
 'T2 is System.TimeSpan
-'T3 is System.DateTime");
+'T3 is System.DateTime")
                 ("let res7 = sin",
                  Some
                      "val sin: value: 'T -> 'T (requires member Sin)
 Full name: Microsoft.FSharp.Core.Operators.sin
-'T is float");
+'T is float")
                 ("let res8 = abs",
                  Some
                      "val abs: value: 'T -> 'T (requires member Abs)
 Full name: Microsoft.FSharp.Core.Operators.abs
-'T is int");
+'T is int")
             ]
 
         executeQuickInfoTest fileContents testCases
diff --git a/vsintegration/tests/FSharp.Editor.Tests/QuickInfoTests.fs b/vsintegration/tests/FSharp.Editor.Tests/QuickInfoTests.fs
index a68e1530847..e1d07740620 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/QuickInfoTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/QuickInfoTests.fs
@@ -26,7 +26,9 @@ module QuickInfo =
 
     let internal GetQuickInfo (code: string) caretPosition =
         async {
-            let document = RoslynTestHelpers.CreateSolution(code) |> RoslynTestHelpers.GetSingleDocument
+            let document =
+                RoslynTestHelpers.CreateSolution(code) |> RoslynTestHelpers.GetSingleDocument
+
             return! FSharpAsyncQuickInfoSource.ProvideQuickInfo(document, caretPosition)
         }
         |> Async.RunSynchronously
@@ -621,7 +623,7 @@ exception SomeError of ``thing wi$$th space``: string
             """
 type R = {| ``thing wi$$th space``: string |}
 """
-        
+
         let expected = "``thing with space``"
 
         let actual = GetQuickInfoTextFromCode code
diff --git a/vsintegration/tests/FSharp.Editor.Tests/SemanticClassificationServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/SemanticClassificationServiceTests.fs
index 47c6edac8dc..38a7490b552 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/SemanticClassificationServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/SemanticClassificationServiceTests.fs
@@ -14,9 +14,8 @@ open FSharp.Test
 type SemanticClassificationServiceTests() =
     let getRanges (source: string) : SemanticClassificationItem list =
         asyncMaybe {
-            let document = 
-                RoslynTestHelpers.CreateSolution(source)
-                |> RoslynTestHelpers.GetSingleDocument
+            let document =
+                RoslynTestHelpers.CreateSolution(source) |> RoslynTestHelpers.GetSingleDocument
 
             let! _, checkFileResults =
                 document.GetFSharpParseAndCheckResultsAsync("SemanticClassificationServiceTests")
@@ -41,8 +40,8 @@ type SemanticClassificationServiceTests() =
         match ranges |> List.tryFind (fun item -> Range.rangeContainsPos item.Range markerPos) with
         | None -> failwith "Cannot find colorization data for end of marker"
         | Some item ->
-            FSharpClassificationTypes.getClassificationTypeName item.Type |> Assert.shouldBeEqualWith classificationType
-                "Classification data doesn't match for end of marker"
+            FSharpClassificationTypes.getClassificationTypeName item.Type
+            |> Assert.shouldBeEqualWith classificationType "Classification data doesn't match for end of marker"
 
     let verifyNoClassificationDataAtEndOfMarker (fileContents: string, marker: string, classificationType: string) =
         let text = SourceText.From(fileContents)
diff --git a/vsintegration/tests/FSharp.Editor.Tests/SignatureHelpProviderTests.fs b/vsintegration/tests/FSharp.Editor.Tests/SignatureHelpProviderTests.fs
index abec8f8b142..a96c2374333 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/SignatureHelpProviderTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/SignatureHelpProviderTests.fs
@@ -23,7 +23,6 @@ module SignatureHelpProvider =
 
     let filePath = "C:\\test.fs"
 
-
     let GetSignatureHelp (project: FSharpProject) (fileName: string) (caretPosition: int) =
         async {
             let triggerChar = None
@@ -146,6 +145,7 @@ module SignatureHelpProvider =
         let caretPosition = fileContents.LastIndexOf(marker) + marker.Length
 
         let sourceText = SourceText.From(fileContents)
+
         let document =
             RoslynTestHelpers.CreateSolution(fileContents)
             |> RoslynTestHelpers.GetSingleDocument
@@ -371,7 +371,7 @@ let _ = System.DateTime(1L,
         assertSignatureHelpForMethodCalls fileContents marker (Some("[10..31)", 1, 2, None))
 
 #if RELEASE
-    [<Fact(Skip="Fails in some CI, reproduces locally in Release mode, needs investigation")>]
+    [<Fact(Skip = "Fails in some CI, reproduces locally in Release mode, needs investigation")>]
 #else
     [<Fact>]
 #endif
@@ -486,6 +486,7 @@ M.f
         let caretPosition = fileContents.IndexOf(marker) + marker.Length
 
         let sourceText = SourceText.From(fileContents)
+
         let document =
             RoslynTestHelpers.CreateSolution(fileContents)
             |> RoslynTestHelpers.GetSingleDocument
@@ -617,6 +618,6 @@ let f (derp: int -> int -> int) x = derp x
 
     </Projects>
     "
-        
+
         let expected = [| [| "System.Int32"; "System.Int32" |] |]
         Assert.Equal<string array array>(expected, completionNames)
diff --git a/vsintegration/tests/FSharp.Editor.Tests/SyntacticColorizationServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/SyntacticColorizationServiceTests.fs
index 7d988259d33..6fcb469ff89 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/SyntacticColorizationServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/SyntacticColorizationServiceTests.fs
@@ -51,8 +51,8 @@ type SyntacticClassificationServiceTests() =
         match tokens |> Seq.tryFind (fun token -> token.TextSpan.Contains(markerPosition)) with
         | None -> failwith "Cannot find colorization data for start of marker"
         | Some classifiedSpan ->
-            classifiedSpan.ClassificationType |> Assert.shouldBeEqualWith classificationType
-                "Classification data doesn't match for start of marker"
+            classifiedSpan.ClassificationType
+            |> Assert.shouldBeEqualWith classificationType "Classification data doesn't match for start of marker"
 
     member private this.VerifyColorizerAtEndOfMarker
         (
@@ -71,8 +71,8 @@ type SyntacticClassificationServiceTests() =
         with
         | None -> failwith "Cannot find colorization data for end of marker"
         | Some classifiedSpan ->
-            classifiedSpan.ClassificationType |> Assert.shouldBeEqualWith classificationType
-                "Classification data doesn't match for end of marker"
+            classifiedSpan.ClassificationType
+            |> Assert.shouldBeEqualWith classificationType "Classification data doesn't match for end of marker"
 
     [<Fact>]
     member this.Comment_SingleLine() =

From 393241b3640b18c1ad5fef83a8973d4af42e9937 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Fri, 10 Feb 2023 22:40:35 +0000
Subject: [PATCH 31/42] Revert unintended formatting changes

---
 .../BraceMatchingServiceTests.fs              | 14 +++-----
 .../BreakpointResolutionServiceTests.fs       |  6 ++--
 .../CompletionProviderTests.fs                |  8 ++---
 .../DocumentDiagnosticAnalyzerTests.fs        | 34 +++++--------------
 .../DocumentHighlightsServiceTests.fs         |  2 +-
 .../EditorFormattingServiceTests.fs           | 18 +++-------
 .../FsxCompletionProviderTests.fs             |  8 ++---
 .../GoToDefinitionServiceTests.fs             |  1 -
 .../HelpContextServiceTests.fs                | 17 ++++++----
 .../Helpers/RoslynHelpers.fs                  | 26 ++++++--------
 .../Hints/HintTestFramework.fs                | 16 +++------
 .../Hints/InlineParameterNameHintTests.fs     |  2 +-
 .../Hints/InlineTypeHintTests.fs              | 18 +++-------
 .../IndentationServiceTests.fs                | 12 +++----
 .../LanguageDebugInfoServiceTests.fs          |  7 ++--
 .../QuickInfoProviderTests.fs                 | 34 +++++++++----------
 .../FSharp.Editor.Tests/QuickInfoTests.fs     |  6 ++--
 .../SemanticClassificationServiceTests.fs     |  9 ++---
 .../SignatureHelpProviderTests.fs             |  7 ++--
 .../SyntacticColorizationServiceTests.fs      |  8 ++---
 20 files changed, 97 insertions(+), 156 deletions(-)

diff --git a/vsintegration/tests/FSharp.Editor.Tests/BraceMatchingServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/BraceMatchingServiceTests.fs
index 9e8bce2aba3..a5278a27c02 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/BraceMatchingServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/BraceMatchingServiceTests.fs
@@ -19,15 +19,14 @@ type BraceMatchingServiceTests() =
         let position = fileContents.IndexOf(marker)
         Assert.True(position >= 0, $"Cannot find marker '{marker}' in file contents")
 
-        let parsingOptions, _ =
-            checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
+        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
         match
             FSharpBraceMatchingService.GetBraceMatchingResult(checker, sourceText, fileName, parsingOptions, position, "UnitTest")
             |> Async.RunImmediateExceptOnUI
         with
         | None -> ()
-        | Some (left, right) -> failwith $"Found match for brace '{marker}'"
+        | Some (left, right) ->  failwith $"Found match for brace '{marker}'"
 
     member private this.VerifyBraceMatch(fileContents: string, startMarker: string, endMarker: string) =
         let sourceText = SourceText.From(fileContents)
@@ -37,8 +36,7 @@ type BraceMatchingServiceTests() =
         Assert.True(startMarkerPosition >= 0, $"Cannot find start marker '{startMarkerPosition}' in file contents")
         Assert.True(endMarkerPosition >= 0, $"Cannot find end marker '{endMarkerPosition}' in file contents")
 
-        let parsingOptions, _ =
-            checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
+        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
         match
             FSharpBraceMatchingService.GetBraceMatchingResult(
@@ -204,9 +202,7 @@ let main argv =
     [<InlineData("let a8 = seq { yield() }", 13, 23)>]
     member this.DoNotMatchOnInnerSide(fileContents: string, [<ParamArray>] matchingPositions: int[]) =
         let sourceText = SourceText.From(fileContents)
-
-        let parsingOptions, _ =
-            checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
+        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
         for position in matchingPositions do
             match
@@ -219,4 +215,4 @@ let main argv =
                 | 0 -> ""
                 | _ -> fileContents.[position - 1] |> sprintf " (previous character '%c')"
                 |> sprintf "Didn't find a matching brace at position '%d' %s" position
-                |> raise (exn ())
+                |> raise (exn())
diff --git a/vsintegration/tests/FSharp.Editor.Tests/BreakpointResolutionServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/BreakpointResolutionServiceTests.fs
index 7322e981aba..548991e3d5f 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/BreakpointResolutionServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/BreakpointResolutionServiceTests.fs
@@ -45,15 +45,15 @@ let main argv =
         |]
 
     [<Theory>]
-    [<MemberData(nameof (BreakpointResolutionServiceTests.testCases))>]
+    [<MemberData(nameof(BreakpointResolutionServiceTests.testCases))>]
     member this.TestBreakpointResolution(searchToken: string, expectedResolution: string option) =
         let searchPosition = code.IndexOf(searchToken)
         Assert.True(searchPosition >= 0, $"SearchToken '{searchToken}' is not found in code")
 
         let sourceText = SourceText.From(code)
-
         let document =
-            RoslynTestHelpers.CreateSolution(code) |> RoslynTestHelpers.GetSingleDocument
+            RoslynTestHelpers.CreateSolution(code)
+            |> RoslynTestHelpers.GetSingleDocument
 
         let searchSpan =
             TextSpan.FromBounds(searchPosition, searchPosition + searchToken.Length)
diff --git a/vsintegration/tests/FSharp.Editor.Tests/CompletionProviderTests.fs b/vsintegration/tests/FSharp.Editor.Tests/CompletionProviderTests.fs
index aa122deca01..2be760394f9 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/CompletionProviderTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/CompletionProviderTests.fs
@@ -141,9 +141,7 @@ System.Console.WriteLine(x + y)
                     IntelliSenseOptions.Default
                 )
 
-            triggered
-            |> Assert.shouldBeEqualWith
-                shouldBeTriggered
+            triggered |> Assert.shouldBeEqualWith shouldBeTriggered 
                 "FSharpCompletionProvider.ShouldTriggerCompletionAux() should compute the correct result"
 
     [<Fact>]
@@ -244,9 +242,7 @@ let z = $"abc  {System.Console.WriteLine(x + y)} def"
                     IntelliSenseOptions.Default
                 )
 
-            triggered
-            |> Assert.shouldBeEqualWith
-                shouldBeTriggered
+            triggered |> Assert.shouldBeEqualWith shouldBeTriggered 
                 $"FSharpCompletionProvider.ShouldTriggerCompletionAux() should compute the correct result for marker '{marker}"
 
     [<Fact>]
diff --git a/vsintegration/tests/FSharp.Editor.Tests/DocumentDiagnosticAnalyzerTests.fs b/vsintegration/tests/FSharp.Editor.Tests/DocumentDiagnosticAnalyzerTests.fs
index f5a3bd134fe..51fdf2be248 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/DocumentDiagnosticAnalyzerTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/DocumentDiagnosticAnalyzerTests.fs
@@ -36,25 +36,17 @@ type DocumentDiagnosticAnalyzerTests() =
             |> Seq.filter (fun e -> e.Severity = DiagnosticSeverity.Error)
             |> Seq.toArray
 
-        errors.Length
-        |> Assert.shouldBeEqualWith 1 "There should be exactly one error generated"
-
+        errors.Length |> Assert.shouldBeEqualWith 1 "There should be exactly one error generated"
         let actualError = errors.[0]
 
         if expectedMessage.IsSome then
-            actualError.GetMessage()
-            |> Assert.shouldBeEqualWith expectedMessage.Value "Error messages should match"
+            actualError.GetMessage() |> Assert.shouldBeEqualWith expectedMessage.Value "Error messages should match"
 
         Assert.Equal(DiagnosticSeverity.Error, actualError.Severity)
         let expectedStart = fileContents.IndexOf(expectedMarker)
-
-        actualError.Location.SourceSpan.Start
-        |> Assert.shouldBeEqualWith expectedStart "Error start positions should match"
-
+        actualError.Location.SourceSpan.Start |> Assert.shouldBeEqualWith expectedStart "Error start positions should match"
         let expectedEnd = expectedStart + expectedMarker.Length
-
-        actualError.Location.SourceSpan.End
-        |> Assert.shouldBeEqualWith expectedEnd "Error end positions should match"
+        actualError.Location.SourceSpan.End |> Assert.shouldBeEqualWith expectedEnd "Error end positions should match"
 
     member private this.VerifyDiagnosticBetweenMarkers
         (
@@ -67,24 +59,14 @@ type DocumentDiagnosticAnalyzerTests() =
             |> Seq.filter (fun e -> e.Severity = expectedSeverity)
             |> Seq.toArray
 
-        errors.Length
-        |> Assert.shouldBeEqualWith 1 "There should be exactly one error generated"
-
+        errors.Length |> Assert.shouldBeEqualWith 1 "There should be exactly one error generated"
         let actualError = errors.[0]
         Assert.Equal(expectedSeverity, actualError.Severity)
-
-        actualError.GetMessage()
-        |> Assert.shouldBeEqualWith expectedMessage "Error messages should match"
-
+        actualError.GetMessage() |> Assert.shouldBeEqualWith expectedMessage "Error messages should match"
         let expectedStart = fileContents.IndexOf(startMarker) + startMarker.Length
-
-        actualError.Location.SourceSpan.Start
-        |> Assert.shouldBeEqualWith expectedStart "Error start positions should match"
-
+        actualError.Location.SourceSpan.Start |> Assert.shouldBeEqualWith expectedStart "Error start positions should match"
         let expectedEnd = fileContents.IndexOf(endMarker)
-
-        actualError.Location.SourceSpan.End
-        |> Assert.shouldBeEqualWith expectedEnd "Error end positions should match"
+        actualError.Location.SourceSpan.End |> Assert.shouldBeEqualWith expectedEnd "Error end positions should match"
 
     member private this.VerifyErrorBetweenMarkers(fileContents: string, expectedMessage: string) =
         this.VerifyDiagnosticBetweenMarkers(fileContents, expectedMessage, DiagnosticSeverity.Error)
diff --git a/vsintegration/tests/FSharp.Editor.Tests/DocumentHighlightsServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/DocumentHighlightsServiceTests.fs
index 08a61bfcd9c..f590c76df1b 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/DocumentHighlightsServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/DocumentHighlightsServiceTests.fs
@@ -15,7 +15,7 @@ module DocumentHighlightsServiceTests =
     let filePath = "C:\\test.fs"
 
     let private getSpans (fileContents: string) (caretPosition: int) =
-        let document =
+        let document = 
             RoslynTestHelpers.CreateSolution(fileContents)
             |> RoslynTestHelpers.GetSingleDocument
 
diff --git a/vsintegration/tests/FSharp.Editor.Tests/EditorFormattingServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/EditorFormattingServiceTests.fs
index 12d0369a4b2..2e917447cdf 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/EditorFormattingServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/EditorFormattingServiceTests.fs
@@ -66,8 +66,7 @@ marker4"""
         let lineNumber =
             sourceText.Lines |> Seq.findIndex (fun line -> line.Span.Contains position)
 
-        let parsingOptions, _ =
-            checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
+        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
         let changesOpt =
             FSharpEditorFormattingService.GetFormattingChanges(
@@ -94,9 +93,7 @@ marker4"""
     [<InlineData(false, "")>]
     member this.TestPasteChanges_PastingOntoIndentedLine(enabled: bool, prefix: string) =
         let checker = FSharpChecker.Create()
-
-        let parsingOptions, _ =
-            checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
+        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
         let clipboard =
             prefix
@@ -152,17 +149,14 @@ somethingElseHere
                 Assert.Equal(expected, changedText)
             | _ -> failwithf "Expected text changes, but got %+A" changesOpt
         else
-            changesOpt
-            |> Assert.shouldBeEqualWith None "Expected no changes as FormatOnPaste is disabled"
+            changesOpt |> Assert.shouldBeEqualWith None "Expected no changes as FormatOnPaste is disabled"
 
     [<Theory>]
     [<InlineData "">]
     [<InlineData "        ">]
     member this.TestPasteChanges_PastingOntoEmptyLine(prefix: string) =
         let checker = FSharpChecker.Create()
-
-        let parsingOptions, _ =
-            checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
+        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
         let clipboard =
             prefix
@@ -220,9 +214,7 @@ somethingElseHere
     [<Fact>]
     member this.TestPasteChanges_PastingWithAutoIndentationInPasteSpan() =
         let checker = FSharpChecker.Create()
-
-        let parsingOptions, _ =
-            checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
+        let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
         let clipboard =
             """[<Class>]
diff --git a/vsintegration/tests/FSharp.Editor.Tests/FsxCompletionProviderTests.fs b/vsintegration/tests/FSharp.Editor.Tests/FsxCompletionProviderTests.fs
index 48276422bdd..1cbe5025735 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/FsxCompletionProviderTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/FsxCompletionProviderTests.fs
@@ -17,11 +17,7 @@ type Worker() =
     member _.VerifyCompletionListExactly(fileContents: string, marker: string, expected: List<string>) =
         let caretPosition = fileContents.IndexOf(marker) + marker.Length
 
-        let options =
-            { RoslynTestHelpers.DefaultProjectOptions with
-                SourceFiles = [| filePath |]
-            }
-
+        let options = { RoslynTestHelpers.DefaultProjectOptions with SourceFiles = [|filePath|] }
         let document =
             RoslynTestHelpers.CreateSolution(fileContents, options = options)
             |> RoslynTestHelpers.GetSingleDocument
@@ -53,7 +49,7 @@ module FsxCompletionProviderTests =
     let getWorker () = Worker()
 
 #if RELEASE
-    [<Fact(Skip = "Fails in some CI, reproduces locally in Release mode, needs investigation")>]
+    [<Fact(Skip="Fails in some CI, reproduces locally in Release mode, needs investigation")>]
 #else
     [<Fact>]
 #endif
diff --git a/vsintegration/tests/FSharp.Editor.Tests/GoToDefinitionServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/GoToDefinitionServiceTests.fs
index 87abb259e0d..f4f534743a1 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/GoToDefinitionServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/GoToDefinitionServiceTests.fs
@@ -55,7 +55,6 @@ module GoToDefinitionServiceTests =
         let caretPosition = fileContents.IndexOf(caretMarker) + caretMarker.Length - 1 // inside the marker
 
         let sourceText = SourceText.From(fileContents)
-
         let document =
             RoslynTestHelpers.CreateSolution(fileContents)
             |> RoslynTestHelpers.GetSingleDocument
diff --git a/vsintegration/tests/FSharp.Editor.Tests/HelpContextServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/HelpContextServiceTests.fs
index c48506c78b3..4f93b1e0ef7 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/HelpContextServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/HelpContextServiceTests.fs
@@ -27,7 +27,6 @@ type HelpContextServiceTests() =
         let fileContents = fileContentsWithMarkers.Replace("$", "")
 
         let sourceText = SourceText.From(fileContents)
-
         let document =
             RoslynTestHelpers.CreateSolution(fileContents)
             |> RoslynTestHelpers.GetSingleDocument
@@ -58,7 +57,7 @@ type HelpContextServiceTests() =
         TestF1KeywordsWithOptions(expectedKeywords, lines)
 
 #if RELEASE
-    [<Fact(Skip = "Fails in some CI, reproduces locally in Release mode, needs investigation")>]
+    [<Fact(Skip="Fails in some CI, reproduces locally in Release mode, needs investigation")>]
 #else
     [<Fact>]
 #endif
@@ -210,7 +209,7 @@ type HelpContextServiceTests() =
         TestF1Keywords(keywords, file)
 
 #if RELEASE
-    [<Fact(Skip = "Fails in some CI, reproduces locally in Release mode, needs investigation")>]
+    [<Fact(Skip="Fails in some CI, reproduces locally in Release mode, needs investigation")>]
 #else
     [<Fact>]
 #endif
@@ -219,10 +218,13 @@ type HelpContextServiceTests() =
         let file = [ "open N$1" ]
         let keywords = [ Some "N1" ]
 
-        TestF1KeywordsWithOptions(keywords, file)
+        TestF1KeywordsWithOptions(
+            keywords,
+            file
+        )
 
 #if RELEASE
-    [<Fact(Skip = "Fails in some CI, reproduces locally in Release mode, needs investigation")>]
+    [<Fact(Skip="Fails in some CI, reproduces locally in Release mode, needs investigation")>]
 #else
     [<Fact>]
 #endif
@@ -237,7 +239,10 @@ type HelpContextServiceTests() =
 
         let keywords = [ Some "N1.T" ]
 
-        TestF1KeywordsWithOptions(keywords, file)
+        TestF1KeywordsWithOptions(
+            keywords,
+            file
+        )
 
     [<Fact>]
     member _.``F1 help keyword EndOfLine``() =
diff --git a/vsintegration/tests/FSharp.Editor.Tests/Helpers/RoslynHelpers.fs b/vsintegration/tests/FSharp.Editor.Tests/Helpers/RoslynHelpers.fs
index 9efa3ecc055..331a812ddd7 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/Helpers/RoslynHelpers.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/Helpers/RoslynHelpers.fs
@@ -219,9 +219,8 @@ type RoslynTestHelpers private () =
             Stamp = None
         }
 
-    static member private GetSourceCodeKind filePath =
+    static member private GetSourceCodeKind filePath = 
         let extension = Path.GetExtension(filePath)
-
         match extension with
         | ".fsx" -> SourceCodeKind.Script
         | ".fsi" -> SourceCodeKind.Regular
@@ -233,7 +232,7 @@ type RoslynTestHelpers private () =
         let id = SolutionId.CreateNewId()
         let versionStamp = VersionStamp.Create(DateTime.UtcNow)
         let slnPath = "test.sln"
-
+ 
         let solutionInfo = SolutionInfo.Create(id, versionStamp, slnPath, projects)
         let solution = workspace.AddSolution(solutionInfo)
         solution
@@ -244,8 +243,7 @@ type RoslynTestHelpers private () =
             filePath,
             loader = TextLoader.From(SourceText.From(code).Container, VersionStamp.Create(DateTime.UtcNow)),
             filePath = filePath,
-            sourceCodeKind = RoslynTestHelpers.GetSourceCodeKind filePath
-        )
+            sourceCodeKind = RoslynTestHelpers.GetSourceCodeKind filePath)
 
     static member CreateProjectInfo id filePath documents =
         ProjectInfo.Create(
@@ -255,10 +253,9 @@ type RoslynTestHelpers private () =
             "test.dll",
             LanguageNames.FSharp,
             documents = documents,
-            filePath = filePath
-        )
+            filePath = filePath)
 
-    static member SetProjectOptions projId (solution: Solution) (options: FSharpProjectOptions) =
+    static member SetProjectOptions projId (solution: Solution) (options: FSharpProjectOptions)  = 
         solution
             .Workspace
             .Services
@@ -267,19 +264,18 @@ type RoslynTestHelpers private () =
             .SetCommandLineOptions(
                 projId,
                 options.SourceFiles,
-                options.OtherOptions |> ImmutableArray.CreateRange
-            )
+                options.OtherOptions |> ImmutableArray.CreateRange)
 
-    static member CreateSolution(source, ?options: FSharpProjectOptions) =
+    static member CreateSolution (source, ?options: FSharpProjectOptions) =
         let projId = ProjectId.CreateNewId()
 
         let docInfo = RoslynTestHelpers.CreateDocumentInfo projId "C:\\test.fs" source
 
         let projFilePath = "C:\\test.fsproj"
-        let projInfo = RoslynTestHelpers.CreateProjectInfo projId projFilePath [ docInfo ]
-        let solution = RoslynTestHelpers.CreateSolution [ projInfo ]
+        let projInfo = RoslynTestHelpers.CreateProjectInfo projId projFilePath [docInfo]
+        let solution = RoslynTestHelpers.CreateSolution [projInfo]
 
-        options
+        options 
         |> Option.defaultValue RoslynTestHelpers.DefaultProjectOptions
         |> RoslynTestHelpers.SetProjectOptions projId solution
 
@@ -288,4 +284,4 @@ type RoslynTestHelpers private () =
     static member GetSingleDocument(solution: Solution) =
         let project = solution.Projects |> Seq.exactlyOne
         let document = project.Documents |> Seq.exactlyOne
-        document
+        document
\ No newline at end of file
diff --git a/vsintegration/tests/FSharp.Editor.Tests/Hints/HintTestFramework.fs b/vsintegration/tests/FSharp.Editor.Tests/Hints/HintTestFramework.fs
index 70f06bb0940..7f9a8be3cbf 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/Hints/HintTestFramework.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/Hints/HintTestFramework.fs
@@ -30,11 +30,7 @@ module HintTestFramework =
 
     let getFsDocument code =
         // I don't know, without this lib some symbols are just not loaded
-        let options =
-            { RoslynTestHelpers.DefaultProjectOptions with
-                OtherOptions = [| "--targetprofile:netcore" |]
-            }
-
+        let options = { RoslynTestHelpers.DefaultProjectOptions with OtherOptions = [| "--targetprofile:netcore" |] }
         RoslynTestHelpers.CreateSolution(code, options = options)
         |> RoslynTestHelpers.GetSingleDocument
 
@@ -42,15 +38,11 @@ module HintTestFramework =
         let projectId = ProjectId.CreateNewId()
         let projFilePath = "C:\\test.fsproj"
 
-        let fsiDocInfo =
-            RoslynTestHelpers.CreateDocumentInfo projectId "C:\\test.fsi" fsiCode
-
+        let fsiDocInfo = RoslynTestHelpers.CreateDocumentInfo projectId "C:\\test.fsi" fsiCode
         let fsDocInfo = RoslynTestHelpers.CreateDocumentInfo projectId "C:\\test.fs" fsCode
 
-        let projInfo =
-            RoslynTestHelpers.CreateProjectInfo projectId projFilePath [ fsiDocInfo; fsDocInfo ]
-
-        let solution = RoslynTestHelpers.CreateSolution [ projInfo ]
+        let projInfo = RoslynTestHelpers.CreateProjectInfo projectId projFilePath [fsiDocInfo; fsDocInfo]
+        let solution = RoslynTestHelpers.CreateSolution [projInfo]
         let project = solution.Projects |> Seq.exactlyOne
         project.Documents
 
diff --git a/vsintegration/tests/FSharp.Editor.Tests/Hints/InlineParameterNameHintTests.fs b/vsintegration/tests/FSharp.Editor.Tests/Hints/InlineParameterNameHintTests.fs
index 7a44467afcf..d9da400e4ad 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/Hints/InlineParameterNameHintTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/Hints/InlineParameterNameHintTests.fs
@@ -448,7 +448,7 @@ type MyType() =
         let actual = getParameterNameHints document
 
         Assert.Empty(actual)
-
+        
     [<Fact>]
     let ``Hints are shown correctly for inner bindings`` () =
         let code =
diff --git a/vsintegration/tests/FSharp.Editor.Tests/Hints/InlineTypeHintTests.fs b/vsintegration/tests/FSharp.Editor.Tests/Hints/InlineTypeHintTests.fs
index d995223fbd3..a8219a3c53a 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/Hints/InlineTypeHintTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/Hints/InlineTypeHintTests.fs
@@ -204,7 +204,6 @@ let func = fun () -> 3
             """
 let x
 """
-
         let document = getFsDocument code
 
         let result = getTypeHints document
@@ -212,12 +211,11 @@ let x
         Assert.Empty(result)
 
     [<Fact>]
-    let ``Hints are not shown for unsolved types in _for_ expressions in collections`` () =
+    let ``Hints are not shown for unsolved types in _for_ expressions in collections`` () = 
         let code =
             """
 let _ = [ for x ]
 """
-
         let document = getFsDocument code
 
         let result = getTypeHints document
@@ -225,7 +223,7 @@ let _ = [ for x ]
         Assert.Empty(result)
 
     [<Fact>]
-    let ``Hints are not shown for unsolved types in _for_ expressions within computational expressions`` () =
+    let ``Hints are not shown for unsolved types in _for_ expressions within computational expressions`` () = 
         let code =
             """
 do task {
@@ -234,7 +232,6 @@ do task {
     do! Task.Delay 0
     }
 """
-
         let document = getFsDocument code
 
         let result = getTypeHints document
@@ -253,19 +250,12 @@ type Number<'T when IAddition<'T>>(value: 'T) =
     interface IAddition<Number<'T>> with
         static member op_Addition(a, b) = Number(a.Value + b.Value)
 """
-
         let document = getFsDocument code
 
         let expected =
             [
-                {
-                    Content = ": Number<'T>"
-                    Location = (7, 36)
-                }
-                {
-                    Content = ": Number<'T>"
-                    Location = (7, 39)
-                }
+                { Content = ": Number<'T>"; Location = (7, 36) }
+                { Content = ": Number<'T>"; Location = (7, 39) }
             ]
 
         let actual = getTypeHints document
diff --git a/vsintegration/tests/FSharp.Editor.Tests/IndentationServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/IndentationServiceTests.fs
index 81f2bfc7f09..3ef331544c3 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/IndentationServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/IndentationServiceTests.fs
@@ -165,8 +165,7 @@ while true do
         for (expectedIndentation, lineNumber, template) in testCases do
             let sourceText = SourceText.From(template)
 
-            let parsingOptions, _ =
-                checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
+            let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
             let actualIndentation =
                 FSharpIndentationService.GetDesiredIndentation(
@@ -182,8 +181,7 @@ while true do
             match expectedIndentation with
             | None -> Assert.True(actualIndentation.IsNone, $"No indentation was expected at line {lineNumber}")
             | Some indentation ->
-                actualIndentation.Value
-                |> Assert.shouldBeEqualWith indentation $"Indentation on line {lineNumber} doesn't match"
+                actualIndentation.Value |> Assert.shouldBeEqualWith indentation  $"Indentation on line {lineNumber} doesn't match"
 
     [<Fact>]
     member this.TestAutoIndentation() =
@@ -191,8 +189,7 @@ while true do
 
             let sourceText = SourceText.From(template)
 
-            let parsingOptions, _ =
-                checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
+            let parsingOptions, _ = checker.GetParsingOptionsFromProjectOptions RoslynTestHelpers.DefaultProjectOptions
 
             let actualIndentation =
                 FSharpIndentationService.GetDesiredIndentation(
@@ -208,5 +205,4 @@ while true do
             match expectedIndentation with
             | None -> Assert.True(actualIndentation.IsNone, $"No indentation was expected at line {lineNumber}")
             | Some indentation ->
-                actualIndentation.Value
-                |> Assert.shouldBeEqualWith indentation $"Indentation on line {lineNumber} doesn't match"
+                actualIndentation.Value |> Assert.shouldBeEqualWith indentation  $"Indentation on line {lineNumber} doesn't match"
diff --git a/vsintegration/tests/FSharp.Editor.Tests/LanguageDebugInfoServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/LanguageDebugInfoServiceTests.fs
index e24c4e93d30..30a6c8ab79a 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/LanguageDebugInfoServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/LanguageDebugInfoServiceTests.fs
@@ -44,7 +44,7 @@ let main argv =
         |]
 
     [<Theory>]
-    [<MemberData(nameof (LanguageDebugInfoServiceTests.testCases))>]
+    [<MemberData(nameof(LanguageDebugInfoServiceTests.testCases))>]
     member this.TestDebugInfo(searchToken: string, expectedDataTip: string option) =
         let searchPosition = code.IndexOf(searchToken)
         Assert.True(searchPosition >= 0, $"SearchToken '{searchToken}' is not found in code")
@@ -70,6 +70,9 @@ let main argv =
         | Some (actualDataTipSpan) ->
             let actualDataTipText = sourceText.GetSubText(actualDataTipSpan).ToString()
 
-            Assert.True(expectedDataTip.IsSome, $"LanguageDebugInfoService produced a data tip while it shouldn't at: {actualDataTipText}")
+            Assert.True(
+                expectedDataTip.IsSome,
+                $"LanguageDebugInfoService produced a data tip while it shouldn't at: {actualDataTipText}"
+            )
 
             Assert.Equal(expectedDataTip.Value, actualDataTipText)
diff --git a/vsintegration/tests/FSharp.Editor.Tests/QuickInfoProviderTests.fs b/vsintegration/tests/FSharp.Editor.Tests/QuickInfoProviderTests.fs
index f39c0a748d2..ed7ed67d85e 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/QuickInfoProviderTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/QuickInfoProviderTests.fs
@@ -197,93 +197,93 @@ let res8 = abs 5.0<kg>
                  Some
                      "(extension) System.Collections.Generic.IEnumerable.GroupBy<'TSource,'TKey>(keySelector: System.Func<'TSource,'TKey>) : System.Collections.Generic.IEnumerable<IGrouping<'TKey,'TSource>>
 'TSource is int * string
-'TKey is int")
+'TKey is int");
                 ("Sort",
                  Some
                      "System.Array.Sort<'T>(array: 'T array) : unit
-'T is int")
+'T is int");
                 ("let test4 x = C().FSharpGenericMethodExplitTypeParams",
                  Some
                      "member C.FSharpGenericMethodExplitTypeParams: a: 'T0 * y: 'T0 -> 'T0 * 'T0
-'T is 'a list")
+'T is 'a list");
                 ("let test5<'U> (x: 'U) = C().FSharpGenericMethodExplitTypeParams",
                  Some
                      "member C.FSharpGenericMethodExplitTypeParams: a: 'T0 * y: 'T0 -> 'T0 * 'T0
-'T is 'U list")
+'T is 'U list");
                 ("let test6 = C().FSharpGenericMethodExplitTypeParams",
                  Some
                      "member C.FSharpGenericMethodExplitTypeParams: a: 'T0 * y: 'T0 -> 'T0 * 'T0
-'T is int")
+'T is int");
                 ("let test7 x = C().FSharpGenericMethodInferredTypeParams",
                  Some
                      "member C.FSharpGenericMethodInferredTypeParams: a: 'a1 * y: 'b2 -> 'a1 * 'b2
 'a is 'a0 list
-'b is 'a0 list")
+'b is 'a0 list");
                 ("let test8 = C().FSharpGenericMethodInferredTypeParams",
                  Some
                      "member C.FSharpGenericMethodInferredTypeParams: a: 'a0 * y: 'b1 -> 'a0 * 'b1
 'a is int
-'b is int")
+'b is int");
                 ("let test9<'U> (x: 'U) = C().FSharpGenericMethodInferredTypeParams",
                  Some
                      "member C.FSharpGenericMethodInferredTypeParams: a: 'a0 * y: 'b1 -> 'a0 * 'b1
 'a is 'U list
-'b is 'U list")
+'b is 'U list");
                 ("let res3 = [1] |>",
                  Some
                      "val (|>) : arg: 'T1 -> func: ('T1 -> 'U) -> 'U
 Full name: Microsoft.FSharp.Core.Operators.(|>)
 'T1 is int list
-'U is int list")
+'U is int list");
                 ("let res3 = [1] |> List.map id",
                  Some
                      "val id: x: 'T -> 'T
 Full name: Microsoft.FSharp.Core.Operators.id
-'T is int")
+'T is int");
                 ("let res4 = (1.0,[1]) ||>",
                  Some
                      "val (||>) : arg1: 'T1 * arg2: 'T2 -> func: ('T1 -> 'T2 -> 'U) -> 'U
 Full name: Microsoft.FSharp.Core.Operators.(||>)
 'T1 is float
 'T2 is int list
-'U is float")
+'U is float");
                 ("let res4 = (1.0,[1]) ||> List.fold",
                  Some
                      "val fold: folder: ('State -> 'T -> 'State) -> state: 'State -> list: 'T list -> 'State
 Full name: Microsoft.FSharp.Collections.List.fold
 'T is int
-'State is float")
+'State is float");
                 ("let res4 = (1.0,[1]) ||> List.fold (fun s x -> string s +",
                  Some
                      "val (+) : x: 'T1 -> y: 'T2 -> 'T3 (requires member (+))
 Full name: Microsoft.FSharp.Core.Operators.(+)
 'T1 is string
 'T2 is string
-'T3 is float")
+'T3 is float");
                 ("let res5 = 1 +",
                  Some
                      "val (+) : x: 'T1 -> y: 'T2 -> 'T3 (requires member (+))
 Full name: Microsoft.FSharp.Core.Operators.(+)
 'T1 is int
 'T2 is int
-'T3 is int")
+'T3 is int");
                 ("let res6 = System.DateTime.Now +",
                  Some
                      "val (+) : x: 'T1 -> y: 'T2 -> 'T3 (requires member (+))
 Full name: Microsoft.FSharp.Core.Operators.(+)
 'T1 is System.DateTime
 'T2 is System.TimeSpan
-'T3 is System.DateTime")
+'T3 is System.DateTime");
                 ("let res7 = sin",
                  Some
                      "val sin: value: 'T -> 'T (requires member Sin)
 Full name: Microsoft.FSharp.Core.Operators.sin
-'T is float")
+'T is float");
                 ("let res8 = abs",
                  Some
                      "val abs: value: 'T -> 'T (requires member Abs)
 Full name: Microsoft.FSharp.Core.Operators.abs
-'T is int")
+'T is int");
             ]
 
         executeQuickInfoTest fileContents testCases
diff --git a/vsintegration/tests/FSharp.Editor.Tests/QuickInfoTests.fs b/vsintegration/tests/FSharp.Editor.Tests/QuickInfoTests.fs
index e1d07740620..a68e1530847 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/QuickInfoTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/QuickInfoTests.fs
@@ -26,9 +26,7 @@ module QuickInfo =
 
     let internal GetQuickInfo (code: string) caretPosition =
         async {
-            let document =
-                RoslynTestHelpers.CreateSolution(code) |> RoslynTestHelpers.GetSingleDocument
-
+            let document = RoslynTestHelpers.CreateSolution(code) |> RoslynTestHelpers.GetSingleDocument
             return! FSharpAsyncQuickInfoSource.ProvideQuickInfo(document, caretPosition)
         }
         |> Async.RunSynchronously
@@ -623,7 +621,7 @@ exception SomeError of ``thing wi$$th space``: string
             """
 type R = {| ``thing wi$$th space``: string |}
 """
-
+        
         let expected = "``thing with space``"
 
         let actual = GetQuickInfoTextFromCode code
diff --git a/vsintegration/tests/FSharp.Editor.Tests/SemanticClassificationServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/SemanticClassificationServiceTests.fs
index 38a7490b552..47c6edac8dc 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/SemanticClassificationServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/SemanticClassificationServiceTests.fs
@@ -14,8 +14,9 @@ open FSharp.Test
 type SemanticClassificationServiceTests() =
     let getRanges (source: string) : SemanticClassificationItem list =
         asyncMaybe {
-            let document =
-                RoslynTestHelpers.CreateSolution(source) |> RoslynTestHelpers.GetSingleDocument
+            let document = 
+                RoslynTestHelpers.CreateSolution(source)
+                |> RoslynTestHelpers.GetSingleDocument
 
             let! _, checkFileResults =
                 document.GetFSharpParseAndCheckResultsAsync("SemanticClassificationServiceTests")
@@ -40,8 +41,8 @@ type SemanticClassificationServiceTests() =
         match ranges |> List.tryFind (fun item -> Range.rangeContainsPos item.Range markerPos) with
         | None -> failwith "Cannot find colorization data for end of marker"
         | Some item ->
-            FSharpClassificationTypes.getClassificationTypeName item.Type
-            |> Assert.shouldBeEqualWith classificationType "Classification data doesn't match for end of marker"
+            FSharpClassificationTypes.getClassificationTypeName item.Type |> Assert.shouldBeEqualWith classificationType
+                "Classification data doesn't match for end of marker"
 
     let verifyNoClassificationDataAtEndOfMarker (fileContents: string, marker: string, classificationType: string) =
         let text = SourceText.From(fileContents)
diff --git a/vsintegration/tests/FSharp.Editor.Tests/SignatureHelpProviderTests.fs b/vsintegration/tests/FSharp.Editor.Tests/SignatureHelpProviderTests.fs
index a96c2374333..abec8f8b142 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/SignatureHelpProviderTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/SignatureHelpProviderTests.fs
@@ -23,6 +23,7 @@ module SignatureHelpProvider =
 
     let filePath = "C:\\test.fs"
 
+
     let GetSignatureHelp (project: FSharpProject) (fileName: string) (caretPosition: int) =
         async {
             let triggerChar = None
@@ -145,7 +146,6 @@ module SignatureHelpProvider =
         let caretPosition = fileContents.LastIndexOf(marker) + marker.Length
 
         let sourceText = SourceText.From(fileContents)
-
         let document =
             RoslynTestHelpers.CreateSolution(fileContents)
             |> RoslynTestHelpers.GetSingleDocument
@@ -371,7 +371,7 @@ let _ = System.DateTime(1L,
         assertSignatureHelpForMethodCalls fileContents marker (Some("[10..31)", 1, 2, None))
 
 #if RELEASE
-    [<Fact(Skip = "Fails in some CI, reproduces locally in Release mode, needs investigation")>]
+    [<Fact(Skip="Fails in some CI, reproduces locally in Release mode, needs investigation")>]
 #else
     [<Fact>]
 #endif
@@ -486,7 +486,6 @@ M.f
         let caretPosition = fileContents.IndexOf(marker) + marker.Length
 
         let sourceText = SourceText.From(fileContents)
-
         let document =
             RoslynTestHelpers.CreateSolution(fileContents)
             |> RoslynTestHelpers.GetSingleDocument
@@ -618,6 +617,6 @@ let f (derp: int -> int -> int) x = derp x
 
     </Projects>
     "
-
+        
         let expected = [| [| "System.Int32"; "System.Int32" |] |]
         Assert.Equal<string array array>(expected, completionNames)
diff --git a/vsintegration/tests/FSharp.Editor.Tests/SyntacticColorizationServiceTests.fs b/vsintegration/tests/FSharp.Editor.Tests/SyntacticColorizationServiceTests.fs
index 6fcb469ff89..7d988259d33 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/SyntacticColorizationServiceTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/SyntacticColorizationServiceTests.fs
@@ -51,8 +51,8 @@ type SyntacticClassificationServiceTests() =
         match tokens |> Seq.tryFind (fun token -> token.TextSpan.Contains(markerPosition)) with
         | None -> failwith "Cannot find colorization data for start of marker"
         | Some classifiedSpan ->
-            classifiedSpan.ClassificationType
-            |> Assert.shouldBeEqualWith classificationType "Classification data doesn't match for start of marker"
+            classifiedSpan.ClassificationType |> Assert.shouldBeEqualWith classificationType
+                "Classification data doesn't match for start of marker"
 
     member private this.VerifyColorizerAtEndOfMarker
         (
@@ -71,8 +71,8 @@ type SyntacticClassificationServiceTests() =
         with
         | None -> failwith "Cannot find colorization data for end of marker"
         | Some classifiedSpan ->
-            classifiedSpan.ClassificationType
-            |> Assert.shouldBeEqualWith classificationType "Classification data doesn't match for end of marker"
+            classifiedSpan.ClassificationType |> Assert.shouldBeEqualWith classificationType
+                "Classification data doesn't match for end of marker"
 
     [<Fact>]
     member this.Comment_SingleLine() =

From d1352fdaf6c411f2e270a8187e801c4fccd543a3 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Fri, 10 Feb 2023 22:57:28 +0000
Subject: [PATCH 32/42] Comment

---
 src/Compiler/Driver/OptimizeInputs.fs | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index 9b04f503ca9..b62c2df2d6d 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -171,6 +171,7 @@ module private ParallelOptimization =
                 let prevPhaseTask =
                     if node.Phase > 0 then
                         task {
+                            // Make sure that creating the task does not block before other node tasks finish
                             do! Task.Yield()
                             return! getTask prevPhaseNode
                         }
@@ -181,6 +182,7 @@ module private ParallelOptimization =
                 let prevFileTask =
                     if node.FileIdx > 0 then
                         task {
+                            // Make sure that creating the task does not block before other node tasks finish
                             do! Task.Yield()
                             return! getTask prevFileNode
                         }
@@ -205,6 +207,7 @@ module private ParallelOptimization =
 
         let startNodeTask (phase: PhaseInfo) (node: Node) =
             task {
+                // Make sure that creating the task does not block before other node tasks finish
                 do! Task.Yield()
                 let! inputs = getNodeInputs node
                 let res = phase.Func inputs
@@ -336,7 +339,7 @@ let ApplyAllOptimizations
         }
 
     // Only do these two steps in the first phase.
-    let phase2And3Settings =
+    let extraAndFinalLoopSettings =
         { firstLoopSettings with
             abstractBigTargets = false
             reportingPhase = false
@@ -424,7 +427,7 @@ let ApplyAllOptimizations
         : PhaseRes =
         let (optEnvExtraLoop, file, _, _), _ =
             Optimizer.OptimizeImplFile(
-                phase2And3Settings,
+                extraAndFinalLoopSettings,
                 ccu,
                 tcGlobals,
                 tcVal,
@@ -495,7 +498,7 @@ let ApplyAllOptimizations
         : PhaseRes =
         let (optEnvFinalSimplify, file, _, _), _ =
             Optimizer.OptimizeImplFile(
-                phase2And3Settings,
+                extraAndFinalLoopSettings,
                 ccu,
                 tcGlobals,
                 tcVal,

From 02a2995c052953d15c3b74aafce1ad66ba6d1f47 Mon Sep 17 00:00:00 2001
From: Janusz Wrobel <janusz.wrobel.2@gmail.com>
Date: Mon, 20 Mar 2023 17:47:19 +0000
Subject: [PATCH 33/42] Update src/Compiler/Optimize/Optimizer.fsi

---
 src/Compiler/Optimize/Optimizer.fsi | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Compiler/Optimize/Optimizer.fsi b/src/Compiler/Optimize/Optimizer.fsi
index fc35dc278c5..cb4f71247e5 100644
--- a/src/Compiler/Optimize/Optimizer.fsi
+++ b/src/Compiler/Optimize/Optimizer.fsi
@@ -11,7 +11,7 @@ open FSharp.Compiler.TypedTreePickle
 
 [<RequireQualifiedAccess>]
 type OptimizationProcessingMode =
-    /// Process files sequentially, on a single thread, doing all three optimization phases for each file next to each other.
+    /// Process files sequentially, on a single thread, doing all optimization phases for each file next to each other.
     | Sequential
     /// Use multiple threads.
     /// As soon as a given phase for a file has finished, start processing the next phase of the current file and the same phase of the next file.

From 9508d7ccdda678da6aae71b551d7e4c9e4b4b104 Mon Sep 17 00:00:00 2001
From: Tomas Grosup <tomasgrosup@microsoft.com>
Date: Mon, 20 Mar 2023 19:03:45 +0100
Subject: [PATCH 34/42] Fix build attempt

---
 tests/FSharp.Test.Utilities/ScriptingShims.fsx | 14 ++++++++++++++
 tests/fsharp/core/auto-widen/minimal/test.fsx  |  6 ++++++
 2 files changed, 20 insertions(+)
 create mode 100644 tests/FSharp.Test.Utilities/ScriptingShims.fsx
 create mode 100644 tests/fsharp/core/auto-widen/minimal/test.fsx

diff --git a/tests/FSharp.Test.Utilities/ScriptingShims.fsx b/tests/FSharp.Test.Utilities/ScriptingShims.fsx
new file mode 100644
index 00000000000..392d2b002b6
--- /dev/null
+++ b/tests/FSharp.Test.Utilities/ScriptingShims.fsx
@@ -0,0 +1,14 @@
+namespace global
+
+[<AutoOpen>]
+module GlobalShims = 
+
+    let errorStringWriter = new System.IO.StringWriter()        
+    let oldConsoleError = System.Console.Error
+    do System.Console.SetError(errorStringWriter)
+
+    let exit (code:int) = 
+        System.Console.SetError(oldConsoleError)
+        if code=0 then 
+            () 
+        else failwith $"Script called function 'exit' with code={code} and collected in stderr: {errorStringWriter.ToString()}"
\ No newline at end of file
diff --git a/tests/fsharp/core/auto-widen/minimal/test.fsx b/tests/fsharp/core/auto-widen/minimal/test.fsx
new file mode 100644
index 00000000000..92e7cfc56da
--- /dev/null
+++ b/tests/fsharp/core/auto-widen/minimal/test.fsx
@@ -0,0 +1,6 @@
+#r "System.Xml.Linq.dll"
+#r "System.Xml.XDocument.dll"
+
+let ns : System.Xml.Linq.XNamespace = ""
+System.IO.File.WriteAllText("test.ok","ok")
+exit 0
\ No newline at end of file

From 7376d9d45ec625af52fc63ba5e57c478dad1fc9e Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Mon, 20 Mar 2023 20:55:04 +0000
Subject: [PATCH 35/42] Finish the merge

---
 docs/fcs/compiler.fsx                         | 25 --------
 docs/fcs/interactive.fsx                      |  2 +-
 .../EntryPoint/entrypointandFSI02.fsx         |  0
 .../TypeChecks/Graph/scrape.fsx               | 56 +++++++++++++++++
 .../FSharp.Test.Utilities/ScriptingShims.fsx  | 14 +++++
 tests/fsharp/core/auto-widen/minimal/test.fsx |  6 ++
 tests/fsharp/core/members/ops/test.fsx        |  2 +-
 tests/fsharp/core/nameof/version46/test.fsx   |  2 +-
 tests/fsharp/core/printf/test.fsx             |  3 +-
 tests/fsharp/core/subtype/test.fsx            | 10 ++--
 tests/fsharp/core/unicode/test.fsx            |  8 ++-
 .../Source/CompilerOptions/fsc/help/dummy.fsx |  3 -
 .../TutorialProject/Template/Tutorial.fsx     | 60 +++++++++----------
 13 files changed, 121 insertions(+), 70 deletions(-)
 rename tests/{fsharpqa/Source => FSharp.Compiler.ComponentTests/Conformance}/EntryPoint/entrypointandFSI02.fsx (100%)
 create mode 100644 tests/FSharp.Compiler.ComponentTests/TypeChecks/Graph/scrape.fsx
 create mode 100644 tests/FSharp.Test.Utilities/ScriptingShims.fsx
 create mode 100644 tests/fsharp/core/auto-widen/minimal/test.fsx
 delete mode 100644 tests/fsharpqa/Source/CompilerOptions/fsc/help/dummy.fsx

diff --git a/docs/fcs/compiler.fsx b/docs/fcs/compiler.fsx
index 0c29769ea8d..fff7522ebb0 100644
--- a/docs/fcs/compiler.fsx
+++ b/docs/fcs/compiler.fsx
@@ -81,28 +81,3 @@ let x = 1.0 + "" // a type error
 let errors1b, exitCode1b = 
     checker.Compile([| "fsc.exe"; "-o"; fn3; "-a"; fn2 |])
     |> Async.RunSynchronously
-
-(**
-
-Compiling to a dynamic assembly
-===============================
-
-You can also compile to a dynamic assembly, which uses the F# Interactive code generator.
-This can be useful if you are, for example, in a situation where writing to the file system
-is not really an option.
-
-You still have to pass the "-o" option to name the output file, but the output file is not actually written to disk.
-
-The 'None' option indicates that the initialization code for the assembly is not executed. 
-*)
-let errors2, exitCode2, dynAssembly2 = 
-    checker.CompileToDynamicAssembly([| "-o"; fn3; "-a"; fn2 |], execute=None)
-     |> Async.RunSynchronously
-
-(*
-Passing 'Some' for the 'execute' parameter executes  the initialization code for the assembly.
-*)
-let errors3, exitCode3, dynAssembly3 = 
-    checker.CompileToDynamicAssembly([| "-o"; fn3; "-a"; fn2 |], Some(stdout,stderr))
-     |> Async.RunSynchronously
-
diff --git a/docs/fcs/interactive.fsx b/docs/fcs/interactive.fsx
index 90ec6033c7e..c904651db99 100644
--- a/docs/fcs/interactive.fsx
+++ b/docs/fcs/interactive.fsx
@@ -273,7 +273,7 @@ Evaluating code in using FsiEvaluationSession generates a .NET dynamic assembly
 You can make generated code collectible by passing `collectible=true`.  However, code will only
 be collected if there are no outstanding object references involving types, for example
 `FsiValue` objects returned by `EvalExpression`, and you must have disposed the `FsiEvaluationSession`.
-See also [Restrictions on Collectible Assemblies](https://docs.microsoft.com/en-us/previous-versions/dotnet/netframework-4.0/dd554932(v=vs.100)#restrictions).
+See also [Restrictions on Collectible Assemblies](https://learn.microsoft.com/previous-versions/dotnet/netframework-4.0/dd554932(v=vs.100)#restrictions).
 
 The example below shows the creation of 200 evaluation sessions. Note that `collectible=true` and
 `use session = ...` are both used.
diff --git a/tests/fsharpqa/Source/EntryPoint/entrypointandFSI02.fsx b/tests/FSharp.Compiler.ComponentTests/Conformance/EntryPoint/entrypointandFSI02.fsx
similarity index 100%
rename from tests/fsharpqa/Source/EntryPoint/entrypointandFSI02.fsx
rename to tests/FSharp.Compiler.ComponentTests/Conformance/EntryPoint/entrypointandFSI02.fsx
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/Graph/scrape.fsx b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Graph/scrape.fsx
new file mode 100644
index 00000000000..c20afd627c3
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Graph/scrape.fsx
@@ -0,0 +1,56 @@
+#r "nuget: MSBuild.StructuredLogger, 2.1.746"
+
+open System.IO
+open Microsoft.Build.Logging.StructuredLogger
+
+/// Create a text file with the F# compiler arguments scrapped from an binary log file.
+/// Run `dotnet build --no-incremental -bl` to create the binlog file.
+/// The --no-incremental flag is essential for this scraping code.
+let mkCompilerArgsFromBinLog file =
+    let build = BinaryLog.ReadBuild file
+
+    let projectName =
+        build.Children
+        |> Seq.choose (function
+            | :? Project as p -> Some p.Name
+            | _ -> None)
+        |> Seq.distinct
+        |> Seq.exactlyOne
+
+    let message (fscTask: FscTask) =
+        fscTask.Children
+        |> Seq.tryPick (function
+            | :? Message as m when m.Text.Contains "fsc" -> Some m.Text
+            | _ -> None)
+
+    let mutable args = None
+
+    build.VisitAllChildren<Task>(fun task ->
+        match task with
+        | :? FscTask as fscTask ->
+            match fscTask.Parent.Parent with
+            | :? Project as p when p.Name = projectName -> args <- message fscTask
+            | _ -> ()
+        | _ -> ())
+
+    match args with
+    | None -> printfn "Could not process the binlog file. Did you build using '--no-incremental'?"
+    | Some args ->
+        let content =
+            let idx = args.IndexOf "-o:"
+            args.Substring(idx)
+
+        let directory = FileInfo(file).Directory.FullName
+
+        let argsPath =
+            Path.Combine(directory, $"{Path.GetFileNameWithoutExtension(projectName)}.args.txt")
+
+        File.WriteAllText(argsPath, content)
+        printfn "Wrote %s" argsPath
+
+// Example:
+// The binlog was created by running `dotnet build --no-incremental -bl`
+mkCompilerArgsFromBinLog @"C:\Projects\fantomas\src\Fantomas.Core\msbuild.binlog"
+mkCompilerArgsFromBinLog @"C:\Projects\FsAutoComplete\src\FsAutoComplete\msbuild.binlog"
+mkCompilerArgsFromBinLog @"C:\Projects\fsharp\src\Compiler\msbuild.binlog"
+mkCompilerArgsFromBinLog @"C:\Projects\fsharp\tests\FSharp.Compiler.ComponentTests\msbuild.binlog"
diff --git a/tests/FSharp.Test.Utilities/ScriptingShims.fsx b/tests/FSharp.Test.Utilities/ScriptingShims.fsx
new file mode 100644
index 00000000000..392d2b002b6
--- /dev/null
+++ b/tests/FSharp.Test.Utilities/ScriptingShims.fsx
@@ -0,0 +1,14 @@
+namespace global
+
+[<AutoOpen>]
+module GlobalShims = 
+
+    let errorStringWriter = new System.IO.StringWriter()        
+    let oldConsoleError = System.Console.Error
+    do System.Console.SetError(errorStringWriter)
+
+    let exit (code:int) = 
+        System.Console.SetError(oldConsoleError)
+        if code=0 then 
+            () 
+        else failwith $"Script called function 'exit' with code={code} and collected in stderr: {errorStringWriter.ToString()}"
\ No newline at end of file
diff --git a/tests/fsharp/core/auto-widen/minimal/test.fsx b/tests/fsharp/core/auto-widen/minimal/test.fsx
new file mode 100644
index 00000000000..92e7cfc56da
--- /dev/null
+++ b/tests/fsharp/core/auto-widen/minimal/test.fsx
@@ -0,0 +1,6 @@
+#r "System.Xml.Linq.dll"
+#r "System.Xml.XDocument.dll"
+
+let ns : System.Xml.Linq.XNamespace = ""
+System.IO.File.WriteAllText("test.ok","ok")
+exit 0
\ No newline at end of file
diff --git a/tests/fsharp/core/members/ops/test.fsx b/tests/fsharp/core/members/ops/test.fsx
index 4c0581d42ca..1f76c94ef46 100644
--- a/tests/fsharp/core/members/ops/test.fsx
+++ b/tests/fsharp/core/members/ops/test.fsx
@@ -415,7 +415,7 @@ let RUN() = !failures
 let aa =
   match !failures with 
   | [] -> 
-      stdout.WriteLine "Test Passed"
+      stdout.WriteLine "Test Passed"    
       System.IO.File.WriteAllText("test.ok","ok")
       exit 0
   | _ -> 
diff --git a/tests/fsharp/core/nameof/version46/test.fsx b/tests/fsharp/core/nameof/version46/test.fsx
index 214bb498d90..0652ca028eb 100644
--- a/tests/fsharp/core/nameof/version46/test.fsx
+++ b/tests/fsharp/core/nameof/version46/test.fsx
@@ -32,7 +32,7 @@
 //<Expects id="FS0039" status="error" span="(262,17)">The value or constructor 'nameof' is not defined.</Expects>
 //<Expects id="FS0039" status="error" span="(266,17)">The value or constructor 'nameof' is not defined.</Expects>
 //<Expects id="FS0267" status="error" span="(271,33)">This is not a valid constant expression or custom attribute value</Expects>
-//<Expects id="FS0267" status="error" span="(271,23)">This is not a valid constant expression or custom attribute value</Expects>
+//<Expects id="FS3350" status="error" span="(271,23)">Feature 'Arithmetic and logical operations in literals, enum definitions and attributes' is not available in F# 4.6. Please use language version 'PREVIEW' or greater.</Expects>
 //<Expects id="FS0039" status="error" span="(271,33)">The value or constructor 'nameof' is not defined.</Expects>
 //<Expects id="FS0267" status="error" span="(271,33)">This is not a valid constant expression or custom attribute value</Expects>
 //<Expects id="FS0267" status="error" span="(271,23)">This is not a valid constant expression or custom attribute value</Expects>
diff --git a/tests/fsharp/core/printf/test.fsx b/tests/fsharp/core/printf/test.fsx
index 8ea722c9ee4..cf78d1a8cbd 100644
--- a/tests/fsharp/core/printf/test.fsx
+++ b/tests/fsharp/core/printf/test.fsx
@@ -447,8 +447,9 @@ module CheckDisplayAttributes12 =
        member internal x.Hello = "Hello"
        override x.ToString() = "x"
 
+    let tName = typeof<Foo>.FullName
     // this should produce an error
-    test "cenwoiwe12" (lazy(sprintf "%A" (Foo()))) "<StructuredFormatDisplay exception: Method 'Test+CheckDisplayAttributes12+Foo.Val{Hello' not found.>"
+    test "cenwoiwe12" (lazy(sprintf "%A" (Foo()))) ("<StructuredFormatDisplay exception: Method '"+tName+".Val{Hello' not found.>")
 
 // Check one with an unmatched closing bracket
 module CheckDisplayAttributes13 =
diff --git a/tests/fsharp/core/subtype/test.fsx b/tests/fsharp/core/subtype/test.fsx
index 76de2b2d520..c9aa30a006b 100644
--- a/tests/fsharp/core/subtype/test.fsx
+++ b/tests/fsharp/core/subtype/test.fsx
@@ -1088,7 +1088,7 @@ module InnerConstrainedClosureTests =
             printfn "hello, %A" z
         /// This uses the local type function in another closure that also captures one of the outer arguments
         let h() = g(3,y)
-        /// This just returnes the closure to make sure we don't optimize it all away
+        // This just returnes the closure to make sure we don't optimize it all away
         h
 
 
@@ -1099,7 +1099,7 @@ module InnerConstrainedClosureTests =
             printfn "hello, %A" z
         /// This uses the local type function in another closure that also captures one of the outer arguments
         let h() = g(3)
-        /// This just returnes the closure to make sure we don't optimize it all away
+        // This just returnes the closure to make sure we don't optimize it all away
         h
             
     let Example3 (y:'b,z:'a) = 
@@ -1108,7 +1108,7 @@ module InnerConstrainedClosureTests =
             printfn "hello, %A" z
         /// This uses the local type function in another closure that also captures one of the outer arguments
         let h() = g(3,y)
-        /// This just returnes the closure to make sure we don't optimize it all away
+        // This just returnes the closure to make sure we don't optimize it all away
         h
 
     let Example4 (y:'b,z:'a) = 
@@ -1119,7 +1119,7 @@ module InnerConstrainedClosureTests =
         let h1() = g(3,4,y)
         /// This uses the local type function in another closure that also captures one of the outer arguments
         let h2() = g("3","4",y)
-        /// This just returnes the closure to make sure we don't optimize it all away
+        // This just returnes the closure to make sure we don't optimize it all away
         h1,h2
 
 
@@ -1132,7 +1132,7 @@ module InnerConstrainedClosureTests =
         let h1() = g(3,4,y)
         /// This uses the local type function in another closure that also captures one of the outer arguments
         let h2() = g("3","4",y)
-        /// This just returnes the closure to make sure we don't optimize it all away
+        // This just returnes the closure to make sure we don't optimize it all away
         h1,h2
 
     let Example6 (y:'b,z:'a) = 
diff --git a/tests/fsharp/core/unicode/test.fsx b/tests/fsharp/core/unicode/test.fsx
index 9b7303c0d32..10089e9dd0b 100644
--- a/tests/fsharp/core/unicode/test.fsx
+++ b/tests/fsharp/core/unicode/test.fsx
@@ -24,6 +24,8 @@ let input_byte (x : System.IO.FileStream) =
     let b = x.ReadByte() 
     if b = -1 then raise (System.IO.EndOfStreamException()) else b
 
+let bslFilePath = Path.Combine(__SOURCE_DIRECTORY__,"out.bsl")
+
 let test2925 () = 
   printfn "test2925...";
   (* This writes a file in the standard utf8 encoding.  Probably needs to be adjusted if default encodings differ *)
@@ -32,7 +34,7 @@ let test2925 () =
   os.Write "\u2260"; (* not equals *)
   os.Dispose();
   use is1 = System.IO.File.OpenRead "out1.txt" in 
-  use is2 = System.IO.File.OpenRead "out.bsl" in 
+  use is2 = System.IO.File.OpenRead bslFilePath in 
   try 
     while true do 
       let c2 = input_byte is2 in 
@@ -54,7 +56,7 @@ let test2925b () =
   os.Write "\U00002260"; (* not equals *)
   os.Dispose();
   let is1 = System.IO.File.OpenRead "out1.txt" in 
-  let is2 = System.IO.File.OpenRead "out.bsl" in 
+  let is2 = System.IO.File.OpenRead bslFilePath in 
   try 
     while true do 
       let c2 = input_byte is2 in 
@@ -77,7 +79,7 @@ let test2926 () =
   Printf.printf "length s = %d\n" (String.length s);
   os.Dispose();
   let is1 = System.IO.File.OpenRead "out2.txt" in 
-  let is2 = System.IO.File.OpenRead "out.bsl" in 
+  let is2 = System.IO.File.OpenRead bslFilePath in 
   try 
     while true do 
       let c2 = input_byte is2 in 
diff --git a/tests/fsharpqa/Source/CompilerOptions/fsc/help/dummy.fsx b/tests/fsharpqa/Source/CompilerOptions/fsc/help/dummy.fsx
deleted file mode 100644
index c5ecbb36434..00000000000
--- a/tests/fsharpqa/Source/CompilerOptions/fsc/help/dummy.fsx
+++ /dev/null
@@ -1,3 +0,0 @@
-// #NoMT #CompilerOptions #RequiresENU   
-#light
-exit 0
diff --git a/vsintegration/ProjectTemplates/TutorialProject/Template/Tutorial.fsx b/vsintegration/ProjectTemplates/TutorialProject/Template/Tutorial.fsx
index 741e8c5a866..bf1ef353d5a 100644
--- a/vsintegration/ProjectTemplates/TutorialProject/Template/Tutorial.fsx
+++ b/vsintegration/ProjectTemplates/TutorialProject/Template/Tutorial.fsx
@@ -7,10 +7,10 @@
 //
 // @@@MoreAbout|For more about F#, see:@@@
 //     https://fsharp.org
-//     https://docs.microsoft.com/en-us/dotnet/articles/fsharp/
+//     https://learn.microsoft.com/dotnet/articles/fsharp/
 //
 // @@@SeeDocumentaton|To see this tutorial in documentation form, see:@@@
-//     https://docs.microsoft.com/en-us/dotnet/articles/fsharp/tour
+//     https://learn.microsoft.com/dotnet/articles/fsharp/tour
 //
 // @@@LearnMoreAbout|To learn more about applied F# programming, use@@@
 //     https://fsharp.org/guides/enterprise/
@@ -33,19 +33,19 @@
 ///
 ///    @@@XmlComments-Line1|They also support .NET-style XML comments, which allow you to generate reference documentation,@@@
 ///    @@@XmlComments-Line2|and they also allow editors (such as Visual Studio) to extract information from them.@@@
-///    @@@XmlComments-Line3|To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/xml-documentation@@@
+///    @@@XmlComments-Line3|To learn more, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/xml-documentation@@@
 
 
 // @@@OpenNamespaces|Open namespaces using the 'open' keyword.@@@
 //
-// @@@LearnMore|To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/import-declarations-the-open-keyword@@@
+// @@@LearnMore|To learn more, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/import-declarations-the-open-keyword@@@
 open System
 
 
 /// @@@Module-Line1|A module is a grouping of F# code, such as values, types, and function values.@@@
 /// @@@Module-Line2|Grouping code in modules helps keep related code together and helps avoid name conflicts in your program.@@@
 ///
-/// @@@Module-Line3|To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/modules@@@
+/// @@@Module-Line3|To learn more, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/modules@@@
 module IntegersAndNumbers =
 
     /// @@@SampleInt|This is a sample integer.@@@
@@ -74,7 +74,7 @@ module IntegersAndNumbers =
 /// @@@ValuesImmutable-Line1|Values in F# are immutable by default.  They cannot be changed@@@
 /// @@@ValuesImmutable-Line2|in the course of a program's execution unless explicitly marked as mutable.@@@
 ///
-/// @@@ValuesImmutable-Line3|To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/values/index#why-immutable@@@
+/// @@@ValuesImmutable-Line3|To learn more, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/values/index#why-immutable@@@
 module Immutability =
 
     /// @@@LetKeyword-Line1|Binding a value to a name via 'let' makes it immutable.@@@
@@ -101,7 +101,7 @@ module Immutability =
 /// @@@FunctionsModule-Line1|Much of F# programming consists of defining functions that transform input data to produce@@@
 /// @@@FunctionsModule-Line2|useful results.@@@
 ///
-/// @@@FunctionsModule-Line3|To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/functions/@@@
+/// @@@FunctionsModule-Line3|To learn more, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/functions/@@@
 module BasicFunctions =
 
     /// @@@LetFunction-Line1|You use 'let' to define a function. This one accepts an integer argument and returns an integer.@@@
@@ -140,9 +140,9 @@ module BasicFunctions =
 /// @@@Booleans-Line1|Booleans are fundamental data types in F#.  Here are some examples of Booleans and conditional logic.@@@
 ///
 /// @@@Booleans-Line2|To learn more, see:@@@
-///     https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/primitive-types
+///     https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/primitive-types
 ///     @@@Booleans-Line3|and@@@
-///     https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/symbol-and-operator-reference/boolean-operators
+///     https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/symbol-and-operator-reference/boolean-operators
 module Booleans =
 
     /// @@@BooleanValues|Booleans values are 'true' and 'false'.@@@
@@ -158,7 +158,7 @@ module Booleans =
 
 /// @@@Strings-Line1|Strings are fundamental data types in F#.  Here are some examples of Strings and basic String manipulation.@@@
 ///
-/// @@@Strings-Line2|To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/strings@@@
+/// @@@Strings-Line2|To learn more, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/strings@@@
 module StringManipulation =
 
     /// @@@StringQuotes|Strings use double quotes.@@@
@@ -186,7 +186,7 @@ module StringManipulation =
 
 /// @@@Tuples-Line1|Tuples are simple combinations of data values into a combined value.@@@
 ///
-/// @@@Tuples-Line2|To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/tuples@@@
+/// @@@Tuples-Line2|To learn more, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/tuples@@@
 module Tuples =
 
     /// @@@TupleInteger|A simple tuple of integers.@@@
@@ -231,8 +231,8 @@ module Tuples =
 /// @@@Pipes-Line2|are used extensively when processing data.  These operators are themselves functions@@@
 /// @@@Pipes-Line3|which make use of Partial Application.@@@
 ///
-/// @@@Pipes-Line4|To learn more about these operators, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/functions/#function-composition-and-pipelining@@@
-/// @@@Pipes-Line5|To learn more about Partial Application, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/functions/#partial-application-of-arguments@@@
+/// @@@Pipes-Line4|To learn more about these operators, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/functions/#function-composition-and-pipelining@@@
+/// @@@Pipes-Line5|To learn more about Partial Application, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/functions/#partial-application-of-arguments@@@
 module PipelinesAndComposition =
 
     /// @@@Squares|Squares a value.@@@
@@ -314,7 +314,7 @@ module PipelinesAndComposition =
 /// @@@Lists-Line2|This module shows various ways to generate lists and process lists with some functions@@@
 /// @@@Lists-Line3|in the 'List' module in the F# Core Library.@@@
 ///
-/// @@@Lists-Line4|To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/lists@@@
+/// @@@Lists-Line4|To learn more, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/lists@@@
 module Lists =
 
     /// @@@ListEmptyDefinition|Lists are defined using [ ... ].  This is an empty list.@@@
@@ -373,7 +373,7 @@ module Lists =
 /// @@@Arrays-Line2|Although they are similar to Lists (they support enumeration and have similar combinators for data processing),@@@
 /// @@@Arrays-Line3|they are generally faster and support fast random access.  This comes at the cost of being less safe by being mutable.@@@
 ///
-/// @@@Arrays-Line4|To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/arrays@@@
+/// @@@Arrays-Line4|To learn more, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/arrays@@@
 module Arrays =
 
     /// @@@EmptyArray|This is The empty array.  Note that the syntax is similar to that of Lists, but uses `[| ... |]` instead.@@@
@@ -403,7 +403,7 @@ module Arrays =
 
     // @@@ArrayAssignment-Line1|You can modify the contents of an an array element by using the left arrow assignment operator.@@@
     //
-    // @@@ArrayAssignment-Line2|To learn more about this operator, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/values/index#mutable-variables@@@
+    // @@@ArrayAssignment-Line2|To learn more about this operator, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/values/index#mutable-variables@@@
     array2.[1] <- "WORLD!"
 
     /// @@@ArrayMap-Line1|You can transform arrays using 'Array.map' and other functional programming operations.@@@
@@ -423,7 +423,7 @@ module Arrays =
 ///
 /// @@@Sequences-Line4|Sequence processing functions can be applied to Lists and Arrays as well.@@@
 ///
-/// @@@Sequences-Line5|To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/sequences@@@
+/// @@@Sequences-Line5|To learn more, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/sequences@@@
 module Sequences =
 
     /// @@@EmptySequence|This is the empty sequence.@@@
@@ -466,7 +466,7 @@ module Sequences =
 ///
 /// @@@RecursiveFunctions-Line3|Recursion is the preferred way to process sequences or collections in F#.@@@
 ///
-/// @@@RecursiveFunctions-Line4|To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/functions/index#recursive-functions@@@
+/// @@@RecursiveFunctions-Line4|To learn more, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/functions/index#recursive-functions@@@
 module RecursiveFunctions =
 
     /// @@@RecFunDef-Line1|This example shows a recursive function that computes the factorial of an@@@
@@ -512,7 +512,7 @@ module RecursiveFunctions =
 /// @@@Records-Line1|Records are an aggregate of named values, with optional members (such as methods).@@@
 /// @@@Records-Line2|They are immutable and have structural equality semantics.@@@
 ///
-/// @@@Records-Line3|To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/records@@@
+/// @@@Records-Line3|To learn more, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/records@@@
 module RecordTypes =
 
     /// @@@RecordDefinition|This example shows how to define a new record type.@@@
@@ -534,7 +534,7 @@ module RecordTypes =
     /// @@@UpdateRecord-Line2|a new record value that is a copy of contact1, but has different values for@@@
     /// @@@UpdateRecord-Line3|the 'Phone' and 'Verified' fields.@@@
     ///
-    /// @@@UpdateRecord-Line4|To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/copy-and-update-record-expressions@@@
+    /// @@@UpdateRecord-Line4|To learn more, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/copy-and-update-record-expressions@@@
     let contact2 =
         { contact1 with
             Phone = "(206) 555-0112"
@@ -580,7 +580,7 @@ module RecordTypes =
 /// @@@DiscriminatedUnions-Line1|Discriminated Unions (DU for short) are values which could be a number of named forms or cases.@@@
 /// @@@DiscriminatedUnions-Line2|Data stored in DUs can be one of several distinct values.@@@
 ///
-/// @@@DiscriminatedUnions-Line3|To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/discriminated-unions@@@
+/// @@@DiscriminatedUnions-Line3|To learn more, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/discriminated-unions@@@
 module DiscriminatedUnions =
 
     /// @@@CardSuit|The following represents the suit of a playing card.@@@
@@ -710,7 +710,7 @@ module DiscriminatedUnions =
 /// @@@PatternMatching-Line3|decompose data into constituent parts, or extract information from data in various ways.@@@
 /// @@@PatternMatching-Line4|You can then dispatch on the "shape" of a pattern via Pattern Matching.@@@
 ///
-/// @@@PatternMatching-Line5|To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/pattern-matching@@@
+/// @@@PatternMatching-Line5|To learn more, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/pattern-matching@@@
 module PatternMatching =
 
     /// @@@PersonRecord|A record for a person's first and last name@@@
@@ -768,7 +768,7 @@ module PatternMatching =
     // @@@ActivePatterns-Line1|Active Patterns are another powerful construct to use with pattern matching.@@@
     // @@@ActivePatterns-Line2|They allow you to partition input data into custom forms, decomposing them at the pattern match call site.@@@
     //
-    // @@@ActivePatterns-Line3|To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/active-patterns@@@
+    // @@@ActivePatterns-Line3|To learn more, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/active-patterns@@@
     let (|Int|_|) = parseInt
     let (|Double|_|) = parseDouble
     let (|Date|_|) = parseDateTimeOffset
@@ -794,7 +794,7 @@ module PatternMatching =
 /// @@@Option-Line2|They are used extensively in F# code to represent the cases where many other@@@
 /// @@@Option-Line3|languages would use null references.@@@
 ///
-/// @@@Option-Line4|To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/options@@@
+/// @@@Option-Line4|To learn more, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/options@@@
 module OptionValues =
 
     /// @@@ZipCode|First, define a zipcode defined via Single-case Discriminated Union.@@@
@@ -821,7 +821,7 @@ module OptionValues =
 /// @@@UnitsOfMeasure-Line1|Units of measure are a way to annotate primitive numeric types in a type-safe way.@@@
 /// @@@UnitsOfMeasure-Line2|You can then perform type-safe arithmetic on these values.@@@
 ///
-/// @@@UnitsOfMeasure-Line3|To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/units-of-measure@@@
+/// @@@UnitsOfMeasure-Line3|To learn more, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/units-of-measure@@@
 module UnitsOfMeasure =
 
     /// @@@CommonUnits|First, open a collection of common unit names@@@
@@ -849,9 +849,9 @@ module UnitsOfMeasure =
 /// @@@Classes-Line1|Classes are a way of defining new object types in F#, and support standard Object-oriented constructs.@@@
 /// @@@Classes-Line2|They can have a variety of members (methods, properties, events, etc.)@@@
 ///
-/// @@@Classes-Line3|To learn more about Classes, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/classes@@@
+/// @@@Classes-Line3|To learn more about Classes, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/classes@@@
 ///
-/// @@@Classes-Line4|To learn more about Members, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/members@@@
+/// @@@Classes-Line4|To learn more about Members, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/members@@@
 module DefiningClasses =
 
     /// @@@Vector-Line1|A simple two-dimensional Vector class.@@@
@@ -887,7 +887,7 @@ module DefiningClasses =
 /// @@@GenericClasses-Line1|Generic classes allow types to be defined with respect to a set of type parameters.@@@
 /// @@@GenericClasses-Line2|In the following, 'T is the type parameter for the class.@@@
 ///
-/// @@@GenericClasses-Line3|To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/generics/@@@
+/// @@@GenericClasses-Line3|To learn more, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/generics/@@@
 module DefiningGenericClasses =
 
     type StateTracker<'T>(initialElement: 'T) =
@@ -915,7 +915,7 @@ module DefiningGenericClasses =
 /// @@@Interfaces-Line1|Interfaces are object types with only 'abstract' members.@@@
 /// @@@Interfaces-Line2|Object types and object expressions can implement interfaces.@@@
 ///
-/// @@@Interfaces-Line3|To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/interfaces@@@
+/// @@@Interfaces-Line3|To learn more, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/interfaces@@@
 module ImplementingInterfaces =
 
     /// @@@IDisposable|This is a type that implements IDisposable.@@@
@@ -964,7 +964,7 @@ module ParallelArrayProgramming =
 
 /// @@@Events-Line1|Events are a common idiom for .NET programming, especially with WinForms or WPF applications.@@@
 ///
-/// @@@Events-Line2|To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/members/events@@@
+/// @@@Events-Line2|To learn more, see: https://learn.microsoft.com/dotnet/articles/fsharp/language-reference/members/events@@@
 module Events =
 
     /// @@@SimpleEvent|First, create instance of Event object that consists of subscription point (event.Publish) and event trigger (event.Trigger).@@@

From 5a546229acb1d2f50cc42d10b261783b6748049b Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Mon, 20 Mar 2023 22:00:31 +0000
Subject: [PATCH 36/42] dummy


From 661811226442d0499822618a81310d10320c7987 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Thu, 4 May 2023 19:02:07 +0100
Subject: [PATCH 37/42] Turn parallel optimization on in deterministic builds

---
 src/Compiler/Driver/OptimizeInputs.fs       | 4 +---
 src/Compiler/FSharp.Compiler.Service.fsproj | 4 ++--
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index b62c2df2d6d..e3e4d6b73ea 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -523,13 +523,11 @@ let ApplyAllOptimizations
 
     let results, optEnvFirstLoop =
         match tcConfig.optSettings.processingMode with
-        // Parallel optimization breaks determinism - turn it off in deterministic builds.
-        | Optimizer.OptimizationProcessingMode.Parallel when (not tcConfig.deterministic) ->
+        | Optimizer.OptimizationProcessingMode.Parallel ->
             let results, optEnvFirstPhase =
                 ParallelOptimization.optimizeFilesInParallel optEnv phases implFiles
 
             results |> Array.toList, optEnvFirstPhase
-        | Optimizer.OptimizationProcessingMode.Parallel
         | Optimizer.OptimizationProcessingMode.Sequential -> optimizeFilesSequentially optEnv phases implFiles
 
 #if DEBUG
diff --git a/src/Compiler/FSharp.Compiler.Service.fsproj b/src/Compiler/FSharp.Compiler.Service.fsproj
index a46aed15887..acabe31e9a5 100644
--- a/src/Compiler/FSharp.Compiler.Service.fsproj
+++ b/src/Compiler/FSharp.Compiler.Service.fsproj
@@ -536,8 +536,8 @@
   </ItemGroup>
 
   <ItemGroup>
-    <Content Include="Driver\parallel-optimization.md" />
-    <Content Include="Driver\parallel-optimization.drawio.svg" />
+    <None Include="Driver\parallel-optimization.md" />
+    <None Include="Driver\parallel-optimization.drawio.svg" />
   </ItemGroup>
 
 </Project>

From 964a275df92d4db56ca98c4ee78b931d69a1c5a3 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Thu, 4 May 2023 20:59:57 +0100
Subject: [PATCH 38/42] Once again disable parallel optimisation in
 deterministic builds - determinism tests are still failing.

---
 src/Compiler/Driver/OptimizeInputs.fs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index e3e4d6b73ea..b62c2df2d6d 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -523,11 +523,13 @@ let ApplyAllOptimizations
 
     let results, optEnvFirstLoop =
         match tcConfig.optSettings.processingMode with
-        | Optimizer.OptimizationProcessingMode.Parallel ->
+        // Parallel optimization breaks determinism - turn it off in deterministic builds.
+        | Optimizer.OptimizationProcessingMode.Parallel when (not tcConfig.deterministic) ->
             let results, optEnvFirstPhase =
                 ParallelOptimization.optimizeFilesInParallel optEnv phases implFiles
 
             results |> Array.toList, optEnvFirstPhase
+        | Optimizer.OptimizationProcessingMode.Parallel
         | Optimizer.OptimizationProcessingMode.Sequential -> optimizeFilesSequentially optEnv phases implFiles
 
 #if DEBUG

From c3aa68f2c80c5460bd51f40416dfd8ee489c9904 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Thu, 4 May 2023 22:44:28 +0100
Subject: [PATCH 39/42] Dummy commit to trigger CI rerun


From ec2202fb909a16852fae082404321b5d7a45f206 Mon Sep 17 00:00:00 2001
From: Tomas Grosup <tomasgrosup@microsoft.com>
Date: Wed, 17 May 2023 16:16:51 +0200
Subject: [PATCH 40/42] Reverting ArrayParallel functionality

---
 src/Compiler/Utilities/lib.fs | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

diff --git a/src/Compiler/Utilities/lib.fs b/src/Compiler/Utilities/lib.fs
index e91be7e0f3a..f4c37de4cf9 100755
--- a/src/Compiler/Utilities/lib.fs
+++ b/src/Compiler/Utilities/lib.fs
@@ -464,17 +464,14 @@ type DisposablesTracker() =
 module ArrayParallel =
 
     let inline iteri f (arr: 'T []) =
-        match arr with
-        | [||] -> ()
-        | arr ->
-            let parallelOptions = ParallelOptions(MaxDegreeOfParallelism = Environment.ProcessorCount)
-            try
-                Parallel.For(0, arr.Length, parallelOptions, fun i ->
-                    f i arr[i]
-                ) |> ignore
-            with
-            | :? AggregateException as ex when ex.InnerExceptions.Count = 1 ->
-                raise(ex.InnerExceptions[0])
+        let parallelOptions = ParallelOptions(MaxDegreeOfParallelism = max (min Environment.ProcessorCount arr.Length) 1)
+        try
+            Parallel.For(0, arr.Length, parallelOptions, fun i ->
+                f i arr[i]
+            ) |> ignore
+        with
+        | :? AggregateException as ex when ex.InnerExceptions.Count = 1 ->
+            raise(ex.InnerExceptions[0])
 
     let inline iter f (arr: 'T []) =
         arr |> iteri (fun _ item -> f item)

From c3ab4128bac840ae38cb00eeeafc4afeced35239 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Wed, 17 May 2023 22:19:39 +0100
Subject: [PATCH 41/42] Dummy commit to trigger CI rerun


From 546c08de27d622bd4732528043a868e8faefe271 Mon Sep 17 00:00:00 2001
From: janusz <janusz.wrobel.2@gmail.com>
Date: Thu, 18 May 2023 17:23:31 +0100
Subject: [PATCH 42/42] Use backgroundTask

---
 src/Compiler/Driver/OptimizeInputs.fs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/Compiler/Driver/OptimizeInputs.fs b/src/Compiler/Driver/OptimizeInputs.fs
index b62c2df2d6d..d6da3a6dbe9 100644
--- a/src/Compiler/Driver/OptimizeInputs.fs
+++ b/src/Compiler/Driver/OptimizeInputs.fs
@@ -164,13 +164,13 @@ module private ParallelOptimization =
 
         /// Asynchronously wait for dependencies of a node
         let getNodeInputs (node: Node) =
-            task {
+            backgroundTask {
                 let prevPhaseNode = { node with Phase = node.Phase - 1 }
                 let prevFileNode = { node with FileIdx = node.FileIdx - 1 }
 
                 let prevPhaseTask =
                     if node.Phase > 0 then
-                        task {
+                        backgroundTask {
                             // Make sure that creating the task does not block before other node tasks finish
                             do! Task.Yield()
                             return! getTask prevPhaseNode
@@ -181,7 +181,7 @@ module private ParallelOptimization =
 
                 let prevFileTask =
                     if node.FileIdx > 0 then
-                        task {
+                        backgroundTask {
                             // Make sure that creating the task does not block before other node tasks finish
                             do! Task.Yield()
                             return! getTask prevFileNode
@@ -206,7 +206,7 @@ module private ParallelOptimization =
             }
 
         let startNodeTask (phase: PhaseInfo) (node: Node) =
-            task {
+            backgroundTask {
                 // Make sure that creating the task does not block before other node tasks finish
                 do! Task.Yield()
                 let! inputs = getNodeInputs node