anchor.diff:          let initBaseEndFromLength b k = 
               [0..k-1] |> List.fold (fun state i -> state*b) 1
               
  -
  +        ///adds a hashvalue to an existing hashvalue
           let addToHash b cHashvalue c =
               b*cHashvalue + hash c
   
  -
  +        ///hashes a pattern
           let blockHash b (pattern:array<'a>) =
               pattern |> Array.fold (fun state c -> addToHash b state c) 0
   
  -
  +        ///updates an existing hashvalue 
           let updateHash b bK cHashvalue inchar outchar =
               b*cHashvalue + (hash inchar) - bK * (hash outchar)
   
  -
  +        ///finds all matches of a query pattern in a source
           let findAll (pattern : array<'a>) (s : array<'a>) = 
               findAllGeneric (updateHash 31 (initBaseEndFromLength 31 pattern.Length)) (blockHash 31) pattern s 
           
  -
  +        ///finds the first match of a query pattern in a source starting from a specific position in the source
           let findFrom (startPos:int) (pattern : array<'a>) (s : array<'a>) =
               findFromGeneric startPos (updateHash 31 (initBaseEndFromLength 31 pattern.Length)) (blockHash 31) pattern s 
   
  -
  +        ///finds the first match of a query pattern in a source
           let find (pattern : array<'a>) (s : array<'a>) =
               findFrom 0 pattern s
   
   
  +    ///A collection of Rabin-Karp string matching algorithms using the cyclic polynomial (CP) hash
       module CP = 
  -        
  +
  +        ///bitwise cyclic rotation of a 64 bit pattern
           let inline rotateLeft r x  = (x <<< r) ||| (x >>> (64 - r))
   
   
  +        ///adds a hashvalue to an existing hashvalue
           let inline addToHashValue hs inchar =
               (rotateLeft 1 hs) ^^^ (uint64 inchar)
   
   
  +        ///hashes a pattern
           let inline blockHash (pattern : array<'a>) =
               let m = pattern.Length
               let rec loop i hs =
  
positive.code:         if s.Length > 0 then loop 0 0 0 [] else []
  
  
      let findFrom (startPos : int) (pattern : array<'a>) (s : array<'a>) =
          let rec loop (sPos:int) (patternPos:int) (matchCount:int) =
              if sPos < s.Length then
  
negative.code:             loop 0 0UL
  
  
          ///updates an existing hashvalue 
          let inline updateHash pLength hs inchar outchar =
              let z = (rotateLeft pLength (uint64 outchar)) 
              (rotateLeft 1 hs) ^^^ z ^^^ (uint64 inchar)
  
  
          ///find all matches of a query pattern in a source   
          let inline findAll (pattern : array<'a>) (s : array<'a>) = 
              findAllGeneric (updateHash pattern.Length) (blockHash) pattern s 
          
  
          ///find the first match of a query pattern in a source starting from a specific position in the source
          let inline findFrom (startPos:int) (pattern : array<'a>) (s : array<'a>) =
              findFromGeneric startPos (updateHash pattern.Length) (blockHash) pattern s 
  
  
          ///find the first match of a query pattern in a source
          let inline find (pattern : array<'a>) (s : array<'a>) =
              findFrom 0 pattern s
      
  ///A collection of Knuth-Morris-Pratt string matching algorithms
  module KnuthMorrisPratt = 
  
      ///creates a prefix table for a query pattern
      let createPrefixTable (pattern : array<'a>) =
          let prefixTable = Array.zeroCreate pattern.Length
  
  