TEXT runtime·usleep(SB),NOSPLIT,$16
	MOVL	$0, DX
	MOVL	usec+0(FP), AX
	MOVL	$1000000, CX
	DIVL	CX
	MOVQ	AX, 0(SP)
	MOVL	$1000, AX	// usec to nsec
	MULL	DX
	MOVQ	AX, 8(SP)

	// nanosleep(&ts, 0)
	MOVQ	SP, DI
	MOVL	$0, SI
	MOVL	$SYS_nanosleep, AX
	SYSCALL
	RET

TEXT runtime·gettid(SB),NOSPLIT,$0-4
	MOVL	$SYS_gettid, AX
	SYSCALL
	MOVL	AX, ret+0(FP)
	RET

	MOVD	$1000000, R5
	MULLW	R4, R5, R5	// Convert tv_sec back into uS
	SUB	R5, R3, R5	// Compute remainder uS.
	MULLD	$1000, R5, R5	// Convert to nsec
	MOVD	R5, 16(R1)	// Store to tv_nsec

	// nanosleep(&ts, 0)
	ADD	$8, R1, R3
	MOVW	$0, R4
	SYSCALL	$SYS_nanosleep
	RET

TEXT runtime·gettid(SB),NOSPLIT,$0-4
	SYSCALL	$SYS_gettid
	MOVW	R3, ret+0(FP)
	RET

TEXT runtime·raise(SB),NOSPLIT|NOFRAME,$0

		"hide":                 "h",
		"show":                 "s",
		"show_from":            "sf",
		"tagfocus":             "tf",
		"tagignore":            "ti",
		"tagshow":              "ts",
		"taghide":              "th",
		"mean":                 "mean",
		"sample_index":         "si",
		"normalize":            "norm",
		"sort":                 "sort",
		"granularity":          "g",

	{"retoffset+28(FP)", "retoffset+28(FP)"},
	{"runtime·_GetStdHandle(SB)", "runtime._GetStdHandle(SB)"},
	{"sync\u2215atomic·AddInt64(SB)", "sync/atomic.AddInt64(SB)"},
	{"timeout+20(FP)", "timeout+20(FP)"},
	{"ts+16(FP)", "ts+16(FP)"},
	{"x+24(FP)", "x+24(FP)"},
	{"x·y(SB)", "x.y(SB)"},
	{"x·y(SP)", "x.y(SP)"},
	{"x·y+8(SB)", "x.y+8(SB)"},
	{"x·y+8(SP)", "x.y+8(SP)"},
	{"y+56(FP)", "y+56(FP)"},

	MOVWU	usec+0(FP), R3
	MOVD	R3, R5
	MOVW	$1000000, R4
	UDIV	R4, R3
	MOVD	R3, 8(RSP)
	MUL	R3, R4
	SUB	R4, R5
	MOVW	$1000, R4
	MUL	R4, R5
	MOVD	R5, 16(RSP)

	// nanosleep(&ts, 0)
	ADD	$8, RSP, R0
	MOVD	$0, R1
	MOVD	$SYS_nanosleep, R8
	SVC
	RET

TEXT runtime·gettid(SB),NOSPLIT,$0-4
	MOVD	$SYS_gettid, R8
	SVC
	MOVW	R0, ret+0(FP)
	RET

// TagMap is a collection of tags, classified by their name.
type TagMap map[string]*Tag

// SortTags sorts a slice of tags based on their weight.
func SortTags(t []*Tag, flat bool) []*Tag {
	ts := tags{t, flat}
	sort.Sort(ts)
	return ts.t
}

// New summarizes performance data from a profile into a graph.
func New(prof *profile.Profile, o *Options) *Graph {
	if o.CallTree {
		return newTree(prof, o)
	}

00000130  92 42 5b c2 81 c0 be 97  79 98 40 fb 4f 6d 14 fd  |.B[.....y.@.Om..|
00000140  2b 13 8b c2 a5 2e 67 d8  d4 09 9e d6 22 38 b7 4a  |+.....g....."8.J|
00000150  0b 74 73 2b c2 34 f1 d1  93 e5 96 d9 74 7b f3 58  |.ts+.4......t{.X|
00000160  9f 6c 61 3c c0 b0 41 d4  d9 2b 2b 24 23 77 5b 1c  |.la<..A..++$#w[.|
00000170  3b bd 75 5d ce 20 54 cf  a1 63 87 1d 1e 24 c4 f3  |;.u]. T..c...$..|

		struct{ x any }{},
		struct{ x map[string]int }{},
		struct{ x func() bool }{},
		struct{ x chan int }{},
		struct{ x []string }{},
		struct{ x unsafe.Pointer }{},
	}
	for _, ts := range doNil {
		ty := TField(TypeOf(ts), 0)
		v := Zero(ty)
		v.IsNil() // panics if not okay to call
	}

	// Check the implementations
	var pi struct {
		x *int
	}
	Nil(pi, t)
	pi.x = new(int)
	NotNil(pi, t)

00000130  92 42 5b c2 81 c0 be 97  79 98 40 fb 4f 6d 14 fd  |.B[.....y.@.Om..|
00000140  2b 13 8b c2 a5 2e 67 d8  d4 09 9e d6 22 38 b7 4a  |+.....g....."8.J|
00000150  0b 74 73 2b c2 34 f1 d1  93 e5 96 d9 74 7b f3 58  |.ts+.4......t{.X|
00000160  9f 6c 61 3c c0 b0 41 d4  d9 2b 2b 24 23 77 5b 1c  |.la<..A..++$#w[.|
00000170  3b bd 75 5d ce 20 54 cf  a1 63 87 1d 1e 24 c4 f3  |;.u]. T..c...$..|

		panic(fmt.Sprintf("Attempting to create subtest %s before running parent", name))
	}

	tc, span := tracing.Start(c.test.tc, name)

	return &testImpl{
		tc:     tc,
		ts:     span,
		name:   name,
		parent: c.test,
		s:      c.test.s,
	}
}

func (c *testContext) NewSubTestf(format string, a ...any) Test {
	return c.NewSubTest(fmt.Sprintf(format, a...))
}