val stage2 = remainingSource
                .takeIf { it.text.isNotBlank() }
                ?.let(Program::Script)

            stage1?.let { s1 ->
                stage2?.let { s2 ->
                    Program.Staged(s1, s2)
                } ?: s1
            }
                ?: stage2
                ?: Program.Empty
        }
    }

    private
    fun rangesToErase(

	VSHASIGMAW	$0, xj_1, $0, s0; \
	VSEL		g, f, e, FUNC; \
	VSHASIGMAW	$15, e, $1, S1; \
	VADDUWM		xi, h, h; \
	VSHASIGMAW	$0, a, $1, S0; \
	VSHASIGMAW	$15, xj_14, $0, s1; \
	VADDUWM		FUNC, h, h; \
	VXOR		b, a, FUNC; \
	VADDUWM		xj_9, xj, xj; \
	VADDUWM		S1, h, h; \
	VSEL		b, c, FUNC, FUNC; \
	VADDUWM		KI, g, g; \
	VADDUWM		h, d, d; \
	VADDUWM		FUNC, S0, S0; \

        failure.assertHasCause("""Type-only model reference of type java.lang.String (parameter 1) is ambiguous as multiple model elements are available for this type:
  - s1 (created by: Plugin1.Rules#s1())
  - s2 (created by: Plugin2.Rules#s2())""")
    }

    def "fails on incompatible by-type reference"() {
        given:
        buildScript """
            class Plugin1 {

        buildScript """
            class Rules extends RuleSource {
              @Model
              String s1(Integer iDontExist) {
                "foo"
              }
            }

            pluginManager.apply Rules
        """

        then:
        fails "help"
        failureCauseContains("""
  Rules#s1(Integer)
    inputs:
      - <no path> Integer (parameter 1) [*]

        WeaklyTypeReferencingMethod.of(declaringType, ModelType.of(method.returnType), method)
    }

    def noArgs() {}

    def oneArg(String s1) {}

    def twoArgs(String s1, String s2) {}

    def genericArgs(List<String> list, Map<Integer, List<String>> map) {}

    class Outer {
        static class Inner {
            def noArgs() {}
        }
    }

// disagree, or <0 if the lengths are the same and all elements
// are identical.
func compareUint32Slices(s1, s2 []uint32) int {
	if len(s1) != len(s2) {
		if len(s1) > len(s2) {
			return len(s2) + 1
		}
		return len(s1) + 1
	}
	for i := range s1 {
		if s1[i] != s2[i] {
			return i
		}
	}
	return -1
}

// compareFloat32Slices returns the first index where the two slices

        ClassSetAnalysis s1 = snapshot(["A": TestHashCodes.hashCodeFrom(0xaa), "B": TestHashCodes.hashCodeFrom(0xbb), "C": TestHashCodes.hashCodeFrom(0xcc)])
        ClassSetAnalysis s2 = snapshot(["A": TestHashCodes.hashCodeFrom(0xaa), "B": TestHashCodes.hashCodeFrom(0xbbbb)])

        expect:
        s1.findChangesSince(s2).dependents.allDependentClasses == ["B"] as Set
        s2.findChangesSince(s1).dependents.allDependentClasses == ["B", "C"] as Set

(MULLWload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem) && ptr.Op != OpSB && is20Bit(int64(o1)+int64(o2)) && canMergeSym(s1, s2) => (MULLWload [o1+o2] {mergeSym(s1, s2)} x ptr mem)
(SUBload   [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem) && ptr.Op != OpSB && is20Bit(int64(o1)+int64(o2)) && canMergeSym(s1, s2) => (SUBload   [o1+o2] {mergeSym(s1, s2)} x ptr mem)

	VSHASIGMAD	$0, xj_1, $0, s0; \
	VSEL		g, f, e, FUNC; \
	VSHASIGMAD	$15, e, $1, S1; \
	VADDUDM		xi, h, h; \
	VSHASIGMAD	$0, a, $1, S0; \
	VSHASIGMAD	$15, xj_14, $0, s1; \
	VADDUDM		FUNC, h, h; \
	VXOR		b, a, FUNC; \
	VADDUDM		xj_9, xj, xj; \
	VADDUDM		S1, h, h; \
	VSEL		b, c, FUNC, FUNC; \
	VADDUDM		KI, g, g; \
	VADDUDM		h, d, d; \
	VADDUDM		FUNC, S0, S0; \

	assert(unsafe.Offsetof(y1.e) == 56)   // relative to S1

	var y1p *S1
	assert(unsafe.Offsetof(y1p.S0) == 32)

	type P *S1
	var p P = y1p
	assert(unsafe.Offsetof(p.S0) == 32)

	var y2 S2
	assert(unsafe.Offsetof(y2.S1) == 0)
	_ = unsafe.Offsetof(y2 /* ERROR "embedded via a pointer" */ .x)
	_ = unsafe.Offsetof(y2 /* ERROR "method value" */ .m)

	var s []byte