func extractDigit() int64 {
	if big.CmpInt(numer, accum) > 0 {
		return -1
	}
	tmp1.Lsh(numer, 1).Add(tmp1, numer).Add(tmp1, accum)
	big.DivModInt(tmp1, tmp2, tmp1, denom)
	tmp2.Add(tmp2, numer)
	if big.CmpInt(tmp2, denom) >= 0 {
		return -1
	}
	return tmp1.Int64()
}

func nextTerm(k int64) {
	y2 := k*2 + 1
	accum.Add(accum, tmp1.Lsh(numer, 1))
	accum.Mul(accum, tmp1.SetInt64(y2))
	numer.Mul(numer, tmp1.SetInt64(k))

			t.tok = ARR
			return ARR
		}
	case '@':
		if s.Peek() == '>' {
			s.Next()
			t.tok = ROT
			return ROT
		}
	case '<':
		if s.Peek() == '<' {
			s.Next()
			t.tok = LSH
			return LSH
		}
	case '>':
		if s.Peek() == '>' {
			s.Next()
			t.tok = RSH
			return RSH
		}
	}
	return t.tok
}

func (t *Tokenizer) Close() {
	if t.file != nil {

// returned by text/scanner.Scanner, plus a couple of extra values.
type ScanToken rune

const (
	// Asm defines some two-character lexemes. We make up
	// a rune/ScanToken value for them - ugly but simple.
	LSH          ScanToken = -1000 - iota // << Left shift.
	RSH                                   // >> Logical right shift.
	ARR                                   // -> Used on ARM for shift type 3, arithmetic right shift.

func (z *Int) Mod(x, y *Int) *Int {
	x.doinit()
	y.doinit()
	z.doinit()
	C.mpz_tdiv_r(&z.i[0], &x.i[0], &y.i[0])
	return z
}

// Lsh sets z = x << s and returns z.
func (z *Int) Lsh(x *Int, s uint) *Int {
	x.doinit()
	z.doinit()
	C._mpz_mul_2exp(&z.i[0], &x.i[0], C.ulong(s))
	return z
}

// Rsh sets z = x >> s and returns z.

	ext := ""
	if p.peek() == lex.LSH {
		// (Rn)(Rm<<2), the shifted offset register.
		ext = "LSL"
	} else {
		// (Rn)(Rm.UXTW<1), the extended offset register.
		// Rm.UXTW<<3, the extended register.
		p.get('.')
		tok := p.next()
		ext = tok.String()
	}
	if p.peek() == lex.LSH {
		// parses left shift amount applied after extension: <<Amount
		p.get(lex.LSH)
		tok := p.get(scanner.Int)

	if err != nil {
		return nil, nil, fmt.Errorf("failed to generate private key: %w", err)
	}

	notBefore := time.Now()
	notAfter := notBefore.Add(validFor)

	serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128)
	serialNumber, err := crand.Int(crand.Reader, serialNumberLimit)
	if err != nil {
		return nil, nil, fmt.Errorf("failed to generate serial number: %w", err)
	}

	template := x509.Certificate{

pkg syscall (netbsd-arm64-cgo), const BPF_LDX ideal-int
pkg syscall (netbsd-arm64-cgo), const BPF_LEN = 128
pkg syscall (netbsd-arm64-cgo), const BPF_LEN ideal-int
pkg syscall (netbsd-arm64-cgo), const BPF_LSH = 96
pkg syscall (netbsd-arm64-cgo), const BPF_LSH ideal-int
pkg syscall (netbsd-arm64-cgo), const BPF_MAJOR_VERSION = 1
pkg syscall (netbsd-arm64-cgo), const BPF_MAJOR_VERSION ideal-int
pkg syscall (netbsd-arm64-cgo), const BPF_MAXBUFSIZE = 16777216

pkg syscall (darwin-386), const BPF_K = 0
pkg syscall (darwin-386), const BPF_LD = 0
pkg syscall (darwin-386), const BPF_LDX = 1
pkg syscall (darwin-386), const BPF_LEN = 128
pkg syscall (darwin-386), const BPF_LSH = 96
pkg syscall (darwin-386), const BPF_MAJOR_VERSION = 1
pkg syscall (darwin-386), const BPF_MAXBUFSIZE = 524288
pkg syscall (darwin-386), const BPF_MAXINSNS = 512
pkg syscall (darwin-386), const BPF_MEM = 96

pkg syscall (freebsd-386-cgo), const BPF_LD ideal-int
pkg syscall (freebsd-386-cgo), const BPF_LDX ideal-int
pkg syscall (freebsd-386-cgo), const BPF_LEN ideal-int
pkg syscall (freebsd-386-cgo), const BPF_LSH ideal-int
pkg syscall (freebsd-386-cgo), const BPF_MAJOR_VERSION ideal-int
pkg syscall (freebsd-386-cgo), const BPF_MAXBUFSIZE ideal-int
pkg syscall (freebsd-386-cgo), const BPF_MAXINSNS ideal-int

pkg syscall (freebsd-riscv64), const BPF_LEN = 128 #53466
pkg syscall (freebsd-riscv64), const BPF_LEN ideal-int #53466
pkg syscall (freebsd-riscv64), const BPF_LSH = 96 #53466
pkg syscall (freebsd-riscv64), const BPF_LSH ideal-int #53466
pkg syscall (freebsd-riscv64), const BPF_MAJOR_VERSION = 1 #53466
pkg syscall (freebsd-riscv64), const BPF_MAJOR_VERSION ideal-int #53466