anchor.diff:  
   //    #nowarn "1204"
   //    #nowarn "42"
  -
  -//    module internal Config =
  -//        [<Literal>]
  -//        let optimizeForLittleEndian = true
   
       [<AutoOpen>]
       module internal Utils =
  
positive.code: 
          let inline unpickle (f : Stream -> 'T) (data : byte []) : 'T =
              use mem = new MemoryStream(data)
              f mem
  
  
  //        /// walks up the type hierarchy, gathering all instance fields
  //        let gatherFields (t : Type) =
  //            // resolve conflicts, index by declaring type and field name
  //            let gathered = ref Map.empty<string * string, FieldInfo>
  //
  //            let rec gather (t : Type) =
  //                let fields = t.GetFields(allFields)
  //                for f in fields do
  //                    let k = f.DeclaringType.AssemblyQualifiedName, f.Name
  //                    if not <| gathered.Value.ContainsKey k then
  //                        gathered := gathered.Value.Add(k, f)
  //
  //                match t.BaseType with
  //                | null -> ()
  //                | t when t = typeof<obj> -> ()
  //                | bt -> gather bt
  //
  //            do gather t
  //
  //            gathered.Value |> Map.toArray |> Array.map snd
  
  
  
  //        type ShallowObjectCopier private () =
  //            
  //            static let mkCopier (t : Type) =
  //                if t.IsValueType then invalidOp t.FullName "not a class."
  //
  //                let fields = gatherFields t
  //#if EMIT_IL
  //                let dele =
  //                    DynamicMethod.compileAction2<obj, obj> "shallowCopier" (fun source target ilGen ->
  //                        for f in fields do
  //                            target.Load()
  //                            source.Load()
  //                            ilGen.Emit(OpCodes.Ldfld, f)
  //                            ilGen.Emit(OpCodes.Stfld, f)
  //
  //                        ilGen.Emit OpCodes.Ret
  //                    )
  //
  //                fun (src : obj) (tgt : obj) -> dele.Invoke(src,tgt)
  //#else
  //                fun src dst ->
  //                    for f in fields do
  //                        let v = f.GetValue(src)
  //                        f.SetValue(dst, v)
  //#endif
  //            static let mkCopierMemoized = memoize mkCopier
  //
  //            static member Copy (t : Type) (source : obj) (target : obj) = 
  //                mkCopierMemoized t source target
  
  
  
  
  //
  //        // .NET 4.0 backwards compatibility
  //
  //        [<Sealed>]
  //        type NonClosingStreamWrapper(s: Stream) =
  //            inherit Stream()
  //
  //            let mutable closed = false
  //            let ns () = raise (NotSupportedException())
  //
  //            let cc () =
  //                if closed then
  //                    raise <| ObjectDisposedException("Stream has been closed or disposed")
  //
  //            override w.BeginRead(a, b, c, d, e) = cc (); s.BeginRead(a, b, c, d, e)
  //            override w.BeginWrite(a, b, c, d, e) = cc (); s.BeginWrite(a, b, c, d, e)
  //
  //            override w.Close() =
  //                if not closed then
  //                    s.Flush()
  //                    closed <- true
  //
  //            override w.CreateObjRef(t) = ns ()
  //            override w.EndRead(x) = cc (); s.EndRead(x)
  //            override w.EndWrite(x) = cc (); s.EndWrite(x)
  //            override w.Flush() = cc (); s.Flush()
  //            override w.InitializeLifetimeService() = ns ()
  //            override w.Read(a, b, c) = cc (); s.Read(a, b, c)
  //            override w.ReadByte() = cc (); s.ReadByte()
  //            override w.Seek(a, b) = cc (); s.Seek(a, b)
  //            override w.SetLength(a) = cc (); s.SetLength(a)
  //            override w.Write(a, b, c) = cc (); s.Write(a, b, c)
  //            override w.WriteByte(a) = cc (); s.WriteByte(a)
  //            override w.CanRead = if closed then false else s.CanRead
  //            override w.CanSeek = if closed then false else s.CanSeek
  //            override w.CanTimeout = if closed then false else s.CanTimeout
  //            override w.CanWrite = if closed then false else s.CanWrite
  //            override w.Length = cc (); s.Length
  //
  //            override w.Position
  //                with get () = cc (); s.Position
  //                and set x = cc (); s.Position <- x
  //
  //            override w.ReadTimeout = cc (); s.ReadTimeout
  //            override w.WriteTimeout = cc (); s.WriteTimeout
  //
  //        type BinaryWriter with
  //            static member Create(output: Stream, encoding: Encoding, leaveOpen: bool) =
  //#if NET40
  //#else
  //                if isDotNet45OrNewer then
  //                    new BinaryWriter(output, encoding, leaveOpen)
  //                else
  //#endif
  //                if leaveOpen then
  //                    new BinaryWriter(new NonClosingStreamWrapper(output), encoding)
  //                else
  //                    new BinaryWriter(output, encoding)
  //
  //        type BinaryReader with
  //            static member Create(output: Stream, encoding: Encoding, leaveOpen: bool) =
  //#if NET40
  //#else
  //                if isDotNet45OrNewer then
  //                    new BinaryReader(output, encoding, leaveOpen)
  //                else
  //#endif
  //                if leaveOpen then
  //                    new BinaryReader(new NonClosingStreamWrapper(output), encoding)
  //                else
  //                    new BinaryReader(output, encoding)
negative.code:         // as suggested in http://stackoverflow.com/a/8543850
          let isDotNet45OrNewer =
              lazy(Type.GetType("System.Reflection.ReflectionContext") <> null)
  
          /// stackless raise operator
          let inline raise (e: System.Exception) = (# "throw" e : 'U #)
  