anchor.diff:      
   type Any private() =
       static let regs = Runner.init.Force()
  +
  +    ///Build a generator that generates a value from one of the generators in the given non-empty seq, with
  +    ///equal probability.
       static member private OneOfSeqGen gs = 
           gs |> Seq.toList |> oneof
  +
  +    ///Build a generator that randomly generates one of the values in the given non-empty seq.
       static member private OneOfSeqValue vs = 
           vs |> Seq.toList |> elements
  +
  +    ///Sequence the given list of generators into a generator of a list.
       static member private SequenceSeq<'a> gs = 
           gs |> Seq.toList |> sequence |> map (fun list -> new List<'a>(list))
  +
  +    /// Returns a generator for the type argument
       static member OfType<'a>() = 
           from<'a>.Generator
  +
  +    /// Generate a constant value
       static member Value (value) = 
           constant value
  +
  +    ///Build a generator that randomly generates one of the values in the given non-empty seq.
       static member ValueIn (values : seq<_>) = 
           values |> Any.OneOfSeqValue
  +
  +    ///Build a generator that randomly generates one of the values in the given non-empty seq.
       static member ValueIn ([<ParamArrayAttribute>] values : array<_>) = 
           values |> Any.OneOfSeqValue
  +
  +    ///Generates an integer between l and h, inclusive.
       static member IntBetween (l,h) = 
           choose (l,h)
  +
  +    ///Build a generator that generates a value from one of the generators in the given non-empty seq, with
  +    ///given probabilities. The sum of the probabilities must be larger than zero.
       static member WeighedValueIn ( weighedValues : seq<WeightAndValue<'a>> ) =
           weighedValues |> Any.OneOfWeighedSeqValue
  +
  +    ///Build a generator that generates a value from one of the constants in the given non-empty seq, with
  +    ///given probabilities. The sum of the probabilities must be larger than zero.
       static member WeighedValueIn ( [<ParamArrayAttribute>] weighedValues : array<WeightAndValue<'a>> ) =
           weighedValues |> Any.OneOfWeighedSeqValue
  +
  +    ///Build a generator that generates a value from one of the constants in the given non-empty seq, with
  +    ///given probabilities. The sum of the probabilities must be larger than zero.
       static member private OneOfWeighedSeqValue ws = 
           ws |> Seq.map (fun wv -> (wv.Weight, constant wv.Value)) |> Seq.toList |> frequency
  +
  +    ///Build a generator that generates a value from one of the generators in the given non-empty seq, with
  +    ///equal probability.
       static member GeneratorIn (generators : seq<Gen<_>>) = 
           generators |> Any.OneOfSeqGen
  +
  +    ///Build a generator that generates a value from one of the generators in the given non-empty seq, with
  +    ///equal probability.
       static member GeneratorIn ([<ParamArrayAttribute>]  generators : array<Gen<_>>) = 
           generators |> Any.OneOfSeqGen
  +
  +    ///Build a generator that generates a value from one of the generators in the given non-empty seq, with
  +    ///given probabilities. The sum of the probabilities must be larger than zero.
       static member WeighedGeneratorIn ( weighedValues : seq<WeightAndValue<Gen<'a>>> ) =
           weighedValues |> Any.OneOfWeighedSeq
  +
  +    ///Build a generator that generates a value from one of the generators in the given non-empty seq, with
  +    ///given probabilities. The sum of the probabilities must be larger than zero.
       static member WeighedGeneratorIn ( [<ParamArrayAttribute>] weighedValues : array<WeightAndValue<Gen<'a>>> ) =
           weighedValues |> Any.OneOfWeighedSeq
  +
  +    ///Build a generator that generates a value from one of the generators in the given non-empty seq, with
  +    ///given probabilities. The sum of the probabilities must be larger than zero.
       static member private OneOfWeighedSeq ws = 
           ws |> Seq.map (fun wv -> (wv.Weight, wv.Value)) |> Seq.toList |> frequency
  +
  +    ///Sequence the given list of generators into a generator of a list.
       static member SequenceOf<'a> (generators:seq<Gen<'a>>) = 
           generators |> Any.SequenceSeq
  +
  +    ///Sequence the given list of generators into a generator of a list.
       static member SequenceOf<'a> ([<ParamArrayAttribute>]generators:array<Gen<'a>>) = 
           generators |> Any.SequenceSeq
  +
       static member OfSize (sizedGen : Func<int,Gen<_>>) =
           sized <| fun s -> (sizedGen.Invoke(s))
   
   
   type Shrink =
  +    ///Returns the immediate shrinks for the given value based on its type.
       static member Type<'a>() = shrink<'a>
   
   //mutable counterpart of the Config type
  
positive.code:     override x.ToString() = base.ToString()
      [<EditorBrowsable(EditorBrowsableState.Never)>]
      abstract Build : unit -> Property
      member x.QuickCheck() = Check.Quick(x.Build())
      member x.QuickCheckThrowOnFailure() = Check.QuickThrowOnFailure(x.Build())
      member x.VerboseCheck() = Check.Verbose(x.Build())
      member x.QuickCheck(name:string) = Check.Quick(name,x.Build())
      member x.QuickCheckThrowOnFailure(name:string) = Check.QuickThrowOnFailure(name,x.Build())
      member x.VerboseCheck(name:string) = Check.Verbose(name,x.Build())
      member x.Check(configuration:Configuration) = Check.One(configuration.ToConfig(),x.Build())
  
  and SpecBuilder<'a> internal   ( generator0:'a Gen
  
negative.code:             forAll (Arb.fromGenShrink(generator0,shrinker0)) (fun a -> (conditions' a) ==> lazy (assertion0 a) |> collects' a |> classifies' a)
      member x.When( condition:Func<'a,bool> ) = 
          SpecBuilder<'a>(generator0, shrinker0, assertion0, (fun a -> condition.Invoke(a))::conditions, collects, classifies)
  
      ///Collect data values. The argument of collect is evaluated in each test case, 
      ///and the distribution of values is reported.
      member x.Collect(collectedValue:Func<'a,string>)=
          SpecBuilder<'a>(generator0, shrinker0,assertion0,conditions,(fun a -> collectedValue.Invoke(a))::collects,classifies)
  
      member x.Classify(filter:Func<'a,bool>,name:string) =
          SpecBuilder<'a>(generator0, shrinker0,assertion0,conditions,collects,((fun a -> filter.Invoke(a)),name)::classifies)
      member x.Shrink(shrinker:Func<'a,'a seq>) =
          SpecBuilder<'a>( generator0, shrinker.Invoke, assertion0, conditions, collects, classifies)
      member x.Label( name:string ) =
          SpecBuilder<'a>(generator0, shrinker0, label name << assertion0,conditions, collects, classifies)
  
      ///Construct a property that succeeds if both succeed.
      member x.And(assertion : Func<'a,bool>) =
          SpecBuilder<'a>( generator0, shrinker0, (fun a -> (assertion0 a) .&. (assertion.Invoke(a))), conditions, collects, classifies)
  
      ///Construct a property that succeeds if both succeed.
      member x.And(assertion : Func<'a,bool>, name:string ) =
          SpecBuilder<'a>( generator0, shrinker0, (fun a -> (assertion0 a) .&. (label name (assertion.Invoke(a)))), conditions, collects, classifies)
  
      ///Construct a property that fails if both fail.
      member x.Or(assertion : Func<'a,bool>) =
          SpecBuilder<'a>( generator0, shrinker0, (fun a -> (assertion0 a) .|. (assertion.Invoke(a))), conditions, collects, classifies)
  
      ///Construct a property that fails if both fail.
      member x.Or(assertion : Func<'a,bool>, name:string ) =
          SpecBuilder<'a>( generator0, shrinker0, (fun a -> (assertion0 a) .|. (label name (assertion.Invoke(a)))), conditions, collects, classifies)
      member x.AndFor<'b>(generator:'b Gen, assertion:Func<'b,bool>) =
  