ADDV	$(1024*8), R29

	// Ask signaller to setgid
	MOVW	$1, R1
	SYNC
	MOVW	R1, ·Baton(SB)
	SYNC

	// Wait for setgid completion
loop:
	SYNC
	MOVW	·Baton(SB), R1
	OR	R2, R2, R2	// hint that we're in a spin loop
	BNE	R1, loop
	SYNC

	// Restore stack
	ADDV	$(-1024*8), R29

	ADDV	$(1024*8), R3

	// Ask signaller to setgid
	MOVW	$1, R12
	DBAR
	MOVW	R12, ·Baton(SB)
	DBAR

	// Wait for setgid completion
loop:
	DBAR
	MOVW	·Baton(SB), R12
	OR	R13, R13, R13	// hint that we're in a spin loop
	BNE	R12, loop
	DBAR

	// Restore stack
	ADDV	$(-1024*8), R3

	var n int
loop: // we want to have 3 preds here, the function entry and both gotos
	if v := try(); v == 42 || v == 1337 { // the two || are to trick findIndVar
		if n < 30 { // this aims to be the matched block
			if shouldInc() {
				n++
				goto loop
			}
			n = N(n) // try to prevent some block joining
			goto loop
		}
	}

	// divided by the type of error:
	// leak, repair, full, outOfRange, duplicate, invalid, unknown
	clusterIPRepairIPErrors = metrics.NewCounterVec(
		&metrics.CounterOpts{
			Namespace:      namespace,
			Subsystem:      subsystem,
			Name:           "ip_errors_total",

		someglobal1++
		someglobal1++
	}
}

func standinacorner2(i int) {
	// contains an irreducible loop containing changes to memory
	if i != 0 {
		goto midloop
	}

loop:
	if someglobal2&1 != 0 {
		goto done
	}
	someglobal2++
midloop:
	someglobal2++
	goto loop

done:
	return
}

func standinacorner3() {
	for someglobal3&1 == 0 {
		if someglobal3&2 != 0 {

	ADD	$(1024*8), X2

	// Ask signaller to setgid
	MOV	$1, X5
	FENCE
	MOVW	X5, ·Baton(SB)
	FENCE

	// Wait for setgid completion
loop:
	FENCE
	MOVW	·Baton(SB), X5
	OR	X6, X6, X6	// hint that we're in a spin loop
	BNE	ZERO, X5, loop
	FENCE

	// Restore stack
	ADD	$(-1024*8), X2

package org.gradle.kotlin.dsl.concurrent

import java.util.concurrent.ArrayBlockingQueue
import java.util.concurrent.TimeUnit


internal
class EventLoop<T>(
    name: String = "Gradle Kotlin DSL Event Loop",
    val loop: (() -> T?) -> Unit
) {

    fun accept(event: T): Boolean {
        if (q.offer(event, offerTimeoutMillis, TimeUnit.MILLISECONDS)) {
            consumer.poke()
            return true
        }

	MOVD	$1, R1
storeloop:
	LDAXRW	(R0), R2
	STLXRW	R1, (R0), R3
	CBNZ	R3, storeloop

	// Wait for setgid completion
	MOVW	$0, R1
	MOVW	$0, R2
loop:
	LDAXRW	(R0), R3
	CMPW	R1, R3
	BNE	loop
	STLXRW	R2, (R0), R3
	CBNZ	R3, loop

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

	MOVD	R9, R30

// since 4 values are processed for each
// loop iteration, and is guaranteed to be > 0.
// If other callers are added this function might
// need to change.
TEXT addMulVVWx<>(SB), NOSPLIT, $0
	MOVD	z+0(FP), R3
	MOVD	x+8(FP), R4
	MOVD	y+16(FP), R5

	MOVD	$0, R9		// R9 = c = 0
	MOVD	R6, CTR		// Initialize loop counter
	PCALIGN	$16

loop:
	MOVD	0(R4), R14	// x[i]
	MOVD	8(R4), R16	// x[i+1]

// getLoopDeviceFromSysfs finds the backing file for a loop
// device from sysfs via "/sys/block/loop*/loop/backing_file".
func getLoopDeviceFromSysfs(path string) (string, error) {
	// If the file is a symlink.
	realPath, err := filepath.EvalSymlinks(path)
	if err != nil {
		return "", fmt.Errorf("failed to evaluate path %s: %s", path, err)
	}

	devices, err := filepath.Glob("/sys/block/loop*")
	if err != nil {