anchor.diff:          | Some x ->
               x :: list
   
  +
  +    (* Simple functions *)
  +
       /// Swaps the values of a tuple so their order is reversed.
       [<CompiledName("Swap")>]
       let inline swap (x : 'T, y : 'U) =
  
positive.code:                 else
                      this.Array.[this.Offset + index] <- value
  
      /// Type abbreviation for System.Collections.Generic.Queue.
      type ResizeQueue<'T> = System.Collections.Generic.Queue<'T>
  
      /// Physical equality operator.
      let inline (===) (x : 'T) y =
  
negative.code: 
          if mapped_x < mapped_y then mapped_y else mapped_x
  
      (*
      #if PROTO_COMPILER
      /// Returns the RuntimeTypeHandle of the specified type.
      [<NoDynamicInvocation>]
      let inline typehandleof<'T> : System.RuntimeTypeHandle =
          let tok = (# "ldtoken !0" type('T) : System.RuntimeTypeHandle #)
          tok
      #endif
      *)
  
      (* Exception-related functions *)
  
      /// Raises a new exception of the specified type.
      [<CompiledName("RaiseNew")>]
      let inline raiseNew<'T when 'T :> exn and 'T : (new : unit -> 'T)> () : 'T =
          raise <| new 'T()
  
      /// Raises a System.NotImplementedException.
      [<CompiledName("RaiseNotImplementedException")>]
      let inline notImpl msg : 'T =
          raise <| System.NotImplementedException msg
  
      /// Raises a System.NotSupportedException.
      [<CompiledName("RaiseNotSupportedException")>]
      let inline notSupported msg : 'T =
          raise <| System.NotSupportedException msg
  
      /// Raises a System.ArgumentOutOfRangeException.
      [<CompiledName("RaiseArgumentOutOfRangeException")>]
      let inline argOutOfRange (paramName : string) (message : string) : 'T =
          raise <| System.ArgumentOutOfRangeException (paramName, message)    
  
      /// Determines if a reference is a null reference, and if it is, throws an ArgumentNullException.
      [<CompiledName("CheckNonNull")>]
      let inline checkNonNull< ^T when ^T : not struct> argName (value : ^T) =
          if isNull value then
              nullArg argName
  
      /// Raises a System.Collections.Generic.KeyNotFoundException.
      [<CompiledName("RaiseKeyNotFoundException")>]
      let inline keyNotFound (msg : string) : 'T =
          raise <| System.Collections.Generic.KeyNotFoundException msg
      
  
  /// Functional operators on enumerations.
  [<RequireQualifiedAccess; CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
  module Enum =
      /// Returns an array of the values defined by an enumeration type.
      [<CompiledName("GetValuesImpl")>]
      let inline private valuesImpl<'Enum, 'T when 'Enum : enum<'T>> (enumType : System.Type) =
          System.Enum.GetValues enumType
          :?> 'Enum[]
  
      /// Returns an array of the values defined by an enumeration type.
      [<CompiledName("GetValues")>]
      let inline values () : ^Enum[] =
          valuesImpl< ^Enum, _> typeof<'Enum>
  
      /// Alias for System.Enum.IsDefined.
      [<CompiledName("IsDefinedImpl")>]
  