anchor.diff:            rightTypes, leftTypes
         (Array.ofSeq s, Array.ofSeq l)
   
  -    let result =
  -      if short.Length <> long.Length && containsWildcard long then
  -        Debug.WriteLine("There is a wildcard.")
  -        None
  +    let complementNumber = long.Length - short.Length
  +    if complementNumber > complementNumberLimit then
  +      Failure
  +    elif short.Length <> long.Length && containsWildcard long then
  +      Debug.WriteLine("There is a wildcard.")
  +      Failure
  +    else
  +      let mutable continue' = true
  +      let mutable state = ctx, Array.empty, long, 0
  +      let enum = (short :> seq<_>).GetEnumerator()
  +      while continue' && enum.MoveNext() do
  +        let testee = enum.Current
  +        let ctx, back, forward, swapNumber = state
  +        Debug.WriteLine(sprintf "Test %s" (testee.Debug()))
  +        Debug.Indent()
  +        let result = contains lowTypeMatcher testee back forward ctx
  +        Debug.Unindent()
  +        match result with
  +        | Some (ctx, back, forward, swapped)  ->
  +          let swapNumber = swapNumber + swappedToInt swapped
  +          state <- ctx, back, forward, swapNumber
  +          continue' <- not (swapNumber > swapNumberLimit)
  +        | None ->
  +          continue' <- false
  +      if continue' then
  +        let ctx, _, _, swapNumber = state
  +        Matched (ctx |> Context.addDistance "swap and complement" (swapNumber + complementNumber))
         else
  -        short
  -        |> Array.fold (fun state testee ->
  -          match state with
  -          | None -> None
  -          | Some (ctx, back, forward, swapNumber) ->
  -            Debug.WriteLine(sprintf "Test %s" (testee.Debug()))
  -            Debug.Indent()
  -            let result =
  -              contains lowTypeMatcher testee back forward ctx
  -              |> Option.map (fun (ctx, back, forward, swapped) -> (ctx, back, forward, swapNumber + swappedToInt swapped))
  -            Debug.Unindent()
  -            result
  -        ) (Some (ctx, Array.empty, long, 0))
  -
  -    match result with
  -    | Some (ctx, back, forward, swapNumber) ->
  -      let complementNumber = back.Length + forward.Length
  -      if swapNumber > swapNumberLimit then
           Failure
  -      elif complementNumber > complementNumberLimit then
  -        Failure
  -      else
  -        Matched (ctx |> Context.addDistance "swap and complement" (swapNumber + complementNumber))
  -    | None -> Failure
   
     let testAllExactly (lowTypeMatcher: ILowTypeMatcher) (leftTypes: LowType seq) (rightTypes: LowType seq) (ctx: Context): MatchingResult =
       Debug.WriteLine(sprintf "Test %A and %A." (Seq.map LowType.debug leftTypes |> Seq.toList) (Seq.map LowType.debug rightTypes |> Seq.toList))
  
positive.code:       Debug.WriteLine("The numbers of the parameters are different.")
        Failure
      else
        Seq.zip leftTypes rightTypes
        |> Seq.fold (fun result (left, right) ->
          Debug.WriteLine(sprintf "Test %s and %s." (LowType.debug left) (LowType.debug right))
          Debug.Indent()
          let result = MatchingResult.bindMatched (lowTypeMatcher.Test left right) result
          Debug.Unindent()
          result
        ) (Matched ctx)
  
    let choiceRule (lowTypeMatcher: ILowTypeMatcher) left right ctx =
      match left, right with
  
negative.code:                 (LowType.debug right)
                  (List.map Equations.debugEquality leftEqualities))
        let result =
          testLeftEqualities lowTypeMatcher leftEqualities right ctx
          |> MatchingResult.bindMatched (Equations.tryAddEquality left right)
        Debug.WriteLine(
          match result with
  