anchor.diff:              let GenericHashWithComparerIntrinsic<'T> (iec : System.Collections.IEqualityComparer) (x : 'T) : int =
                   match GenericSpecializeHash.Func with
                   | null -> GenericHashParamObj iec (box x)
  -                | func -> func.Invoke x
  +                | func -> func.Invoke (iec, x)
                   
               /// Direct call to GetHashCode on the string type
               let inline HashString (s:string) = 
  
positive.code:                   | _ -> 
                       HashCombine 10 (x.GetLength(0)) (x.GetLength(1)) 
  
              type GenericSpecializeHash<'a>() =
                  static let generalize (func:Func<'aa,int>) =
                      match box func with
                      | :? Func<'a,int> as f -> f
                      | _ -> raise (Exception "invalid logic")
  
                  static let _func =
                      match typeof<'a> with
                      | t when t.Equals typeof<bool>       -> generalize (Func<_,_>(fun (a:bool)       -> a.GetHashCode()))
                      | t when t.Equals typeof<sbyte>      -> generalize (Func<_,_>(fun (a:sbyte)      -> a.GetHashCode()))
                      | t when t.Equals typeof<int16>      -> generalize (Func<_,_>(fun (a:int16)      -> a.GetHashCode()))
                      | t when t.Equals typeof<int32>      -> generalize (Func<_,_>(fun (a:int32)      -> a.GetHashCode()))
                      | t when t.Equals typeof<int64>      -> generalize (Func<_,_>(fun (a:int64)      -> a.GetHashCode()))
                      | t when t.Equals typeof<byte>       -> generalize (Func<_,_>(fun (a:byte)       -> a.GetHashCode()))
                      | t when t.Equals typeof<uint16>     -> generalize (Func<_,_>(fun (a:uint16)     -> a.GetHashCode()))
                      | t when t.Equals typeof<uint32>     -> generalize (Func<_,_>(fun (a:uint32)     -> a.GetHashCode()))
                      | t when t.Equals typeof<uint64>     -> generalize (Func<_,_>(fun (a:uint64)     -> a.GetHashCode()))
                      | t when t.Equals typeof<nativeint>  -> generalize (Func<_,_>(fun (a:nativeint)  -> a.GetHashCode()))
                      | t when t.Equals typeof<unativeint> -> generalize (Func<_,_>(fun (a:unativeint) -> a.GetHashCode()))
                      | t when t.Equals typeof<char>       -> generalize (Func<_,_>(fun (a:char)       -> a.GetHashCode()))
                      | t when t.Equals typeof<string>     -> generalize (Func<_,_>(fun (a:string)     -> a.GetHashCode()))
                      | t when t.Equals typeof<decimal>    -> generalize (Func<_,_>(fun (a:decimal)    -> a.GetHashCode()))
                      | t when t.Equals typeof<float>      -> generalize (Func<_,_>(fun (a:float)      -> a.GetHashCode()))
                      | t when t.Equals typeof<float32>    -> generalize (Func<_,_>(fun (a:float32)    -> a.GetHashCode()))
                      | _ -> null
                              
                  static member Func = _func
  
negative.code:             // NOTE: The compiler optimizer is aware of this function (see uses of generic_hash_inner_vref in opt.fs)
              // and devirtualizes calls to it based on type "T".
              let GenericHashIntrinsic x = 
                  let iec = fsEqualityComparerUnlimitedHashingPER
                  match GenericSpecializeHash.Func with
                  | null -> GenericHashParamObj iec (box x)
                  | func -> func.Invoke (iec, x)
  
              /// Intrinsic for calls to depth-limited structural hashing that were not optimized by static conditionals.
              let LimitedGenericHashIntrinsic limit x =
                  let iec = CountLimitedHasherPER limit
                  match GenericSpecializeHash.Func with
                  | null -> GenericHashParamObj iec (box x)
                  | func -> func.Invoke (iec, x)
  
              /// Intrinsic for a recursive call to structural hashing that was not optimized by static conditionals.
              //
  