private void eliminateStaticAccess(ClassNode node) {

    if (node.type == ClassNode.CLASS_LAMBDA) {
      return;
    }

    for (MethodWrapper meth : node.getWrapper().getMethods()) {

      if (meth.root != null) {

        boolean replaced = false;

        DirectGraph graph = meth.getOrBuildGraph();

        HashSet<DirectNode> setVisited = new HashSet<>();
        LinkedList<DirectNode> stack = new LinkedList<>();
        stack.add(graph.first);

        while (!stack.isEmpty()) {  // TODO: replace with interface iterator?

          DirectNode nd = stack.removeFirst();

          if (setVisited.contains(nd)) {
            continue;
          }
          setVisited.add(nd);

          for (int i = 0; i < nd.exprents.size(); i++) {
            Exprent exprent = nd.exprents.get(i);

            replaced |= replaceInvocations(node, meth, exprent);

            if (exprent.type == Exprent.EXPRENT_INVOCATION) {
              Exprent ret = replaceAccessExprent(node, meth, (InvocationExprent)exprent);

              if (ret != null) {
                nd.exprents.set(i, ret);
                replaced = true;
              }
            }
          }

          stack.addAll(nd.successors);
        }

        if (replaced) {
          computeMethodType(node, meth);
        }
      }
    }

    for (ClassNode child : node.nested) {
      eliminateStaticAccess(child);
    }
  }
private void eliminateStaticAccess(ClassNode node)