anchor.diff:          sb.Append("_") |> ignore
           sb.AppendJoin("_", args, (parameterElement api variableMemory))
               .Append("_")
  -      | Variable (_, v) -> 
  -            match api.Kind with
  -            | ApiKind.ExtensionMember when isGenericMember api ->
  -                sb.Append("__").Append(variableMemory.[v.Name])
  -
  -            | ApiKind.Member(_ , _) when isGenericMember api ->
  -                match api.Signature with
  -                | ApiSignature.InstanceMember(_, mem)
  -                | ApiSignature.StaticMember(_,mem)  -> 
  -                    if mem.GenericParameters |> List.exists(fun x -> x.Name = v.Name) then
  -                        sb.Append("__").Append(variableMemory.[v.Name])
  -                    else
  -                        sb.Append("_").Append(variableMemory.[v.Name])
  -                | _ -> 
  -                    sb.Append("__").Append(variableMemory.[v.Name])
  -
  -            | _ -> sb.Append("_").Append(variableMemory.[v.Name])
  +      | Variable (_, v) -> sb.Append(variableMemory.[v.Name])
         | Delegate (d, _) -> sb.Append(parameterElement api variableMemory d)
         | AbbreviationRoot root -> sb.Append(parameterElement api variableMemory root)
         | _ -> sb
  
positive.code:       | [] | [ [ { Type = Unit } ] ] -> false
        | _ -> true
  
      let hashPart (nameElems: string[]) (variableMemory: Dictionary<_, _>) (member': Member) (api: Api) (sb: StringBuilder) =
        let nameElems = nameElems |> Seq.map (fun n -> n.Replace("-", "_"))
        
        sb.AppendJoin("_", nameElems) |> ignore
  
negative.code:     open System.Collections.Generic
      open System.Text
  
      type VariableMemory = Dictionary<string, string>
  
      let variableId (kind: ApiKind) (name: DisplayName) =
        let variableMemory = VariableMemory()
        let memory (prefix: string) (n: DisplayNameItem) =
          n.GenericParameters
          |> List.iteri (fun variableId p ->
            let variable = p.Name
            if variableMemory.ContainsKey(variable) = false then
              variableMemory.[variable] <- prefix + string variableId
          )
          
        match kind with
        | ApiKind.TypeDefinition ->
          name |> List.iter (memory "_")
        | _ ->
          name.Head |> memory "__"
          name.Tail |> List.iter (memory "_")
        variableMemory
  
      let nameElementsAndVariableId (api: Api) =
        let convert (modifiedString: string) ((wroteGeneric, result): bool * string list) (name: DisplayNameItem) =
          if wroteGeneric = false && name.GenericParameters.IsEmpty = false then
            let result = (urlName name + modifiedString + string name.GenericParameters.Length) :: result
            true, result
          else
            let result = urlName name :: result
            (wroteGeneric, result)
        
        let name = Name.toDisplayName api.Name
  
        let kind = api.Kind
  
        let elems =
          let initState = false, []
          [|
            match kind with
            | ApiKind.TypeDefinition ->
              yield! name |> Seq.rev |> Seq.fold (convert "-") initState |> snd |> Seq.rev
            | ApiKind.Constructor ->
              yield! name.Tail |> Seq.rev |> Seq.fold (convert "-") initState |> snd |> Seq.rev
              yield "-ctor"
            | _ ->
              yield! name.Tail |> Seq.rev |> Seq.fold (convert "-") initState |> snd |> Seq.rev
              yield! convert "--" initState name.Head |> snd
          |]
  
        let variableMemory = variableId kind name
        elems, variableMemory
  
      let urlPart elems (sb: StringBuilder) =
        let elems = elems |> Seq.map toLower
        sb.AppendJoin(".", elems)
  
      let rec parameterElement (api: Api) (variableMemory: VariableMemory) (t: LowType) (sb: StringBuilder) : StringBuilder =
        match t with
        | Unit -> sb
        | Identity (FullIdentity { Name = name }) ->
  