MOVBZ  ·useAsm(SB), R4
	LMG    dig+0(FP), R1, R3            // R2 = &p[0], R3 = len(p)
	MOVBZ  $1, R0                       // SHA-1 function code
	CMPBEQ R4, $0, generic

loop:
	KIMD R0, R2      // compute intermediate message digest (KIMD)
	BVS  loop        // continue if interrupted
	RET

generic:

// However, checking i < len(x) && i < len(y) as well is faster than
// having the compiler do a bounds check in the body of the loop;
// remarkably it is even faster than hoisting the bounds check
// out of the loop, by doing something like
//   _, _ = x[len(z)-1], y[len(z)-1]
// There are other ways to hoist the bounds check out of the loop,
// but the compiler's BCE isn't powerful enough for them (yet?).
// See the discussion in CL 164966.

// license that can be found in the LICENSE file.

package a

func Unique[T comparable](set []T) []T {
	nset := make([]T, 0, 8)

loop:
	for _, s := range set {
		for _, e := range nset {
			if s == e {
				continue loop
			}
		}

		nset = append(nset, s)
	}

	return nset

	// will clobber the test pattern created by the caller
	ADDQ	$(1024 * 8), SP

	// Ask signaller to setgid
	MOVL	$1, ·Baton(SB)

	// Wait for setgid completion
loop:
	PAUSE
	MOVL	·Baton(SB), AX
	CMPL	AX, $0
	JNE	loop

	// Restore stack
	SUBQ	$(1024 * 8), SP

// Verify that constant definition loops are caught during
// typechecking and that the errors print correctly.

package main

const A = 1 + B // ERROR "constant definition loop\n.*A uses B\n.*B uses C\n.*C uses A|initialization cycle"
const B = C - 1 // ERROR "constant definition loop\n.*B uses C\n.*C uses B|initialization cycle"

		return true
	})
	return nil, nil
}

// reportCaptured reports a diagnostic stating a loop variable
// has been captured by a func literal if checkStmt has escaping
// references to vars. vars is expected to be variables updated by a loop statement,
// and checkStmt is expected to be a statements from the body of a func literal in the loop.
func reportCaptured(pass *analysis.Pass, vars []types.Object, checkStmt ast.Stmt) {

	ADD      $19, R7, R9  // Number of string bytes for loop
	CMP      R9, LASTBYTE // Compare against last byte of string
	BLT      index3loop2  // If within, continue this loop
	CMP      R7, LASTSTR  // Compare against last start byte
	BLT      index2to16   // Process remainder
	VSPLTISB $0, V3       // Special case for last 16 bytes
	BR       index3loop   // Continue this loop

	// Loop to process 4 byte separator
	// string[0:16] in V2

	// will clobber the test pattern created by the caller
	ADDL	$(1024 * 8), SP

	// Ask signaller to setgid
	MOVL	$1, (BX)

	// Wait for setgid completion
loop:
	PAUSE
	MOVL	(BX), AX
	CMPL	AX, $0
	JNE	loop

	// Restore stack
	SUBL	$(1024 * 8), SP

	// will clobber the test pattern created by the caller
	ADD	$(1024 * 8), R15

	// Ask signaller to setgid
	MOVD	$·Baton(SB), R5
	MOVW	$1, 0(R5)

	// Wait for setgid completion
loop:
	SYNC
	MOVW	·Baton(SB), R3
	CMPBNE	R3, $0, loop

	// Restore stack
	SUB	$(1024 * 8), R15

			wantErr:                true,
			shouldDisableInstances: true,
		},
		{
			name:      "subsequent sync loop succeeds",
			addrs:     createNodeInternalIPAddress("10.0.1.12"),
			wantAddrs: createNodeInternalIPAddress("10.0.1.12"),
		},
		{
			name:      "subsequent sync loop encounters an error, last addresses returned",
			err:       errors.New("bad"),
			wantAddrs: createNodeInternalIPAddress("10.0.1.12"),