dependencies {
                modules "org.utils:api:1.+"
            }

            task verify {
                def filesA = configurations.modulesA
                def filesB = configurations.modulesB
                doLast {
                    assert filesA.collect { it.name } == [ 'api-1.1.jar']
                    assert filesB.collect { it.name } == [ 'api-1.0.jar']
                }
            }

	// If filesToWrite is set, write the generated content to disk.
	// In the special case of "all", write all files in filemap.
	write := *filesToWrite != ""
	var files []string // files to process
	if *filesToWrite != "" && *filesToWrite != "all" {
		files = strings.Split(*filesToWrite, ",")
	} else {
		for file := range filemap {
			files = append(files, file)
		}
	}

	for _, filename := range files {
		generate(t, filename, write)

// well-formed.
type Tag struct {
	// NOTE: exported tags will become part of the public API.
	language ID
	locale   ID
	full     fullTag // always a language.Tag for now.
}

const _und = 0

type fullTag interface {
	IsRoot() bool
	Parent() language.Tag
}

// Make a compact Tag from a fully specified internal language Tag.
func Make(t language.Tag) (tag Tag) {

		"subdir4":            "overlayfiles/subdir4",
		"subdir3/file3b.txt": "overlayfiles/subdir3_file3b.txt",
		"subdir5":            "",
		"subdir6":            ""
	}
}
-- subdir1/file1.txt --

-- subdir3/file3a.txt --
33
-- subdir4/file4.txt --
444
-- overlayfiles/subdir2_file2.txt --
2
-- overlayfiles/subdir3_file3b.txt --
66666
-- overlayfiles/subdir4 --
x
-- subdir6/file6.txt --
six
`)

	Ctim31       [4]byte
	Rdev         uint32
	Auditoraudit uint32
	Useraudit    uint32
	Blksize      int32
	Creatim31    [4]byte
	AuditID      [16]byte
	_            [4]byte // rsrvd1
	File_tag     struct {
		Ccsid   uint16
		Txtflag uint16 // aggregating Txflag:1 deferred:1 rsvflags:14
	}
	CharsetID [8]byte
	Blocks    int64
	Genvalue  uint32
	Reftim31  [4]byte
	Fid       [8]byte

		// the end of time.Time -> JSON -> Unstructured -> CBOR, the CBOR encoder has no
		// reliable way of knowing that a particular string originated from serializing a
		// time.Time), so producing tag 0 has little use.
		TimeTag: cbor.EncTagNone,

		// Indefinite-length items have multiple encodings and aren't being used anyway, so
		// disable to avoid an opportunity for nondeterminism.
		IndefLength: cbor.IndefLengthForbidden,

	funcnameOffset uintptr // offset to the funcnametab variable from pcHeader
	cuOffset       uintptr // offset to the cutab variable from pcHeader
	filetabOffset  uintptr // offset to the filetab variable from pcHeader
	pctabOffset    uintptr // offset to the pctab variable from pcHeader
	pclnOffset     uintptr // offset to the pclntab variable from pcHeader
}

                doLast {
                    def filesA = configurations.first.incoming.artifactView { lenient = true }.files.files*.name
                    def filesB = configurations.second.incoming.artifactView { lenient = true }.files.files*.name
                    def filesC = configurations.third.incoming.artifactView { lenient = true }.files.files*.name
                    println "Resolved: \${filesA} \${filesB} \${filesC}"
                }

		log.Fatalf("generate: %s", err)
	}

	// Parse package clause
	filePkg, err := parser.ParseFile(token.NewFileSet(), "", src, parser.PackageClauseOnly)
	if err != nil {
		// Invalid package clause - ignore file.
		return true
	}

	g := &Generator{
		r:        bytes.NewReader(src),
		path:     absFile,
		pkg:      filePkg.Name.String(),
		commands: make(map[string][]string),
	}
	return g.run()
}

               Y: 2,
       },
               &T{
                       X: 3,
                       Y: 4,
               },
               nil
}

func _() interface{} {
	return &fileStat{
			name:    basename(file.name),
			size:    mkSize(d.FileSizeHigh, d.FileSizeLow),
			modTime: mkModTime(d.LastWriteTime),
			mode:    mkMode(d.FileAttributes),
			sys:     mkSysFromFI(&d),
		}, nil
}