* <origin><![CDATA[
     * <distributionManagement>
     * <repository>
     * <id>some-repo</id>
     * <url>scp://host/path</url>
     * </repository>
     * <snapshotRepository>
     * <id>some-snap-repo</id>
     * <url>scp://host/snapshot-path</url>
     * </snapshotRepository>
     * </distributionManagement>
     * ]]></origin>
     * <usage><![CDATA[

import java.util.Properties


@DisableCachingByDefault(because = "Not worth caching")
abstract class UpdateInitPluginTemplateVersionFile : DefaultTask() {

    private
    val devSuffixes = arrayOf(
        "-SNAP\\d+",
        "-SNAPSHOT",
        "-alpha.*\\d+",
        "-beta.*\\d+",
        "-dev-?\\d+",
        "-dev-\\d+-\\d+",
        "-rc-?\\d+",
        "-M.+",
        "-eap-?\\d+"

        assertEquals("project.snaps", pom.getValue("distributionManagement/snapshotRepository/id"));
        assertEquals("snaps", pom.getValue("distributionManagement/snapshotRepository/name"));
        assertEquals("https://project.url/snaps", pom.getValue("distributionManagement/snapshotRepository/url"));

	"⪴":                             "\u2ab4",
	"⪸":                            "\u2ab8",
	"š":                          "\u0161",
	"≽":                           "\u227d",
	"⪰":                             "\u2ab0",
	"ş":                          "\u015f",
	"ŝ":                           "\u015d",
	"⪶":                            "\u2ab6",
	"⪺":                           "\u2aba",

			"(*Uint32).Swap",
			"(*Uint64).Add",
			"(*Uint64).CompareAndSwap",
			"(*Uint64).Load",
			"(*Uint64).Store",
			"(*Uint64).Swap",
			"(*Uintptr).Add",
			"(*Uintptr).CompareAndSwap",
			"(*Uintptr).Load",
			"(*Uintptr).Store",
			"(*Uintptr).Swap",
			"(*Pointer[go.shape.int]).CompareAndSwap",
			"(*Pointer[go.shape.int]).Load",
			"(*Pointer[go.shape.int]).Store",
			"(*Pointer[go.shape.int]).Swap",
		},

func (check *Checker) subst(pos syntax.Pos, typ Type, smap substMap, expanding *Named, ctxt *Context) Type {
	assert(expanding != nil || ctxt != nil)

	if smap.empty() {
		return typ
	}

	// common cases
	switch t := typ.(type) {
	case *Basic:
		return typ // nothing to do
	case *TypeParam:
		return smap.lookup(t)
	}

	// general case
	subst := subster{
		pos:       pos,
		smap:      smap,
		check:     check,

        }
      #end
    }

      #if ( $field.type == "java.util.List" && $field.multiplicity == "*" )
        #set ( $v = $Helper.singular( ${field.name} ) )
        #set ( $scap = $Helper.capitalise( $v ) )
    public void add${scap}(${field.to} ${v}) {
        #if ( $field.to == "String" )
        update(getDelegate().with${cap}(
               Stream.concat(getDelegate().get${cap}().stream(), Stream.of(${v}))

			}
			smap := makeSubstMap(ytparams, targs)

			var check *Checker   // ok to call subst on a nil *Checker
			ctxt := NewContext() // need a non-nil Context for the substitution below

			// Constraints must be pair-wise identical, after substitution.
			for i, xtparam := range xtparams {
				ybound := check.subst(nopos, ytparams[i].bound, smap, nil, ctxt)

)

// SortTags sorts tags in place.
func SortTags(tags []language.Tag) {
	sort.Sort(sorter(tags))
}

type sorter []language.Tag

func (s sorter) Len() int {
	return len(s)
}

func (s sorter) Swap(i, j int) {
	s[i], s[j] = s[j], s[i]
}

func (s sorter) Less(i, j int) bool {
	return s[i].String() < s[j].String()
}

// UniqueTags sorts and filters duplicate tags in place and returns a slice with

	// code.
	if origSig.RecvTypeParams().Len() == t.inst.targs.Len() {
		smap := makeSubstMap(origSig.RecvTypeParams().list(), t.inst.targs.list())
		var ctxt *Context
		if check != nil {
			ctxt = check.context()
		}
		sig = check.subst(origm.pos, origSig, smap, t, ctxt).(*Signature)
	}

	if sig == origSig {