//
	// 13. Let H' = Hash(M'), an octet string of length hLen.
	var prefix [8]byte
	hash.Write(prefix[:])
	hash.Write(mHash)
	hash.Write(salt)

	h0 := hash.Sum(nil)

	// 14. If H = H', output "consistent." Otherwise, output "inconsistent."
	if !bytes.Equal(h0, h) { // TODO: constant time?
		return ErrVerification
	}
	return nil
}

		return fmt.Sprintf("W%d", int(r-W0))
	case X0 <= r && r <= X30:
		return fmt.Sprintf("X%d", int(r-X0))

	case B0 <= r && r <= B31:
		return fmt.Sprintf("B%d", int(r-B0))
	case H0 <= r && r <= H31:
		return fmt.Sprintf("H%d", int(r-H0))
	case S0 <= r && r <= S31:
		return fmt.Sprintf("S%d", int(r-S0))
	case D0 <= r && r <= D31:
		return fmt.Sprintf("D%d", int(r-D0))
	case Q0 <= r && r <= Q31:

	if q < 0 {
		// Inverse powers of ten must be rounded up.
		pow[0] += 1
	}
	e2 += mulByLog10Log2(q) - 127 + 119

	// long multiplication
	l1, l0 := bits.Mul64(m, pow[0])
	h1, h0 := bits.Mul64(m, pow[1])
	mid, carry := bits.Add64(l1, h0, 0)
	h1 += carry
	return h1<<9 | mid>>55, e2, mid<<9 == 0 && l0 == 0
}

func divisibleByPower5(m uint64, k int) bool {
	if m == 0 {
		return true
	}

00000350  58 f7 65 0e 8d                                    |X.e..|
>>> Flow 4 (server to client)
00000000  14 03 03 00 01 01 16 03  03 00 28 3f eb 87 50 b0  |..........(?..P.|
00000010  ae c2 fd 68 30 95 94 61  1c 78 1e 60 3e 38 17 ef  |...h0..a.x.`>8..|
00000020  ed 9b f1 10 26 5e 53 a3  8c 46 2e 6c 24 b2 ab a7  |....&^S..F.l$...|
00000030  6c f0 ea                                          |l..|
>>> Flow 5 (client to server)

	}
	h1 := runDbgr(dbg, count)
	if *dryrun {
		fmt.Printf("# Tag for above is %s\n", dbg.tag())
		return
	}
	if *update {
		h1.write(nextlog)
	} else {
		h0 := &nextHist{}
		h0.read(nextlog)
		if !h0.equals(h1) {
			// Be very noisy about exactly what's wrong to simplify debugging.
			h1.write(tmplog)
			cmd := testenv.Command(t, "diff", "-u", nextlog, tmplog)
			line := asCommandLine("", cmd)

00000260  1f d1 05 f5 39 76 61 e6  a6 ea 75 0e 50 32 a1 19  |....9va...u.P2..|
00000270  20 6a 4c 5d 62 6e 2a 6e  af f9 9c 38 b6 3a bc 86  | jL]bn*n...8.:..|
00000280  eb ac 6d d3 b5 48 30 11  4d 98 2e 61 34 16 03 03  |..m..H0.M..a4...|
00000290  00 88 0f 00 00 84 08 04  00 80 82 ed 3f da b5 50  |............?..P|
000002a0  d2 50 51 14 cf ee f7 b9  7b a9 0c 77 2f 88 42 0a  |.PQ.....{..w/.B.|

func (c *Connection) shouldConnect() bool {
	// The remote should have the opposite result.
	h0 := xxh3.HashString(c.Local + c.Remote)
	h1 := xxh3.HashString(c.Remote + c.Local)
	if h0 == h1 {
		return c.Local < c.Remote
	}
	return h0 < h1
}

func (c *Connection) send(ctx context.Context, msg []byte) error {
	select {
	case <-ctx.Done():

// Returns nil if the given interface/type pair isn't present.
func (t *itabTableType) find(inter *interfacetype, typ *_type) *itab {
	// Implemented using quadratic probing.
	// Probe sequence is h(i) = h0 + i*(i+1)/2 mod 2^k.
	// We're guaranteed to hit all table entries using this probe sequence.
	mask := t.size - 1
	h := itabHashFunc(inter, typ) & mask
	for i := uintptr(1); ; i++ {

n?this.plugin+": "+this.text:this.text}};Ef.exports=Pi;Pi.default=Pi});var Ii=v((tT,Tf)=>{l();"use strict";var h0=Os(),Di=class{constructor(e,t,r){this.processor=e,this.messages=[],this.root=t,this.opts=r,this.css=void 0,this.map=void 0}toString(){return this.css}warn(e,t={}){t.plugin||this.lastPlugin&&this.lastPlugin.postcssPlugin&&(t.plugin=this.lastPlugin.postcssPlugin);let r=new h0(e,t);return this.messages.push(r),r}warnings(){return this.messages.filter(e=>e.type==="warning")}get content(){return...

11O\360\333?w\340\027\371\220W\347?8s\254\276s\206\305?\270\014\317\231\346\232\312?\263\014\332\307sS\350?\375\317\364\274}\204\353?\266\343E:\341\324\357?\261\326\243\346\214/\342?\226\300\217\310\000\235\331?\210+\217&k\225\265?\"d7R\215\377\356?H0\326\206\315\235\332?\020\343\264\335d\337\243?\324\000\033\202#Z\334?\230\345y\374RE\312?\246\261\363\366\265\271\333?\3166\021\024\211\236\321?\010z\221\017\026\222\277?~\265\312\317\347\276\342?[n\\M\212\024\346?\222\237\344lV\021\323?\353ys\252\...