"math"
	"math/bits"
	"sync"
)

const digits = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

// Note: MaxBase = len(digits), but it must remain an untyped rune constant
//       for API compatibility.

// MaxBase is the largest number base accepted for string conversions.
const MaxBase = 10 + ('z' - 'a' + 1) + ('Z' - 'A' + 1)
const maxBaseSmall = 10 + ('z' - 'a' + 1)

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

package big

import (
	"bytes"
	"fmt"
	"io"
	"math/bits"
	"strings"
	"testing"
)

func TestMaxBase(t *testing.T) {
	if MaxBase != len(digits) {
		t.Fatalf("%d != %d", MaxBase, len(digits))
	}
}

// log2 computes the integer binary logarithm of x.
// The result is the integer n for which 2^n <= x < 2^(n+1).
// If x == 0, the result is -1.
func log2(x Word) int {

// error case, the value of z is undefined but the returned value is nil. The
// syntax follows the syntax of integer literals in Go.
//
// The base argument must be 0 or a value from 2 through MaxBase. If the base
// is 0, the string prefix determines the actual conversion base. A prefix of
// “0b” or “0B” selects base 2; a “0”, “0o”, or “0O” prefix selects

pkg html/template, type Srcset string
pkg math, func Erfcinv(float64) float64
pkg math, func Erfinv(float64) float64
pkg math, func Round(float64) float64
pkg math, func RoundToEven(float64) float64
pkg math/big, const MaxBase = 62
pkg math/big, method (*Float) Sqrt(*Float) *Float
pkg math/big, method (*Int) CmpAbs(*Int) int
pkg math/rand, func Shuffle(int, func(int, int))
pkg math/rand, method (*Rand) Shuffle(int, func(int, int))

pkg math/big, const MaxBase = 36
pkg math/big, type Word uintptr
pkg net, func ListenUnixgram(string, *UnixAddr) (*UDPConn, error)
pkg os (linux-arm), const O_SYNC = 1052672
pkg os (linux-arm), const O_SYNC = 4096

// (not just a prefix) must be valid for success. If SetString fails,
// the value of z is undefined but the returned value is nil.
//
// The base argument must be 0 or a value between 2 and [MaxBase].
// For base 0, the number prefix determines the actual base: A prefix of
// “0b” or “0B” selects base 2, “0”, “0o” or “0O” selects base 8,
// and “0x” or “0X” selects base 16. Otherwise, the selected base is 10

// characters that involve multiple runes in the input or output.

// Indices into the Delta arrays inside CaseRanges for case mapping.
const (
	UpperCase = iota
	LowerCase
	TitleCase
	MaxCase
)

type d [MaxCase]rune // to make the CaseRanges text shorter

// If the Delta field of a [CaseRange] is UpperLower, it means
// this CaseRange represents a sequence of the form (say)
// [Upper] [Lower] [Upper] [Lower].
const (

var Lydian <type 1>;
var M <type 1>;
var Mahajani <type 1>;
var Malayalam <type 1>;
var Mandaic <type 1>;
var Manichaean <type 1>;
var Marchen <type 1>;
var Mark <type 1>;
const MaxASCII = 127' ;
const MaxCase = 3 ;
const MaxLatin1 = 255' ;
const MaxRune = 1114111' ;
var Mc <type 1>;
var Me <type 1>;
var Meetei_Mayek <type 1>;
var Mende_Kikakui <type 1>;
var Meroitic_Cursive <type 1>;

			}
		}
	}
}

func TestSpecialCaseNoMapping(t *testing.T) {
	// Issue 25636
	// no change for rune 'A', zero delta, under upper/lower/title case change.
	var noChangeForCapitalA = CaseRange{'A', 'A', [MaxCase]rune{0, 0, 0}}
	got := strings.ToLowerSpecial(SpecialCase([]CaseRange{noChangeForCapitalA}), "ABC")
	want := "Abc"
	if got != want {
		t.Errorf("got %q; want %q", got, want)
	}
}

		{"Accuracy", Type, 5},
		{"AwayFromZero", Const, 5},
		{"Below", Const, 5},
		{"ErrNaN", Type, 5},
		{"Exact", Const, 5},
		{"Float", Type, 5},
		{"Int", Type, 0},
		{"Jacobi", Func, 5},
		{"MaxBase", Const, 0},
		{"MaxExp", Const, 5},
		{"MaxPrec", Const, 5},
		{"MinExp", Const, 5},
		{"NewFloat", Func, 5},
		{"NewInt", Func, 0},
		{"NewRat", Func, 0},
		{"ParseFloat", Func, 5},