}
	return dst
}

func base128BigIntLength(n *big.Int) int {
	if n.Cmp(big.NewInt(0)) == 0 {
		return 1
	}
	return (n.BitLen() + 6) / 7
}

func appendBase128BigInt(dst []byte, n *big.Int) []byte {
	if n.Cmp(big.NewInt(0)) == 0 {
		return append(dst, 0)
	}

	for i := base128BigIntLength(n) - 1; i >= 0; i-- {
		o := byte(big.NewInt(0).Rsh(n, uint(i)*7).Bits()[0])
		o &= 0x7f
		if i != 0 {

}

func _() {
	var x big.Float
	_ = x.neg // ERROR "x.neg undefined (type big.Float has no field or method neg, but does have method Neg)"
	_ = x.nEg // ERROR "x.nEg undefined (type big.Float has no field or method nEg)"
	_ = x.Neg
	_ = x.NEg // ERROR "x.NEg undefined (type big.Float has no field or method NEg, but does have method Neg)"

	t.Run("1", func(t *testing.T) {
		checkScalar(t, big.NewInt(1).FillBytes(make([]byte, byteLen)))
	})
	t.Run("N-1", func(t *testing.T) {
		checkScalar(t, new(big.Int).Sub(c.Params().N, big.NewInt(1)).Bytes())
	})
	t.Run("N", func(t *testing.T) { checkScalar(t, c.Params().N.Bytes()) })
	t.Run("N+1", func(t *testing.T) {
		checkScalar(t, new(big.Int).Add(c.Params().N, big.NewInt(1)).Bytes())
	})
	t.Run("all1s", func(t *testing.T) {

// and foreign code on multiple pthreads.

package main

import (
	big "."
	"runtime"
)

func fibber(c chan *big.Int, out chan string, n int64) {
	// Keep the fibbers in dedicated operating system
	// threads, so that this program tests coordination
	// between pthreads and not just goroutines.
	runtime.LockOSThread()

	i := big.NewInt(n)
	if n == 0 {
		c <- i
	}
	for {
		j := <-c
		out <- j.String()

	"encoding/asn1"
	"errors"
	"math/big"
)

// pkcs1PrivateKey is a structure which mirrors the PKCS #1 ASN.1 for an RSA private key.
type pkcs1PrivateKey struct {
	Version int
	N       *big.Int
	E       int
	D       *big.Int
	P       *big.Int
	Q       *big.Int
	// We ignore these values, if present, because rsa will calculate them.
	Dp   *big.Int `asn1:"optional"`
	Dq   *big.Int `asn1:"optional"`

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

package p

import "math/big"

// From go.dev/issue/18419
func _(x *big.Float) {
	x.form /* ERROR "x.form undefined (cannot refer to unexported field form)" */ ()
}

// From go.dev/issue/31053
func _() {
	_ = big.Float{form /* ERROR "cannot refer to unexported field form in struct literal of type big.Float" */ : 0}

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

package main

import (
	"fmt"
	"math/big"
)

//go:noinline
func f(x uint32) *big.Int {
	return big.NewInt(int64(x))
}
func main() {
	b := f(0xffffffff)
	c := big.NewInt(0xffffffff)
	if b.Cmp(c) != 0 {
		panic(fmt.Sprintf("b:%x c:%x", b, c))
	}

		"Error [B1] (SoapBubble) Explosion accident: the bubble is too big\n" +
			"Warning [C1] (GrandCastle) Collapse danger: the castle is too old",
	))
}

func TestFormatter_PrintLogWithColor(t *testing.T) {
	g := NewWithT(t)

	firstMsg := diag.NewMessage(
		diag.NewMessageType(diag.Error, "B1", "Explosion accident: %v"),
		diag.MockResource("SoapBubble"),
		"the bubble is too big",
	)
	secondMsg := diag.NewMessage(

	default:
		panic("unexpected type")
	}
	return cmp(min, "<=", val) && cmp(val, "<=", max)
}

func getValues(typ string) []*big.Int {
	Uint := func(v uint64) *big.Int { return big.NewInt(0).SetUint64(v) }
	Int := func(v int64) *big.Int { return big.NewInt(0).SetInt64(v) }
	values := []*big.Int{
		// limits
		Uint(maxU64),
		Uint(maxU64 - 1),
		Uint(maxI64 + 1),
		Uint(maxI64),
		Uint(maxI64 - 1),
		Uint(maxU32 + 1),

	}

	// Fill in the backwards-compatibility *big.Int values.
	if priv.Precomputed.Dp != nil {
		return
	}

	priv.Precomputed.Dp = new(big.Int).Sub(priv.Primes[0], bigOne)
	priv.Precomputed.Dp.Mod(priv.D, priv.Precomputed.Dp)

	priv.Precomputed.Dq = new(big.Int).Sub(priv.Primes[1], bigOne)
	priv.Precomputed.Dq.Mod(priv.D, priv.Precomputed.Dq)

	priv.Precomputed.Qinv = new(big.Int).ModInverse(priv.Primes[1], priv.Primes[0])