// run

//go:build !nacl && !js && !wasip1 && !gccgo

// Copyright 2019 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.

// Make sure we don't get an index out of bounds error
// while trying to print a map that is concurrently modified.
// The runtime might complain (throw) if it detects the modification,
// so we have to run the test as a subprocess.

      if (type == null) {
        Type[] bounds = var.getBounds();
        if (bounds.length == 0) {
          return var;
        }
        Type[] resolvedBounds = new TypeResolver(forDependants).resolveTypes(bounds);
        /*
         * We'd like to simply create our own TypeVariable with the newly resolved bounds. There's

var BigEndian bigEndian

type littleEndian struct{}

func (littleEndian) Uint16(b []byte) uint16 {
	_ = b[1] // bounds check hint to compiler; see golang.org/issue/14808
	return uint16(b[0]) | uint16(b[1])<<8
}

func (littleEndian) PutUint16(b []byte, v uint16) {
	_ = b[1] // early bounds check to guarantee safety of writes below
	b[0] = byte(v)
	b[1] = byte(v >> 8)
}

	}

	q := PCG{}
	if err := q.UnmarshalBinary([]byte(want)); err != nil {
		t.Fatalf("UnmarshalBinary(): %v", err)
	}
	if q != p {
		t.Fatalf("after round trip, q = %#x, but p = %#x", q, p)
	}

	qu := q.Uint64()
	pu := p.Uint64()
	if qu != pu {
		t.Errorf("after round trip, q.Uint64() = %#x, but p.Uint64() = %#x", qu, pu)
	}
}

func TestPCG(t *testing.T) {
	p := NewPCG(1, 2)
	want := []uint64{
		0xc4f5a58656eef510,

    }


    /**
     * Filters the given versions to those that are between the given closed bounds.
     *
     * @param versionsToFilter the versions to filter
     * @param from the lower bound, inclusive
     * @param to the upper bound, inclusive
     */
    static Set<String> versionsBetweenInclusive(Collection<String> versionsToFilter, String from, String to) {

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

package main

// This program failed when run under the C/C++ ThreadSanitizer.
//
// cgocallback on a new thread calls into runtime.needm -> _cgo_getstackbound
// to update gp.stack.lo with the stack bounds. If the G itself is passed to
// _cgo_getstackbound, then writes to the same G can be seen on multiple

// Copyright 2021 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.

package main

/*
#include <stdlib.h>
#include <stdio.h>

void test(int* a) {
	// Access Go pointer out of bounds.
	a[3] = 300;          // BOOM
	// We shouldn't get here; asan should stop us first.
	printf("a[3]=%d\n", a[3]);
}*/
import "C"

func main() {

}

extern void crosscall1(void (*fn)(void), void (*setg_gcc)(void*), void *g);
static void
threadentry(void *v)
{
	ThreadStart ts;

	ts = *(ThreadStart*)v;
	free(v);

	// minit queries stack bounds from the OS.

	/*
	 * Set specific keys in thread local storage.
	 */
	asm volatile (
		"movl %0, %%fs:0(%1)\n"	// MOVL tls0, 0(tls_g)(FS)
		"movl %%fs:0(%1), %%eax\n"	// MOVL 0(tls_g)(FS), tmp

func (x *Nat) Equal(y *Nat) choice {
	// Eliminate bounds checks in the loop.
	size := len(x.limbs)
	xLimbs := x.limbs[:size]
	yLimbs := y.limbs[:size]

	equal := yes
	for i := 0; i < size; i++ {
		equal &= ctEq(xLimbs[i], yLimbs[i])
	}
	return equal
}

// IsZero returns 1 if x == 0, and 0 otherwise.
func (x *Nat) IsZero() choice {
	// Eliminate bounds checks in the loop.
	size := len(x.limbs)

        return Collections.emptyIterator()
    }

    override fun get(index: Int): KaAnnotation = withValidityAssertion {
        throw IndexOutOfBoundsException("Index $index out of bounds")
    }

    override fun contains(classId: ClassId): Boolean = withValidityAssertion {
        return false
    }

    override fun get(classId: ClassId): List<KaAnnotation> = withValidityAssertion {