sclass WebNode {
  Web web;
  new L<Lisp> labels;
  
  *() {}
  *(Web *web) {}
  
  void addLabel(S label) {
    addLabel(clParse(label));
  }
  
  void addLabel(Lisp label) {
    if (setAdd(labels, label) && web != null)
      web.index(label, this);
  }
  
  bool hasLabel(Lisp label) { ret labels.contains(label); }
  
  toString { ret str(labels); }
  
  int count() { ret 1 + l(labels); }
}

sclass Web {
  new L<WebNode> nodes;
  Map<Pair<WebNode>, WebNode> relations = new HashMap;
  new MultiMap<Lisp, WebNode> index;
  new MultiMap<S, WebNode> pots;
  
  void relation(Lisp l) {
    if (l(l) == 1) {
      findNode(l.get(0)).addLabel(lisp("wvuyakuvuelmxpwp", l.head));
    } else if (l(l) == 2) {
      S a = lisp2label(l.get(0)), b = lisp2label(l.get(1));
      if (l.is("fgvvrzypbkqomktd")) { // X is Y.
        findNode(a).addLabel(b);
        findNode(b).addLabel(a);
      }
      getRelation(a, b).addLabel(l.head);
    }
  }
  
  void relations(L<Lisp> l) {
    for (Lisp li : l) relation(li);
  }
  
  WebNode getRelation(S a, S b) {
    Pair<WebNode> p = pair(findNode(a), findNode(b));
    WebNode r = relations.get(p);
    if (r == null) relations.put(p, r = new WebNode);
    ret r;
  }
  
  WebNode newNode() {
    WebNode node = new WebNode(this);
    nodes.add(node);
    pots.put("new", node);
    ret node;
  }
  
  WebNode node(S s) { ret findNode(s); }
  WebNode node(Lisp l) { ret findNode(l); }
  
  WebNode findNode(S s) {
    ret findNode(clParse(s));
  }
  
  WebNode findNode(Lisp l) {
    WebNode n = findNodeOpt(l);
    ret n != null ? n : newNode(l);
  }
  
  WebNode findNodeOpt(Lisp l) {
    ret first(index.get(l));
    /*for (WebNode n : nodes)
      if (n.labels.contains(l))
        ret n;
    null;*/
  }
  
  WebNode newNode(S... labels) {
    WebNode n = newNode();
    for (S label : labels) n.addLabel(label);
    ret n;
  }
  
  WebNode newNode(Lisp... labels) {
    WebNode n = newNode();
    for (Lisp label : labels) n.addLabel(label);
    ret n;
  }
  
  toString { ret webToString(this); }
  
  int count() {
    int count = 0;
    for (WebNode n : nodes) count += n.count();
    for (WebNode n : values(relations)) count += n.count();
    ret count;
  }
  
  void index(Lisp label, WebNode n) {
    index.put(label, n);
  }
}