var algPriority = [ASPECIAL + 1]int8{ASPECIAL: 1, ANOEQ: 2, ANOALG: 3, AMEM: -1}

// setAlg sets the algorithm type of t to a, if it is of higher
// priority to the current algorithm type.
func (t *Type) setAlg(a AlgKind) {
	if t.alg == AUNK {
		base.Fatalf("setAlg(%v,%s) starting with unknown priority", t, a)
	}
	if algPriority[a] > algPriority[t.alg] {
		t.alg = a

 * It features an <code>execute()</code> method, which triggers the Mojo's build-process behavior, and can throw
 * a MojoExecutionException or MojoFailureException if error conditions occur.<br>
 * Also included is the <code>setLog(...)</code> method, which simply allows Maven to inject a logging mechanism which
 * will allow the Mojo to communicate to the outside world through standard Maven channels.
 *
 */
public interface Mojo {

	for i, c := range cases {
		t.Run(fmt.Sprintf("case %d %q", i, c.args), func(t *testing.T) {
			args := strings.Split(c.args, " ")
			setFlag := fmt.Sprintf("installPackagePath=%s", snapshotCharts)
			by := &bytes.Buffer{}
			_, err := profileDiffInternal(args[len(args)-2], args[len(args)-1], []string{setFlag}, by, l)
			verifyProfileDiffCommandCaseOutput(t, c, by.String(), err)
		})
	}
}

	// sure that we don't end up doing O(n^2) work
	// for a chain of n copies.
	for v != w {
		x := v.Args[0]
		v.SetArg(0, w)
		v = x
	}
	return w
}

// copyelimValue ensures that no args of v are copies.
func copyelimValue(v *Value) {
	for i, a := range v.Args {
		if a.Op == OpCopy {
			v.SetArg(i, copySource(a))
		}
	}
}

// phielim eliminates redundant phi values from f.

            return host;
        }
    }

    protected String toAscii(final String host) {
        return IDN.toASCII(decode(host), flag);
    }

    public void setFlag(final int flag) {
        this.flag = flag;
    }

    public void setEncoding(final String encoding) {
        this.encoding = encoding;
    }

func gcWriteBarrierSI()
func gcWriteBarrierR8()
func gcWriteBarrierR9()

// stackcheck checks that SP is in range [g->stack.lo, g->stack.hi).
func stackcheck()

// Called from assembly only; declared for go vet.
func settls() // argument in DI

// Retpolines, used by -spectre=ret flag in cmd/asm, cmd/compile.
func retpolineAX()
func retpolineCX()
func retpolineDX()
func retpolineBX()
func retpolineBP()
func retpolineSI()

func (c *context) lr() uintptr { return uintptr(c.lrr) }

func (c *context) set_ip(x uintptr) { c.pc = uint32(x) }
func (c *context) set_sp(x uintptr) { c.spr = uint32(x) }
func (c *context) set_lr(x uintptr) { c.lrr = uint32(x) }

// arm does not have frame pointer register.
func (c *context) set_fp(x uintptr) {}

func prepareContextForSigResume(c *context) {
	c.r0 = c.spr
	c.r1 = c.pc
}

func (c *context) sp() uintptr { return uintptr(c.esp) }

// 386 does not have link register, so this returns 0.
func (c *context) lr() uintptr      { return 0 }
func (c *context) set_lr(x uintptr) {}

func (c *context) set_ip(x uintptr) { c.eip = uint32(x) }
func (c *context) set_sp(x uintptr) { c.esp = uint32(x) }

// 386 does not have frame pointer register.
func (c *context) set_fp(x uintptr) {}

func (t Tag) RegionalTag() Tag {
	rt := Tag{language: t.locale, locale: t.locale}
	if t.full == nil {
		return rt
	}
	b := language.Builder{}
	tag := t.Tag()
	// tag, _ = tag.SetTypeForKey("rg", "")
	b.SetTag(t.locale.Tag())
	if v := tag.Variants(); v != "" {
		for _, v := range strings.Split(v, "-") {
			b.AddVariant(v)
		}
	}
	for _, e := range tag.Extensions() {
		b.AddExt(e)
	}
	return t
}

	tv.tv_usec = int64(x)
}

type sigactiont struct {
	sa_flags   uint32
	sa_handler uintptr
	sa_mask    [2]uint64
	// linux header does not have sa_restorer field,
	// but it is used in setsig(). it is no harm to put it here
	sa_restorer uintptr
}

type siginfoFields struct {
	si_signo int32
	si_code  int32
	si_errno int32
	__pad0   [1]int32