c := (v.l0 + 19) >> 51
	c = (v.l1 + c) >> 51
	c = (v.l2 + c) >> 51
	c = (v.l3 + c) >> 51
	c = (v.l4 + c) >> 51

	// If v < 2^255 - 19 and c = 0, this will be a no-op. Otherwise, it's
	// effectively applying the reduction identity to the carry.
	v.l0 += 19 * c

	v.l1 += v.l0 >> 51
	v.l0 = v.l0 & maskLow51Bits
	v.l2 += v.l1 >> 51
	v.l1 = v.l1 & maskLow51Bits
	v.l3 += v.l2 >> 51

	}

	for {
		if x == 19 {
			break L1 /* ERROR "invalid break label L1" */
		}
		if x == 20 {
			continue L1 /* ERROR "invalid continue label L1" */
		}
		if x == 21 {
			goto L1
		}
	}
}

// Additional tests not in the original files.

func f2() {
L1 /* ERROR "label L1 declared and not used" */ :
	if x == 0 {
		for {
			continue L1 /* ERROR "invalid continue label L1" */
		}
	}

	// r2 = l0×l2 + l1×l1 + l2×l0 + 19×(l3×l4 + l4×l3) = 2×l0×l2 + l1×l1 + 19×2×l3×l4
	r2 := mul64(l0_2, l2)
	r2 = addMul64(r2, l1, l1)
	r2 = addMul64(r2, l3_38, l4)

	// r3 = l0×l3 + l1×l2 + l2×l1 + l3×l0 + 19×l4×l4 = 2×l0×l3 + 2×l1×l2 + 19×l4×l4
	r3 := mul64(l0_2, l3)
	r3 = addMul64(r3, l1_2, l2)
	r3 = addMul64(r3, l4_19, l4)

	// r4 = l0×l4 + l1×l3 + l2×l2 + l3×l1 + l4×l0 = 2×l0×l4 + 2×l1×l3 + l2×l2

	mul64(r1, 2, l0, l1)
	addMul64(r1, 38, l2, l4)
	addMul64(r1, 19, l3, l3)

	// r2 = = 2×l0×l2 + l1×l1 + 19×2×l3×l4
	r2 := uint128{"r2", GP64(), GP64()}
	mul64(r2, 2, l0, l2)
	addMul64(r2, 1, l1, l1)
	addMul64(r2, 38, l3, l4)

	// r3 = = 2×l0×l3 + 2×l1×l2 + 19×l4×l4
	r3 := uint128{"r3", GP64(), GP64()}
	mul64(r3, 2, l0, l3)
	addMul64(r3, 2, l1, l2)
	addMul64(r3, 19, l4, l4)

	// r4 = = 2×l0×l4 + 2×l1×l3 + l2×l2

      c2: null
    p2:
      c3: null
  d2:
    p3:
      c4: null
      c5: null
    p4:
      c6: null
`
	testClusterResourcesLabels = `
ns1/p1:
  l1: v1
  l2: v2
ns1/p2:
  l1: v1
  l2: v22
  l3: v3
ns1/p3:
  l1: v1
  l2: v2
  l3: v3
  l4: v4
`
	testClusterResourcesAnnotations = `
ns1/p1:
  k2: v2
ns1/p2:
  k1: v1
  k2: v2
  k3: v33
ns1/p3:
  k1: v1

}

func TestIssue4103() {
	l1 := _New[int]()
	l1.PushBack(1)
	l1.PushBack(2)

	l2 := _New[int]()
	l2.PushBack(3)
	l2.PushBack(4)

	e := l1.Front()
	l2.Remove(e) // l2 should not change because e is not an element of l2
	if n := l2.Len(); n != 2 {
		panic(fmt.Sprintf("l2.Len() = %d, want 2", n))
	}

	l1.InsertBefore(8, e)
	if n := l1.Len(); n != 3 {

	goto L /* ERROR "goto L jumps into block" */
	goto L1 /* ERROR "goto L1 jumps into block" */
	{
	L: L1:
	}
}

// goto backward into inner block still not okay
func _() {
	{
	L:
	}
	goto L /* ERROR "goto L jumps into block" */
}

func _() {
	{
	L: L1:
	}
	goto L /* ERROR "goto L jumps into block" */
	goto L1 /* ERROR "goto L1 jumps into block" */
}

        then:
        container.dependencies*.displayName == [displayName]

        where:
        proj | lib  | displayName
        "p1" | "l1" | "project 'p1' library 'l1'"
        "p1" | null | "project 'p1'"
        null | "l1" | "library 'l1'"
    }

    def "throws IllegalDependencyNotation for project dependency spec with no project or library"() {
        when:
        container.project(null).library(null)

type S1 struct{ x int }
type S2 struct{ x any }
type S3 struct{ x [10]interface{ m() } }

func _[P1 comparable, P2 S2]() {
	_ = f[S1]
	_ = f[S2]
	_ = f[S3]

	type L1 struct { x P1 }
	type L2 struct { x P2 }
	_ = f[L1]
	_ = f[L2 /* ERROR "L2 does not satisfy comparable" */ ]
}


// example from issue

type Set[T comparable] map[T]struct{}

func NewSetFromSlice[T comparable](items []T) *Set[T] {

eight:700}.lit{color:#044}.pun,.opn,.clo{color:#440}.tag{color:#006;font-weight:700}.atn{color:#404}.atv{color:#060}}pre.prettyprint{padding:2px;border:1px solid #888}ol.linenums{margin-top:0;margin-bottom:0}li.L0,li.L1,li.L2,li.L3,li.L5,li.L6,li.L7,li.L8{list-style-type:none}li.L1,li.L3,li.L5,li.L7,li.L9{background:#eee}...