#set ( $dummy = $allClasses.add( $class ) )
  #end
#end
#foreach ( $class in $allClasses )
  #set ( $ancestors = $Helper.ancestors( $class ) )
  #set ( $allFields = [] )
  #set ( $inheritedFields = [] )
  #foreach ( $cl in $ancestors )
    #if ( $cl != $class )
      #set ( $dummy = $inheritedFields.addAll( $cl.allFields ) )
    #end
    #set ( $dummy = $allFields.addAll( $cl.allFields ) )

     *
     * A file is contained in the set if it or one of its ancestors has
     * been added to the set.
     */
    public abstract boolean contains(File file);

    /**
     * Checks if the given path is contained in the set.
     *
     * A path is contained in the set if it or one of its ancestors has
     * been added to the set.
     */
    public abstract boolean contains(String path);

// If `use_external_constant` is true, it will create `tfl.external_const`
// instead of `tfl.const`.
// If `experimental_prune_unreachable_nodes_unconditionally` is true, nodes that
// are not ancestors of the output nodes will be pruned.
mlir::OwningOpRef<mlir::ModuleOp> FlatBufferToMlir(
    absl::string_view buffer, mlir::MLIRContext* context,
    mlir::Location base_loc, bool use_external_constant = false,

    visited.insert(item.cluster);

    stack.push_back({item.cluster, true});
    const auto& iter = ancestors.find(item.cluster);
    if (iter != ancestors.end()) {
      for (const auto& ancestor : iter->second) {
        stack.push_back({ancestor, false});
      }
    }
  }
  CHECK(sorted->size() == clusters.size());
}

}  // namespace

#set ( $package = "${packageModelV4}" )
#set ( $root = $model.getClass( $model.getRoot($version), $version ) )
#foreach ( $class in $model.allClasses )
  #set ( $ancestors = $Helper.ancestors( $class ) )
  #set ( $allFields = [] )
  #set ( $inheritedFields = [] )
  #foreach ( $cl in $ancestors )
    #if ( $cl != $class )
      #set ( $dummy = $inheritedFields.addAll( $cl.getFields($version) ) )
    #end

package ssa

import (
	"math/bits"
)

// Code to compute lowest common ancestors in the dominator tree.
// https://en.wikipedia.org/wiki/Lowest_common_ancestor
// https://en.wikipedia.org/wiki/Range_minimum_query#Solution_using_constant_time_and_linearithmic_space

// lcaRange is a data structure that can compute lowest common ancestor queries
// in O(n lg n) precomputed space and O(1) time per query.
type lcaRange struct {

        parent1.ownStrictVersionConstraints != StrictVersionConstraints.EMPTY
        parent2.ownStrictVersionConstraints == StrictVersionConstraints.EMPTY
    }

    def "computes intersection of ancestors"() {
        when:
        def parent1Edge = edge(root, false)
        def parent2Edge = edge(root, false)
        def parent1 = parent1Edge.targetComponent.nodes[0]

        "some/location/intermediate/child/sub1/leaf1" | [5]
        "some/location/intermediate/child/sub1/leaf2" | [6]
        "some/location/intermediate/child/sub3/leaf"  | [7]
    }

    def "can query ancestors values"() {
        ValuedVfsHierarchy<Integer> hierarchy = complexHierarchy()

        when:
        def visitor = new CollectingValueVisitor()
        hierarchy.visitValues(location, visitor)
        then:

        expect:
        assertNodesAccessing("/some", ancestor, child, grandChild)
        assertNodesAccessing("/some/location", ancestor, child, grandChild)
        assertNodesAccessing("/some/location/child/within", ancestor, child, grandChild)
        assertNodesAccessing("/some/location/child/other", ancestor)
    }

    def "ancestor accesses location"() {
        def node1 = Mock(Node)
        def node2 = Mock(Node)

}

// Checks if an op is a supported HLO control flow op.
bool IsControlFlowOp(Operation* op) { return isa<IfOp, WhileOp>(op); }

// Collects control flow op ancestors of a given op, up until FuncOp. If any
// ancestor is not a control flow op or a FuncOp, or of a single block region,
// an error will be returned.
LogicalResult GetControlFlowAncestors(