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

package main

func main() {
	m := make(map[string][1000]byte)
	m["hi"] = [1000]byte{1}
	
	v := m["hi"]
	
	for k, vv := range m {
		if k != "hi" || string(v[:]) != string(vv[:]) {
			panic("bad iter")
		}
	}

	}
}

func useVMMapWithRetry(t *testing.T) (hi, lo uint64, err error) {
	var retryable bool
	for {
		hi, lo, retryable, err = useVMMap(t)
		if err == nil {
			return hi, lo, nil
		}
		if !retryable {
			return 0, 0, err
		}
		t.Logf("retrying vmmap after error: %v", err)
	}
}

func useVMMap(t *testing.T) (hi, lo uint64, retryable bool, err error) {
	pid := strconv.Itoa(os.Getpid())

	// computed as r = hi - lo for extra precision.
	var k int
	switch {
	case x > 0:
		k = int(x + 0.5)
	case x < 0:
		k = int(x - 0.5)
	}
	t := x - float64(k)
	hi := t * Ln2Hi
	lo := -t * Ln2Lo

	// compute
	return expmulti(hi, lo, k)
}

// exp1 returns e**r × 2**k where r = hi - lo and |r| ≤ ln(2)/2.
func expmulti(hi, lo float64, k int) float64 {
	const (

func (t *sparseBlocks) lookup(n uint32, b byte) uint16 {
	offset := t.offset[n]
	header := t.values[offset]
	lo := offset + 1
	hi := lo + uint16(header.lo)
	for lo < hi {
		m := lo + (hi-lo)/2
		r := t.values[m]
		if r.lo <= b && b <= r.hi {
			return r.value + uint16(b-r.lo)*header.value
		}
		if b < r.lo {
			hi = m
		} else {
			lo = m + 1
		}
	}
	return 0

type uint128 struct {
	lo, hi uint64
}

func mul64(a, b uint64) uint128 {
	hi, lo := bits.Mul64(a, b)
	return uint128{lo, hi}
}

func add128(a, b uint128) uint128 {
	lo, c := bits.Add64(a.lo, b.lo, 0)
	hi, c := bits.Add64(a.hi, b.hi, c)
	if c != 0 {
		panic("poly1305: unexpected overflow")
	}
	return uint128{lo, hi}
}

func shiftRightBy2(a uint128) uint128 {

	SCVTFD	R1, F3		// F3 = float64(int(k))
	FMOVD	$Ln2Hi, F4	// F4 = Ln2Hi
	FMOVD	$Ln2Lo, F5	// F5 = Ln2Lo
	FMSUBD	F3, F0, F4, F4	// F4 = hi = x - float64(int(k))*Ln2Hi
	FMULD	F3, F5		// F5 = lo = float64(int(k)) * Ln2Lo
	FSUBD	F5, F4, F6	// F6 = r = hi - lo
	FMULD	F6, F6, F7	// F7 = t = r * r
	// compute y
	FMOVD	$P5, F8		// F8 = P5
	FMOVD	$P4, F9		// F9 = P4
	FMADDD	F7, F9, F8, F13	// P4+t*P5
	FMOVD	$P3, F10	// F10 = P3

class GreetingScriptPlugin implements Plugin<Project> {
    void apply(Project project) {
        project.task('hi') {
            doLast {
                println 'Hi from the GreetingScriptPlugin'
            }
        }
    }
}

// Apply the plugin

}

func gi(p, q *T) bool {
	return p.x == q.x
}

func hi(p, q func() struct{}) bool {
	return p() == q()
}

func main() {
	shouldPanic(func() { f(nil, nil) })
	shouldPanic(func() { g(nil, nil) })
	shouldPanic(func() { h(nil, nil) })
	shouldPanic(func() { fi(nil, nil) })
	shouldPanic(func() { gi(nil, nil) })
	shouldPanic(func() { hi(nil, nil) })
	n := 0
	inc := func() struct{} {
		n++
		return struct{}{}

    @TaskAction
    fun printMessage() {
        logger.quiet(message.get())
    }
}

tasks.register<Greeting>("greeting") {
    greeting.set("Hi") // <4>
    greeting = "Hi" // <5>

	check(want T)
}

type Val[T comparable] struct {
	val T
}

//go:noinline
func (l *Val[T]) check(want T) {
	if l.val != want {
		panic("hi")
	}
}

func Test1() {
	var l Val[int]
	if l.val != 0 {
		panic("hi")
	}
	_ = IVal[int](&l)
}

func Test2() {
	var l Val[float64]
	l.val = 3.0
	l.check(float64(3))
	_ = IVal[float64](&l)
}