anchor.diff:  
           [<CompiledName("Sum")>]
           let inline sum (source: seq< (^a) >) : ^a = 
  +            use e = source.GetEnumerator() 
               let mutable acc = LanguagePrimitives.GenericZero< (^a) >
  -            for item in source do
  -                acc <- Checked.(+) acc item
  +            while e.MoveNext() do
  +                acc <- Checked.(+) acc e.Current
               acc
   
           [<CompiledName("SumBy")>]
           let inline sumBy (f : 'T -> ^U) (source: seq<'T>) : ^U = 
  +            use e = source.GetEnumerator() 
               let mutable acc = LanguagePrimitives.GenericZero< (^U) >
  -            for item in source do
  -                acc <- Checked.(+) acc (f item)
  +            while e.MoveNext() do
  +                acc <- Checked.(+) acc (f e.Current)
               acc
   
           [<CompiledName("Average")>]
           let inline average (source: seq< (^a) >) : ^a = 
               checkNonNull "source" source
  +            use e = source.GetEnumerator()     
               let mutable acc = LanguagePrimitives.GenericZero< (^a) >
               let mutable count = 0
  -            for item in source do
  -                acc <- Checked.(+) acc item
  +            while e.MoveNext() do
  +                acc <- Checked.(+) acc e.Current
                   count <- count + 1
  -            if count = 0 then
  +            if count = 0 then 
                   invalidArg "source" LanguagePrimitives.ErrorStrings.InputSequenceEmptyString
               LanguagePrimitives.DivideByInt< (^a) > acc count
   
           [<CompiledName("AverageBy")>]
           let inline averageBy (f : 'T -> ^U) (source: seq< 'T >) : ^U = 
               checkNonNull "source" source
  +            use e = source.GetEnumerator() 
               let mutable acc = LanguagePrimitives.GenericZero< (^U) >
               let mutable count = 0
  -            for item in source do
  -                acc <- Checked.(+) acc (f item)
  +            while e.MoveNext() do
  +                acc <- Checked.(+) acc (f e.Current)
                   count <- count + 1
               if count = 0 then 
                   invalidArg "source" LanguagePrimitives.ErrorStrings.InputSequenceEmptyString;
               LanguagePrimitives.DivideByInt< (^U) > acc count
               
           [<CompiledName("Min")>]
  -        let inline min (source: seq<'T>) = 
  -            checkNonNull "source" source
  -            let mutable hasValue = false
  -            let mutable acc = Unchecked.defaultof<_>
  -            for item in source do
  -              let curr = item
  -              if hasValue then
  -                if curr < acc then acc <- curr
  -              else
  -                acc <- curr
  -                hasValue <- true
  -            if not (hasValue) then 
  +        let inline min (source: seq<_>) = 
  +            checkNonNull "source" source
  +            use e = source.GetEnumerator() 
  +            if not (e.MoveNext()) then 
                   invalidArg "source" LanguagePrimitives.ErrorStrings.InputSequenceEmptyString;
  +            let mutable acc = e.Current
  +            while e.MoveNext() do
  +                let curr = e.Current 
  +                if curr < acc then 
  +                    acc <- curr
               acc
   
           [<CompiledName("MinBy")>]
  
positive.code:         let last (source : seq<_>) =
              checkNonNull "source" source
              use e = source.GetEnumerator() 
              if e.MoveNext() then
                  let mutable res = e.Current
                  while (e.MoveNext()) do res <- e.Current
                  res
  
negative.code: 
  *)
          [<CompiledName("Max")>]
          let inline max (source: seq<_>) = 
              checkNonNull "source" source
              use e = source.GetEnumerator() 
              if not (e.MoveNext()) then 
                  invalidArg "source" LanguagePrimitives.ErrorStrings.InputSequenceEmptyString;
              let mutable acc = e.Current
              while e.MoveNext() do
                  let curr = e.Current 
                  if curr > acc then 
                      acc <- curr
              acc
  
          [<CompiledName("MaxBy")>]
  