package main

import "fmt"

const N = 2e6

type Big = [N]int

var sink interface{}

func main() {
	g(0, f(0))

	x1 := f(1)
	sink = &x1
	g(1, x1)
	g(7, f(7))
	g(1, x1)

	x3 := f(3)
	sink = &x3
	g(1, x1)
	g(3, x3)

	h(f(0), x1, f(2), x3, f(4))
}

//go:noinline
func f(k int) (x Big) {
	for i := range x {
		x[i] = k*N + i
	}
	return
}

)

const (
	// Maximum size in bits for big.Ints before signaling
	// overflow and also mantissa precision for big.Floats.
	ConstPrec = 512
)

func BigFloat(v constant.Value) *big.Float {
	f := new(big.Float)
	f.SetPrec(ConstPrec)
	switch u := constant.Val(v).(type) {
	case int64:
		f.SetInt64(u)
	case *big.Int:
		f.SetInt(u)
	case *big.Float:
		f.Set(u)
	case *big.Rat:
		f.SetRat(u)
	default:

			return p, nil
		}
	}
}

// Int returns a uniform random value in [0, max). It panics if max <= 0.
func Int(rand io.Reader, max *big.Int) (n *big.Int, err error) {
	if max.Sign() <= 0 {
		panic("crypto/rand: argument to Int is <= 0")
	}
	n = new(big.Int)
	n.Sub(max, n.SetUint64(1))
	// bitLen is the maximum bit length needed to encode a value < max.
	bitLen := n.BitLen()
	if bitLen == 0 {

pkg math/big, const MaxPrec ideal-int
pkg math/big, const MinExp = -2147483648
pkg math/big, const MinExp ideal-int
pkg math/big, const ToNearestAway = 1
pkg math/big, const ToNearestAway RoundingMode
pkg math/big, const ToNearestEven = 0
pkg math/big, const ToNearestEven RoundingMode
pkg math/big, const ToNegativeInf = 4
pkg math/big, const ToNegativeInf RoundingMode
pkg math/big, const ToPositiveInf = 5

	// allocated is a bit array of the allocated items in the range
	allocated *big.Int
}

// AllocationBitmap implements Interface and Snapshottable
var _ Interface = &AllocationBitmap{}
var _ Snapshottable = &AllocationBitmap{}

// bitAllocator represents a search strategy in the allocation map for a valid item.
type bitAllocator interface {
	AllocateBit(allocated *big.Int, max, count int) (int, bool)
}

func TestZetas(t *testing.T) {
	ζ := big.NewInt(17)
	q := big.NewInt(q)
	for k, zeta := range zetas {
		// ζ^BitRev7(k) mod q
		exp := new(big.Int).Exp(ζ, big.NewInt(int64(BitRev7(uint8(k)))), q)
		if big.NewInt(int64(zeta)).Cmp(exp) != 0 {
			t.Errorf("zetas[%d] = %v, expected %v", k, zeta, exp)
		}
	}
}

func TestGammas(t *testing.T) {
	ζ := big.NewInt(17)
	q := big.NewInt(q)
	for k, gamma := range gammas {

        String    | 'hello'
        File      | TEST_FILE
    }

    def "can zip two providers"() {
        def big = withValues("big")
        def black = withValues("black")
        def cat = withValues("cat")

        when:
        def zipped = providerFactory.zip(
                providerFactory.zip(big, black) { s1, s2 -> "$s1 $s2" } ,
                cat) { s1, s2 -> "${s1.capitalize()} ${s2}"}

        then:

func (intVal) implementsValue()     {}
func (floatVal) implementsValue()   {}
func (complexVal) implementsValue() {}

func newInt() *big.Int     { return new(big.Int) }
func newRat() *big.Rat     { return new(big.Rat) }
func newFloat() *big.Float { return new(big.Float).SetPrec(prec) }

func i64toi(x int64Val) intVal   { return intVal{newInt().SetInt64(int64(x))} }

// d == result * factor ^ times
// d may be modified in place.
// If d == 0, then the return values will be (0, 0)
func removeBigIntFactors(d, factor *big.Int) (result *big.Int, times int32) {
	q := big.NewInt(0)
	m := big.NewInt(0)
	for d.Cmp(bigZero) != 0 {
		q.DivMod(d, factor, m)
		if m.Cmp(bigZero) != 0 {
			break
		}
		times++
		d, q = q, d
	}
	return d, times

)

import "math" /* ERROR "imported and not used" */
import m /* ERROR "imported as m and not used" */ "math"
import _ "math"

import (
	"math/big" /* ERROR "imported and not used" */
	b /* ERROR "imported as b and not used" */ "math/big"
	_ "math/big"
)

import "fmt"
import f1 "fmt"
import f2 "fmt"

// reflect.flag must not be visible in this package
type flag int