MOVQ	SP, BX	// hide (SP) reads from vet
	MOVQ	8(BX), BX	// caller's PC
	MOVQ	BX, (g_sched+gobuf_pc)(R14)
	LEAQ	fn+0(FP), BX	// caller's SP
	MOVQ	BX, (g_sched+gobuf_sp)(R14)
	// Get the caller's frame pointer by dereferencing BP. Storing BP as it is
	// can cause a frame pointer cycle, see CL 476235.
	MOVQ	(BP), BX // caller's BP
	MOVQ	BX, (g_sched+gobuf_bp)(R14)

				{1, 239}, // AX CX DX BX BP SI DI
			},
			outputs: []outputInfo{
				{0, 239}, // AX CX DX BX BP SI DI
			},
		},
	},
	{
		name:         "ADCLconst",
		auxType:      auxInt32,
		argLen:       2,
		resultInArg0: true,
		clobberFlags: true,
		asm:          x86.AADCL,
		reg: regInfo{
			inputs: []inputInfo{
				{0, 239}, // AX CX DX BX BP SI DI
			},

		for by := 0; by*v < d.height; by++ {
			for bx := 0; bx*h < d.width; bx++ {
				if err := d.reconstructBlock(&d.progCoeffs[i][by*stride+bx], bx, by, i); err != nil {
					return err
				}
			}
		}
	}
	return nil
}

// reconstructBlock dequantizes, performs the inverse DCT and stores the block
// to the image.
func (d *decoder) reconstructBlock(b *block, bx, by, compIndex int) error {

// R11 = caller's return address
TEXT	racefuncenter<>(SB), NOSPLIT|NOFRAME, $0-0
	MOVQ	DX, BX		// save function entry context (for closures)
	MOVQ	g_racectx(R14), RARG0	// goroutine context
	MOVQ	R11, RARG1
	// void __tsan_func_enter(ThreadState *thr, void *pc);
	MOVQ	$__tsan_func_enter(SB), AX
	// racecall<> preserves BX
	CALL	racecall<>(SB)
	MOVQ	BX, DX	// restore function entry context
	RET

// func runtime·racefuncexit()

// from [P224], [P256], [P384], or [P521].
func (curve *CurveParams) ScalarMult(Bx, By *big.Int, k []byte) (*big.Int, *big.Int) {
	// If there is a dedicated constant-time implementation for this curve operation,
	// use that instead of the generic one.
	if specific, ok := matchesSpecificCurve(curve); ok {
		return specific.ScalarMult(Bx, By, k)
	}
	panicIfNotOnCurve(curve, Bx, By)

	Bz := new(big.Int).SetInt64(1)

00000020  d3 22 c1 e3 a6 c6 cf 6f  47 57 49 20 86 52 fb 0a  |.".....oGWI .R..|
00000030  fd aa 10 47 00 9a 5d ad  4c d8 90 f1 cf 13 10 73  |...G..].L......s|
00000040  31 f1 df 22 f3 42 58 b0  10 25 43 eb cc a8 00 01  |1..".BX..%C.....|
00000050  7e 00 12 01 69 01 67 00  75 00 a4 b9 09 90 b4 18  |~...i.g.u.......|
00000060  58 14 87 bb 13 a2 cc 67  70 0a 3c 35 98 04 f9 1b  |X......gp.<5....|

#define _sa (20*8)
#define _se (21*8)
#define _si (22*8)
#define _so (23*8)
#define _su (24*8)

// Temporary registers
#define rT1  AX

// Round vars
#define rpState DI
#define rpStack SP

#define rDa BX
#define rDe CX
#define rDi DX
#define rDo R8
#define rDu R9

#define rBa R10
#define rBe R11
#define rBi R12
#define rBo R13
#define rBu R14

#define rCa SI
#define rCe BP
#define rCi rBi

			fmt.Printf(" rel %#.4x/%d %s%+d\n", uint32(r.Off), r.Siz, r.Sym.Name, r.Add)
		}
	}

	// Mark nonpreemptible instruction sequences.
	// The 2-instruction TLS access sequence
	//	MOVQ TLS, BX
	//	MOVQ 0(BX)(TLS*1), BX
	// is not async preemptible, as if it is preempted and resumed on
	// a different thread, the TLS address may become invalid.
	if !CanUse1InsnTLS(ctxt) {
		useTLS := func(p *obj.Prog) bool {

00000270  97 e2 8c 9b 86 e2 8a 4d  62 1a bd 35 0e 2d 63 18  |.......Mb..5.-c.|
00000280  a1 1f 7c ed fc 3b 89 c2  00 6d da 01 42 0a 47 95  |..|..;...m..B.G.|
00000290  12 8e 01 82 62 58 f9 96  eb a9 aa c3 f8 96 ec 20  |....bX......... |
000002a0  e1 65 a9 46 a8 af 4b 7c  aa 29 ee 9c 48 18 b3 4a  |.e.F..K|.)..H..J|
000002b0  00 7f 79 97 87 27 92 ca  45 14 03 03 00 01 01 16  |..y..'..E.......|

//
//	b1:
//	  v4 = ArgIntReg <uintptr> {s+8} [0] : BX
//	  v5 = ArgIntReg <int> {used} [0] : CX
//
// While this is an accurate picture of the live incoming params,
// we also want to have debug locations for non-live params (or
// their non-live pieces), e.g. something like
//
//	b1:
//	  v9 = ArgIntReg <*uint8> {s+0} [0] : AX
//	  v4 = ArgIntReg <uintptr> {s+8} [0] : BX
//	  v5 = ArgIntReg <int> {used} [0] : CX