anchor.diff:          let fieldDelimChars = fieldDelim.ToCharArray()
           let isSingleCharFieldDelim = fieldDelimChars.Length = 1
           let charFieldDelim = fieldDelimChars.[0]
  -    
  -        member x.FieldDelimiter:string = fieldDelim
  -        member x.RowDelimiter:string = rowDelim
  -        member x.HonorQuotedFields:bool = honorQuotes
  -        member x.FieldLast = fieldLast
  -        member x.RowLast = rowLast
  -        member x.RowFirstChar = rowFirstChar
  -        member x.RowDelimChars = rowDelimChars
  -        member x.IsRowDelimNewline = isRowDelimNewline
  -        member x.FieldDelimChars = fieldDelimChars
  -        member x.IsSingleCharFieldDelim = isSingleCharFieldDelim
  -        member x.CharFieldDelim = fieldDelimChars.[0]
  -
  -
  -    let defaultSettings = new ParseSettings(",",System.Environment.NewLine,true)
  -
  -    type ParseState(stream:System.Collections.Generic.IEnumerator<char>,settings:ParseSettings,field:char list,currentChar:char,lastChar:char,isInQuotes:bool, delimMatcher:char->ParseState->CharMatch)= 
  -        let mutable myStream = stream
  -        let mutable myField = field
  -        let mutable myCurrentChar = currentChar
  -        let mutable myLastChar = lastChar
  -        let mutable myIsInQuotes = isInQuotes
  -        let stringBuilder = new System.Text.StringBuilder()
  -
  -        member x.Stream 
  -            with get() = myStream
  -            and  set(v) = myStream <- v
  - 
  -        member x.Settings = settings
  -    
  -        member x.Field = myField 
  -            //and set(v) = myField <- v
  -    
  -        member x.CurrentChar 
  -            with get() = myCurrentChar 
  -            and  set(v) = myCurrentChar <- v
  -
  -        member x.LastChar 
  -            with get() = myLastChar 
  -            and  set(v) = myLastChar <- v
  -
  -        member x.IsInQuotes 
  -            with get() = myIsInQuotes 
  -            and  set(v) = myIsInQuotes <- v
  -    
  -        member x.DelimMatcher = delimMatcher
  -
  -        member x.FieldString = stringBuilder.ToString()
  -
  -        member x.AddCharacter c = 
  -            myField <- c :: myField
  -            stringBuilder.Append(c) |> ignore
  -    and CharMatch =
  -        | NoMatch
  -        | Field
  -        | Row
  -        | Skip
  -
  -    type FieldBounrdy =
  -        | EndOfField
  -        | EndOfRow
  -        | EndOfFile
  -
  -    type charSequence(stream:System.IO.Stream,encoding:System.Text.Encoding option) =
  -        let buffersize = 0x80000
  -        let reader = 
  -            match encoding with
  -                | None -> new System.IO.StreamReader(stream,true)
  -                | Some(e) -> new System.IO.StreamReader(stream,e)
  -        let buffer = Array.init(buffersize)(fun i -> char(0))
  -    
  -        let mutable currentIdx = 0
  -        let mutable maxIdx = 0
  -
  -        let reloadBuffer size=
  -            maxIdx <- reader.Read(buffer,0,size)
  -            if maxIdx > 0 then
  -                currentIdx <- 0
  -                true
  -            else
  -                false
  -
  -        member e.Peek = 
  -            if currentIdx + 1 = maxIdx then
  -                if reloadBuffer buffersize then
  -                    buffer.[currentIdx + 1]
  -                else
  -                    failwith "Reached end of file"
  -            else
  -                buffer.[currentIdx + 1]
  -        
  -        interface System.Collections.Generic.IEnumerator<char> with
  -            member e.MoveNext() = 
  -                    let nextIdx = currentIdx + 1
  -                    if (nextIdx) < maxIdx then
  -                        currentIdx <- nextIdx
  -                        true
  -                    else
  -                        reloadBuffer buffersize
  -
  -            member e.Dispose() = reader.Dispose()
  -            member e.Reset() = 
  -                currentIdx <- 0
  -                maxIdx <- 0
  -            member e.Current with get() = buffer.[currentIdx]
  -            member e.Current with get() = box(buffer.[currentIdx])    
  -
  -
  -    let getField (stream) (settings:ParseSettings) =     
  -        let matchesNewLine (c:char) = 
  -            match c with 
  -               | '\r' -> true
  -               | '\n' -> true
  -               | _ -> false
  -
  -        let rec segmentMatches (list1:char list) (list2:char array) = 
  +
  +        let simpleMatch (list1:char list) (list2:char array) = 
  +            list1.Head = list2.[0]
  +
  +        let segmentMatches (list1:char list) (list2:char array) = 
               let rec comp (l1:char list) (l2:char array) (idx:int) (max:int) = 
                   let next = idx + 1
                   match next with 
  
positive.code:                 list1.Head = list2.[0]
              else
                  (comp (list1) (list2) 0 len)
  
          let delimiterMatcher = 
              if settings.IsSingleCharFieldDelim && settings.IsRowDelimNewline then
  
negative.code:                 fun (c:char) (s:ParseState) ->
                      match c with
                          | x when x = settings.CharFieldDelim -> Field
                          | _ when settings.RowSegmentMatcher (c :: s.Field) (settings.RowDelimChars) -> Row
                          | _ -> NoMatch
              else
                  fun (c:char) (s:ParseState) -> 
                      match c with
                          | x when x = settings.FieldLast && 
                                  settings.FieldSegmentMatcher (c :: s.Field) (settings.FieldDelimChars) -> Field
                          | x when x = settings.RowLast ->
                              match (settings.RowFirstChar) with
                                  | _ when settings.RowSegmentMatcher (c :: s.Field) (settings.RowDelimChars) -> Row
                                  | _ -> NoMatch
                          | _ -> NoMatch
  
  