// We are hitting the timeout too often, so increase the timeout by 25%
		timeout := atomic.LoadInt64(&dt.timeout) * 125 / 100

		// Set upper cap.
		if timeout > int64(maxDynamicTimeout) {
			timeout = int64(maxDynamicTimeout)
		}
		// Safety, shouldn't happen
		if timeout < dt.minimum {
			timeout = dt.minimum
		}
		atomic.StoreInt64(&dt.timeout, timeout)
	} else if failPct < dynamicTimeoutDecreaseThresholdPct {

// issue 16985: intrinsified AMD64 atomic ops should clobber flags

package main

import "sync/atomic"

var count uint32

func main() {
	buffer := []byte("T")
	for i := 0; i < len(buffer); {
		atomic.AddUint32(&count, 1)
		_ = buffer[i]
		i++
		i++
	}

	for i := 0; i < len(buffer); {
		atomic.CompareAndSwapUint32(&count, 0, 1)
		_ = buffer[i]
		i++
		i++
	}

//go:nowritebarrier
func unlock2(l *mutex) {
	gp := getg()
	var mp *m
	for {
		v := atomic.Loaduintptr(&l.key)
		if v == locked {
			if atomic.Casuintptr(&l.key, locked, 0) {
				break
			}
		} else {
			// Other M's are waiting for the lock.
			// Dequeue an M.
			mp = muintptr(v &^ locked).ptr()
			if atomic.Casuintptr(&l.key, v, uintptr(mp.nextwaitm)) {
				// Dequeued an M.  Wake it.
				semawakeup(mp)

exists -exec mygofmt
! exists mygofmt.exe
! exists gofmt
! exists gofmt.exe

go build sync/atomic
! exists atomic
! exists atomic.exe

go build -o myatomic.a sync/atomic
exists myatomic.a
exec $GOBIN/isarchive myatomic.a
! exists atomic
! exists atomic.a
! exists atomic.exe

! go build -o whatever cmd/gofmt sync/atomic
stderr 'multiple packages'

-- go.mod --
module m

go 1.16
-- x.go --

pkg sync/atomic, func OrUint32(*uint32, uint32) uint32 #61395
pkg sync/atomic, func OrUint64(*uint64, uint64) uint64 #61395
pkg sync/atomic, func OrUintptr(*uintptr, uintptr) uintptr #61395
pkg sync/atomic, method (*Int32) And(int32) int32 #61395
pkg sync/atomic, method (*Int32) Or(int32) int32 #61395
pkg sync/atomic, method (*Int64) And(int64) int64 #61395
pkg sync/atomic, method (*Int64) Or(int64) int64 #61395

        e.message == "boom"

        where:
        factory            | factoryName
        Lazy.unsafe()::of  | "unsafe"
        Lazy.locking()::of | "locking"
        Lazy.atomic()::of  | "atomic"
    }

    def "#factoryName supplier code is executed once with apply"() {
        def supplier = Mock(Supplier)

        when:
        def lazy = factory(supplier)

        then:

func abigen_sync_atomic_LoadUint64(addr *uint64) (val uint64)

//go:linkname abigen_sync_atomic_LoadUintptr sync/atomic.LoadUintptr
func abigen_sync_atomic_LoadUintptr(addr *uintptr) (val uintptr)

//go:linkname abigen_sync_atomic_LoadPointer sync/atomic.LoadPointer
func abigen_sync_atomic_LoadPointer(addr *unsafe.Pointer) (val unsafe.Pointer)

//go:linkname abigen_sync_atomic_StoreInt32 sync/atomic.StoreInt32

	"github.com/hashicorp/go-multierror"
	"go.uber.org/atomic"
	"golang.org/x/sync/semaphore"
)

const (
	maxConcurrencyPerForward = 20
)

type executor struct {
	totalRequests  *atomic.Uint64
	activeRequests *atomic.Uint64
	stopCh         chan struct{}
}

func newExecutor() *executor {
	e := &executor{
		totalRequests:  atomic.NewUint64(0),
		activeRequests: atomic.NewUint64(0),
		stopCh:         make(chan struct{}),

package runtime_test

import (
	"runtime"
	"sync"
	"sync/atomic"
	"syscall"
	"testing"
)

func TestGoroutineProfile(t *testing.T) {
	// GoroutineProfile used to use the wrong starting sp for
	// goroutines coming out of system calls, causing possible
	// crashes.
	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(100))

	var stop uint32
	defer atomic.StoreUint32(&stop, 1) // in case of panic

	var wg sync.WaitGroup

		throw("lfstack.push")
	}
	for {
		old := atomic.Load64((*uint64)(head))
		node.next = old
		if atomic.Cas64((*uint64)(head), old, new) {
			break
		}
	}
}

func (head *lfstack) pop() unsafe.Pointer {
	for {
		old := atomic.Load64((*uint64)(head))
		if old == 0 {
			return nil
		}
		node := lfstackUnpack(old)
		next := atomic.Load64(&node.next)
		if atomic.Cas64((*uint64)(head), old, next) {