return newBuilder;
  }

  /**
   * Specifies the order of iteration for the elements of {@link ValueGraph#edges()}, {@link
   * ValueGraph#adjacentNodes(Object)}, {@link ValueGraph#predecessors(Object)}, {@link
   * ValueGraph#successors(Object)} and {@link ValueGraph#incidentEdges(Object)}.
   *
   * <p>The default value is {@link ElementOrder#unordered() unordered} for mutable graphs. For

    return newBuilder;
  }

  /**
   * Specifies the order of iteration for the elements of {@link Graph#edges()}, {@link
   * Graph#adjacentNodes(Object)}, {@link Graph#predecessors(Object)}, {@link
   * Graph#successors(Object)} and {@link Graph#incidentEdges(Object)}.
   *
   * <p>The default value is {@link ElementOrder#unordered() unordered} for mutable graphs. For

	"testing"
)

// Compare two Funcs for equivalence. Their CFGs must be isomorphic,
// and their values must correspond.
// Requires that values and predecessors are in the same order, even
// though Funcs could be equivalent when they are not.
// TODO(matloob): Allow values and predecessors to be in different
// orders if the CFG are otherwise equivalent.
func Equiv(f, g *Func) bool {
	valcor := make(map[*Value]*Value)

    Map<K, V> result = super.convertToHashFloodingResistantImplementation();
    links = null;
    return result;
  }

  /*
   * For discussion of the safety of the following methods for operating on predecessors and
   * successors, see the comments near the end of CompactHashMap, noting that the methods here call
   * link(), which is defined at the end of this file.
   */

  private int getPredecessor(int entry) {

    const TF::SideEffectAnalysis::Info& side_effect_analysis,
    std::function<std::string(Operation*)> get_target,
    const llvm::DenseMap<Operation*, Cluster*>& op_to_cluster_map) {
  // If any of the op's control predecessors appears after the last op in the
  // cluster, merging the op may cause control dependencies to be reordered.
  // Hence, the op cannot be merged to the cluster in such a case.
  const bool has_control_predecessors_after_cluster =

    return newBuilder;
  }

  /**
   * Specifies the order of iteration for the elements of {@link ValueGraph#edges()}, {@link
   * ValueGraph#adjacentNodes(Object)}, {@link ValueGraph#predecessors(Object)}, {@link
   * ValueGraph#successors(Object)} and {@link ValueGraph#incidentEdges(Object)}.
   *
   * <p>The default value is {@link ElementOrder#unordered() unordered} for mutable graphs. For

  return GetResourceSubtype(resource.getType());
}

// Updates uses of `old_read` to `new_partitioned_input` and `new_reads`.
// `old_partitioned_input` is the predecessor of `old_read`. `new_reads`
// contains the predecessors of `new_partitioned_input`.
LogicalResult UpdateReadUses(TF::ReadVariableOp old_read,
                             TF::TPUPartitionedInputV2Op old_partitioned_input,

			flag = end[b.Preds[0].b.ID]
			// Note: the following condition depends on the lack of critical edges.
			for _, e := range b.Preds[1:] {
				p := e.b
				if end[p.ID] != flag {
					f.Fatalf("live flag in %s's predecessors not consistent", b)
				}
			}
		}
		for _, v := range oldSched {
			if v.Op == OpPhi && v.Type.IsFlags() {
				f.Fatalf("phi of flags not supported: %s", v.LongString())
			}

	for k, b := range fun.blocks {
		if k[:1] == "z" && b.Kind != BlockInvalid {
			t.Errorf("case2 %s was not eliminated, but should have", k)
		}
	}

	// Case 3, empty blocks with multiple predecessors, z0 and z1 will be eliminated.
	//     entry
	//      |  \
	//      |  b0
	//      | /  \
	//      z0   z1
	//       \   /
	//       exit
	fun = c.Fun("entry",
		Bloc("entry",

	idom := f.Idom()
	po := f.postorder()
	// The ordering in the dominator tree matters; it's important that
	// the walk of the dominator tree also be a preorder (i.e., a node is
	// visited only after all its non-backedge predecessors have been visited).
	sdom := newSparseOrderedTree(f, idom, po)

	if f.pass.debug > 1 {
		fmt.Printf("before %s = %s\n", f.Name, sdom.treestructure(f.Entry))
	}

	tofixBackedges := []edgeMem{}