project: CachedProjectState,
        rootProjectName: String,
        children: Map<Path?, List<CachedProjectState>>
    ): BuildStructureOperationProject {
        val childProjects = children.getOrDefault(project.path, emptyList()).map { convertProject(converted, it, rootProjectName, children) }.toSet()
        return converted.computeIfAbsent(project.path) {

                            parameterConfiguration.getInputLocation());

                    children.add(parameterConfiguration);
                }
            }
        }
        XmlNode finalConfiguration = new XmlNodeImpl("configuration", null, null, children, null);

        mojoExecution.setConfiguration(finalConfiguration);
    }

                <template>transformer.vm</template>
                <template>reader-stax.vm</template>
                <template>writer-stax.vm</template>
              </templates>
              <params combine.children="append">
                <param>locationTracking=true</param>
                <param>generateLocationClasses=true</param>
              </params>
            </configuration>
          </execution>

     * Called when starting to visit a file collection. Can return true to continue with visiting or false to skip this collection and its contents.
     *
     * <p>When a file collection represents a container of file collections, the children of the file collection are visited in order. Visiting a child works in the
     * same way as visiting this collection, starting with a call to {@link #startVisit(FileCollectionInternal.Source, FileCollectionInternal)}.
     *

            try {
                final CIFSContext context = file.getContext();
                final SID[] children = context.getSIDResolver().getGroupMemberSids(context, file.getServer(), sid.getDomainSid(),
                        sid.getRid(), jcifs.smb.SID.SID_FLAG_RESOLVE_SIDS);
                for (final SID child : children) {
                    if (!sidSet.contains(child)) {
                        processAllowedSIDs(file, child, sidSet);

	// properties of the dominator tree
	idom  []*ssa.Block // dominator parents
	tree  []domBlock   // dominator child+sibling
	level []int32      // level in dominator tree (0 = root or unreachable, 1 = children of root, ...)

	// scratch locations
	priq   blockHeap    // priority queue of blocks, higher level (toward leaves) = higher priority
	q      []*ssa.Block // inner loop queue
	queued *sparseSet   // has been put in q

  }

  private static final TreeTraverser<BinaryNode> VIEWER =
      new TreeTraverser<BinaryNode>() {
        @Override
        public Iterable<BinaryNode> children(BinaryNode root) {
          return Optional.presentInstances(ImmutableList.of(root.left, root.right));
        }
      };

  enum Traversal {
    PRE_ORDER {
      @Override

            throws ProjectBuildingException;

    /**
     * Builds the projects for the specified POM files and optionally their children.
     *
     * @param pomFiles The POM files to build, must not be {@code null}.
     * @param recursive {@code true} to recursively build submodules referenced by the POM files, {@code false} to

                    createRootFingerprint(currentSnapshot)
                ))) {
                    // Only one of the types will be a directory, so we now need to report all children of the other one.
                    if (visitAllChildChanges(previousSnapshot, visitor, (relativePath, snapshot) -> FINGERPRINT_CHANGE_FACTORY.removed(
                        snapshot.getAbsolutePath(),

        if (type == SID.SID_TYPE_DOM_GRP || type == SID.SID_TYPE_ALIAS) {
            try {
                final SID[] children = sid.getGroupMemberSids(file.getServer(), (NtlmPasswordAuthentication) file.getPrincipal(),
                        SID.SID_FLAG_RESOLVE_SIDS);
                for (final SID child : children) {
                    if (!sidSet.contains(child)) {
                        processAllowedSIDs(file, child, sidSet);