anchor.diff:                      cache'.TryAdd(s,t) |> ignore
                       t
   
  -
  -//        // produces a structural hashcode out of a byte array
  -//        let getByteHashCode (bs : byte []) =
  -//            let n = bs.Length
  -//            let mutable i = 0
  -//            let mutable acc = 0
  -//
  -//            let inline bytes2Int x y z w = 
  -//                int x + (int y <<< 8) + (int z <<< 16) + (int w <<< 24)
  -//
  -//            while i + 4 <= n do
  -//                acc <- acc ^^^ bytes2Int bs.[i] bs.[i + 1] bs.[i + 2] bs.[i + 3]
  -//                i <- i + 4
  -//
  -//            match n - i with
  -//            | 0 -> ()
  -//            | 1 -> acc <- acc ^^^ bytes2Int bs.[i] 0uy 0uy 0uy
  -//            | 2 -> acc <- acc ^^^ bytes2Int bs.[i] bs.[i+1] 0uy 0uy
  -//            | _ -> acc <- acc ^^^ bytes2Int bs.[i] bs.[i+1] bs.[i+2] 0uy
  -//
  -//            acc
  -
           [<RequireQualifiedAccess>]
           module Stream =
   
  
positive.code:                     do readBytes r
                      Buffer.BlockCopy(buf, 0, array, d * bufferSize, r)
  
  
          // reflection utils
  
  //        let allFields = 
  //            BindingFlags.NonPublic ||| BindingFlags.Public ||| 
  //                BindingFlags.Instance ||| BindingFlags.FlattenHierarchy 
  //
  //        let allMembers =
  //            BindingFlags.NonPublic ||| BindingFlags.Public |||
  //                BindingFlags.Instance ||| BindingFlags.Static ||| BindingFlags.FlattenHierarchy
  //
  //        let allConstructors = BindingFlags.Instance ||| BindingFlags.NonPublic ||| BindingFlags.Public
  //
  //        let containsAttr<'T when 'T :> Attribute> (m : MemberInfo) =
  //            m.GetCustomAttributes(typeof<'T>, true) |> Seq.isEmpty |> not
  
  //        /// checks if instances of given type can be arrays
  //        let isAssignableFromArray =
  //            let getCanonicalType (t:Type) = 
  //                if t.IsGenericType then t.GetGenericTypeDefinition() 
  //                else t
  //
  //            let arrayIfs =  typeof<int []>.GetInterfaces() |> Array.map getCanonicalType
  //
  //            fun (t : Type) ->
  //                if t.IsAssignableFrom typeof<Array> then true
  //                elif t.IsArray then true
  //                elif not t.IsInterface then false
  //                else
  //                    // check interface compatibility
  //                    Array.exists ((=) (getCanonicalType t)) arrayIfs
  
  
          type SerializationInfo with
              member sI.Write<'T> (name : string, x : 'T) =
                  sI.AddValue(name, x, typeof<'T>)
  
              member sI.Read<'T>(name : string) =
                  sI.GetValue(name, typeof<'T>) :?> 'T
  
  
  
  
  
  
          let inline pickle (f : Stream -> 'T -> unit) (x : 'T) : byte [] =
              use mem = new MemoryStream()
  
negative.code: 
  //    #nowarn "1204"
  //    #nowarn "42"
  
      [<AutoOpen>]
      module internal Utils =
  