func EnableKlogWithGoFlag() {
	gf := klogVerboseFlag()
	goflag.CommandLine.Var(gf.Value, "vklog", gf.Usage+". Like -v flag. ex: --vklog=9")
}

// isKlogVerbose returns true if klog verbosity is non-zero.
func klogVerbose() bool {
	gf := klogVerboseFlag()
	return gf.Value.String() != "0"
}

var (
	klogFlagSet     = &goflag.FlagSet{}
	klogFlagSetOnce = sync.Once{}
)

		t.Errorf("test.v flag (type %T) does not have IsBoolFlag method", f)
	} else if !bf.IsBoolFlag() {
		t.Error("test.v IsBoolFlag() returned false")
	}

	gf, ok := f.Value.(flag.Getter)
	if !ok {
		t.Fatalf("test.v flag (type %T) does not have Get method", f)
	}
	v := gf.Get()

	var want any
	switch *testFlagArg {
	case "":
		want = false
	case "-test.v":
		want = true
	case "-test.v=test2json":

		}
	}
}

// Multiply b and c as GF(2) polynomials modulo poly
func mul(b, c uint32) uint32 {
	i := b
	j := c
	s := uint32(0)
	for k := uint32(1); k < 0x100 && j != 0; k <<= 1 {
		// Invariant: k == 1<<n, i == b * xⁿ

		if j&k != 0 {
			// s += i in GF(2); xor in binary
			s ^= i
			j ^= k // turn off bit to end loop early
		}

		// i *= x in GF(2) modulo the polynomial
		i <<= 1
		if i&0x100 != 0 {

	if len(gobFacts) > 0 {
		if err := gob.NewEncoder(&buf).Encode(gobFacts); err != nil {
			// Fact encoding should never fail. Identify the culprit.
			for _, gf := range gobFacts {
				if err := gob.NewEncoder(io.Discard).Encode(gf); err != nil {
					fact := gf.Fact
					pkgpath := reflect.TypeOf(fact).Elem().PkgPath()

      |2lt5/qFtgUpEon2j06rd/0+ODqqVJX+6d3SpmF1fPfKUB6AOZbxEkaJpBSTavoTg
      |G2M/NMdjZjrcB3quNQcLg54mmI3HJm1zOd/8i2fZjvoiyVY30Inn2SmQsAotXw1u
      |aE/319bnR2sQlnkp6MJU0eLEtKyRif/IODvY+mtRYYdkFtoeT6qQPMIh+gF/H3to
      |5tjs3g59QC8k2TJDop4EFYUOwdrtnb8wUiBnLyURD1szASE2IO2Ftk1zaNOPKtrv
      |VeJuB/mpAgMBAAGjIDAeMBwGA1UdEQEB/wQSMBCHBAEBAQGCCGNhc2guYXBwMA0G
      |CSqGSIb3DQEBCwUAA4IBAQAPm7vfk+rxSucxxbFiimmFKBw+ymieLY/kznNh0lHJ

	i = ((i << 1) & 0xa) | ((i >> 1) & 0x5)
	return i
}

// gcmAdd adds two elements of GF(2¹²⁸) and returns the sum.
func gcmAdd(x, y *gcmFieldElement) gcmFieldElement {
	// Addition in a characteristic 2 field is just XOR.
	return gcmFieldElement{x.low ^ y.low, x.high ^ y.high}
}

// gcmDouble returns the result of doubling an element of GF(2¹²⁸).
func gcmDouble(x *gcmFieldElement) (double gcmFieldElement) {
	msbSet := x.high&1 == 1

				return
			}
		case "rtf":
			z.RmvTagFailedTotal, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "RmvTagFailedTotal")
				return
			}
		case "gf":
			z.GetFailedTotal, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "GetFailedTotal")
				return
			}
		case "hf":
			z.HeadFailedTotal, err = dc.ReadUint64()
			if err != nil {

		if x.Sign() != 0 && x.Cmp(priv.Q) < 0 {
			break
		}
	}

	priv.X = x
	priv.Y = new(big.Int)
	priv.Y.Exp(priv.G, x, priv.P)
	return nil
}

// fermatInverse calculates the inverse of k in GF(P) using Fermat's method.
// This has better constant-time properties than Euclid's method (implemented
// in math/big.Int.ModInverse) although math/big itself isn't strictly
// constant-time so it's not perfect.

00000010  b9 47 4b 47 49 af 52 88  3c 12 50 0d 65 46 f7 a1  |.GKGI.R.<.P.eF..|
00000020  50 39 c5 39 22 b3 45 e6  d3 25 44 a6 bc 3d bc 69  |P9.9".E..%D..=.i|
00000030  35 1d 61 cf a0 3c 53 77  94 67 66 ae 37 7f 3f 84  |5.a..<Sw.gf.7.?.|
00000040  17 03 03 00 17 5e 1d af  5b 7c b6 2d 19 ea 18 e0  |.....^..[|.-....|
00000050  55 47 43 e1 f2 0e 28 49  ae ef ba 86 17 03 03 00  |UGC...(I........|

nRMCydsnk1DV02qXNhKBENb5lIAckbwgu4TauT+EfSQh4/2qhmITF8fXAekIGvuU
y4KCsTiQ4dWzbOiTHtmDruCt/TNUCJE6W4sZ7e158pZW9upNJQ03f0R3babeGAbF
N8JirBXUuglIErY9E7mgLBCeY76bgQIDAQABAoICAAwq33wH0mvAgTHdNMywz/GF
h3zese2nbG+qU8CUMzULGdLBmqPFN5rqWaZmCrfIAoHHipP/Siki7DUoLLXivStQ
amq6YWa7aFlup80/txIYy9n39KHW5Wdx1EydHtqHUkbIhSFmEUpfp8zrkNo2V+M0
UW8+mOMEdza798sWCduegZC1OysGYGSNClFMQgF2FgOzpIUy8SocV8/oLG0FrfnX