// run

// Copyright 2013 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 4620: map indexes are not evaluated before assignment of other elements

package main

import "fmt"

func main() {
	m := map[int]int{0:1}
	i := 0
	i, m[i] = 1, 2
	if m[0] != 2 {
		fmt.Println(m)
		panic("m[i] != 2")
	}

        when:
        indexes.each {
            selectors.add(candidateSelectors[it], false)
        }
        indexes.each {
            selectors.remove(candidateSelectors[it])
        }

        then:
        verifyEmpty(selectors)

        where:
        indexes << [0, 1, 2, 3].permutations()

    }

// The MOV instruction loads R12 with the callback index, and the
// B instruction branches to callbackasm1.
// callbackasm1 takes the callback index from R12 and
// indexes into an array that stores information about each callback.
// It then calls the Go implementation for that callback.
#include "textflag.h"

TEXT runtime·callbackasm(SB),NOSPLIT|NOFRAME,$0
`)

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 4348. After switch to 64-bit ints the compiler generates
// illegal instructions when using large array bounds or indexes.

// Skip. We reject symbols larger that 2GB (Issue #9862).

package main

// 1<<32 on a 64-bit machine, 1 otherwise.
const LARGE = ^uint(0)>>32 + 1

func A() int {
	var a []int
	return a[LARGE]
}

// compile

// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Non-Go-constant but constant indexes are ok at compile time.

package p

import "unsafe"

func f() {
	var x [0]int
	x[uintptr(unsafe.Pointer(nil))] = 0
}
func g() {
	var x [10]int
	_ = x[3:uintptr(unsafe.Pointer(nil))]

// The indexes range in the usual order, from 0 through len(s)-1.
func All[Slice ~[]E, E any](s Slice) iter.Seq2[int, E] {
	return func(yield func(int, E) bool) {
		for i, v := range s {
			if !yield(i, v) {
				return
			}
		}
	}
}

// Backward returns an iterator over index-value pairs in the slice,
// traversing it backward. The indexes range from len(s)-1 down to 0.

import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Simple helper class to build a "sparse" array of objects based on the indexes that were added to
 * it. The array will be from 0 to the maximum index given. All non-set indexes will contain null
 * (so it's not really a sparse array, just a pseudo sparse array). The builder can also return a
 * CharEscaper based on the generated array.
 *

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

// This test makes sure that we use all 64 bits of an
// index, even on 32 bit machines.  It also tests that nacl
// can compile 64 bit indexes loaded from ODOTPTR properly.

package main

type T struct {
	i int64
}

func f(t *T) byte {
	b := [2]byte{3, 4}
	return b[t.i]
}

func main() {
	t := &T{0x100000001}
	defer func() {

	records [][]byte
	lookup  map[string]int64
}

// testHashes implements tlog.HashReader, reading from a slice.
type testHashes []tlog.Hash

func (h testHashes) ReadHashes(indexes []int64) ([]tlog.Hash, error) {
	var list []tlog.Hash
	for _, id := range indexes {
		list = append(list, h[id])
	}
	return list, nil
}

func (s *TestServer) Signed(ctx context.Context) ([]byte, error) {
	s.mu.Lock()
	defer s.mu.Unlock()

	PopHead() (any, bool)
	PopTail() (any, bool)
}

func NewPoolDequeue(n int) PoolDequeue {
	d := &poolDequeue{
		vals: make([]eface, n),
	}
	// For testing purposes, set the head and tail indexes close
	// to wrapping around.
	d.headTail.Store(d.pack(1<<dequeueBits-500, 1<<dequeueBits-500))
	return d
}

func (d *poolDequeue) PushHead(val any) bool {
	return d.pushHead(val)
}