anchor.diff:                    | _ -> 
                         x.GetHashCode()
   
  -            // functionality of GenericSpecializedHash should match GenericHashParamObj, or return null
  -            // for fallback to that funciton. 
  -            type GenericSpecializeHash<'a>() =
  -                static let generalize (func:Func<IEqualityComparer,'aa,int>) =
  -                    match box func with
  -                    | :? Func<IEqualityComparer,'a,int> as f -> f
  -                    | _ -> raise (Exception "invalid logic")
  -
  -                static let _specialized =
  -                    match typeof<'a> with
  -                    | t when t.IsArray || typeof<System.Array>.IsAssignableFrom t ->
  -                        // I could do something here, but I doubt it would have any real performance impact
  -                        null
  -
  -                    | t when t.IsValueType && typeof<IStructuralEquatable>.IsAssignableFrom t ->
  -                        let equals = typeof<IStructuralEquatable>.GetMethod ("GetHashCode", [|typeof<IEqualityComparer>|])
  -                        let ec = Expression.Parameter typeof<IEqualityComparer>
  -                        let a = Expression.Parameter typeof<'a>
  -                        let lambda = Expression.Lambda<_> (Expression.Call (a, equals, ec), ec, a)
  -                        lambda.Compile ()
  -
  -                    | t when typeof<IStructuralEquatable>.IsAssignableFrom t ->
  -                        (Func<_,_,_>(fun ec (a:'a) ->
  -                            match box a with
  -                            | null -> 0
  -                            | :? IStructuralEquatable as se -> se.GetHashCode ec
  -                            | _ -> raise (Exception "invalid logic")))
  -
  -                    | 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()))
  -
  -                    | t when t.IsValueType ->
  -                        let ec = Expression.Parameter typeof<IEqualityComparer>
  -                        let a = Expression.Parameter typeof<'a>
  -                        let lambda = Expression.Lambda<_> (Expression.Call(a, "GetHashCode", [||]), ec, a)
  -                        lambda.Compile ()
  -
  -#if FX_ATLEAST_40
  -                    | t when t.IsSealed -> // only sealed as a derived class might inherit from IStructuralEquatable
  -                        (Func<_,_,_>(fun ec (a:'a) ->
  -                            match box a with
  -                            | null -> 0
  -                            | o -> o.GetHashCode ()))
  -#endif
  -                    | _ -> null
  -
  -                static let _func =
  -                    match _specialized with
  -                    | null -> Func<_,_,_>(fun iec o -> GenericHashParamObj iec (box o))
  -                    | f -> f
  -                            
  -                static member Func = _func
  -
               /// Fill in the implementation of CountLimitedHasherPER
               type CountLimitedHasherPER with
                   interface System.Collections.IEqualityComparer with
  
positive.code:                 interface IEqualityComparerInfo with
                      member __.Info = EqualityComparerInfo.PER
  
              /// Intrinsic for calls to depth-unlimited structural hashing that were not optimized by static conditionals.
              //
              // 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
                  eliminate_tail_call_int (GenericSpecializeHash.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
                  eliminate_tail_call_int (GenericSpecializeHash.Func.Invoke (iec, x))
  
              /// Intrinsic for a recursive call to structural hashing that was not optimized by static conditionals.
              //
  
negative.code:             // NOTE: The compiler optimizer is aware of this function (see uses of generic_hash_withc_inner_vref in opt.fs)
              // and devirtualizes calls to it based on type "T".
              let GenericHashWithComparerIntrinsic<'T> (iec : System.Collections.IEqualityComparer) (x : 'T) : int =
                  eliminate_tail_call_int (GenericSpecializeHash.Function<_>.Func.Invoke (iec, x))
  
  #else
  
              /// Intrinsic for calls to depth-unlimited structural hashing that were not optimized by static conditionals.
              //
              // 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 = GenericHashParamObj fsEqualityComparerUnlimitedHashingPER (box(x))
  
              /// Intrinsic for calls to depth-limited structural hashing that were not optimized by static conditionals.
              let LimitedGenericHashIntrinsic limit x = GenericHashParamObj (CountLimitedHasherPER(limit)) (box(x))
  
              /// Intrinsic for a recursive call to structural hashing that was not optimized by static conditionals.
              //
              // "iec" is assumed to be either fsEqualityComparerUnlimitedHashingER, fsEqualityComparerUnlimitedHashingPER or 
              // a CountLimitedHasherPER.
              //
              // NOTE: The compiler optimizer is aware of this function (see uses of generic_hash_withc_inner_vref in opt.fs)
              // and devirtualizes calls to it based on type "T".
              let GenericHashWithComparerIntrinsic<'T> (iec : System.Collections.IEqualityComparer) (x : 'T) : int =
                  GenericHashParamObj iec (box(x))
  #endif
                  
              /// Direct call to GetHashCode on the string type
              let inline HashString (s:string) = 
  