public final void addTearDown(TearDown tearDown) {
    synchronized (stack) {
      stack.addFirst(checkNotNull(tearDown));
    }
  }

  /** Causes teardown to execute. */
  public final void runTearDown() {
    List<Throwable> exceptions = new ArrayList<>();
    List<TearDown> stackCopy;
    synchronized (stack) {
      stackCopy = Lists.newArrayList(stack);
      stack.clear();
    }
    for (TearDown tearDown : stackCopy) {

UserRegionBegin dt=286 task=1 name_string=24 stack=15
UserRegionBegin dt=244 task=1 name_string=25 stack=16
UserRegionBegin dt=6 task=1 name_string=26 stack=17
UserLog dt=6 task=1 key_string=27 value_string=28 stack=18
UserRegionEnd dt=4 task=1 name_string=26 stack=19
UserRegionEnd dt=315 task=1 name_string=25 stack=20
UserTaskEnd dt=5 task=1 stack=21
GoUnblock dt=11 g=1 g_seq=1 stack=22
GoDestroy dt=6
GoStart dt=10 g=1 g_seq=2

# still be cached separately.
# Verifies golang.org/issue/35412.
go get example.com/stack@v1.0.0
go run -trimpath printstack.go
stdout '^example.com/stack@v1.0.0/stack.go$'
go get example.com/stack@v1.0.1
go run -trimpath printstack.go
stdout '^example.com/stack@v1.0.1/stack.go$'

-- $WORK/hello.go --
package main
func main() { println("hello") }

-- $WORK/printstack.go --

		switch {
		case g == nil:
			// No g: we're on a C stack or a signal stack.
			ret = callCgoSigaction(uintptr(sig), new, old)
		case sp < g.stack.lo || sp >= g.stack.hi:
			// We're no longer on g's stack, so we must be handling a signal.  It's
			// possible that we interrupted the thread during a transition between g
			// and g0, so we should stay on the current stack to avoid corrupting g0.
			ret = callCgoSigaction(uintptr(sig), new, old)

	m.pcs[pcs] = stack
	m.stacks[stack] = rec
	return rec
}

func (m *stackMap) profile() []traceviewer.ProfileRecord {
	prof := make([]traceviewer.ProfileRecord, 0, len(m.stacks))
	for stack, record := range m.stacks {
		rec := *record
		i := 0
		stack.Frames(func(frame trace.StackFrame) bool {
			rec.Stack = append(rec.Stack, &trace.Frame{
				PC:   frame.PC,
				Fn:   frame.Func,

GoBlock dt=4 reason_string=12 stack=25
GoStart dt=3 g=19 g_seq=1
GoUnblock dt=5 g=1 g_seq=7 stack=26
GoBlock dt=2 reason_string=15 stack=27
GoStart dt=2 g=1 g_seq=8
GoCreate dt=8 new_g=20 new_stack=23 stack=24
GoBlock dt=3 reason_string=12 stack=25
GoStart dt=2 g=20 g_seq=1
GoUnblock dt=3 g=1 g_seq=9 stack=26
GoBlock dt=1 reason_string=15 stack=27
GoStart dt=2 g=1 g_seq=10

func balancedParentheses(s string) bool {
	var stack []byte
	for _, ch := range s {
		var open byte
		switch ch {
		case '(', '[', '{':
			stack = append(stack, byte(ch))
			continue
		case ')':
			open = '('
		case ']':
			open = '['
		case '}':
			open = '{'
		default:
			continue
		}
		// closing parenthesis/bracket must have matching opening
		top := len(stack) - 1
		if top < 0 || stack[top] != open {

		},
		{
			svcSubnetList: "fd03::/112,192.168.10.0/24",
			expected:      "fd03::/112",
			expectedError: false,
			name:          "valid: valid <IPv6,IPv4> ranges from dual-stack",
		},
		{
			svcSubnetList: "192.168.10.0/24,fd03:x::/112",
			expected:      "",
			expectedError: true,
			name:          "invalid: failed to parse subnet range for dual-stack",
		},
	}

	// Create a new goroutine to get a default-size stack segment.
	go func() {
		x := new(X)
		clos(x.foo)()
		c <- true
	}()
	<-c
}

type X int

func (x *X) foo() {
}

func clos(x func()) func() {
	f := func() {
		print("")
		x() // This statement crashed, because the partial call was allocated on the old stack.
	}
	// Grow stack so that partial call x becomes invalid if allocated on stack.

    %elem = "tf._SomeOp"() : () -> tensor<f32>
    %push = "tf.StackPushV2"(%stack, %elem) {swap_memory = false} : (tensor<!tf_type.resource>, tensor<f32>) -> tensor<f32>
    "tf.Yield"(%stack) : (tensor<!tf_type.resource>) -> ()
  }, {
    %pop = "tf.StackPopV2"(%stack) : (tensor<!tf_type.resource>) -> tensor<f32>
    "tf.Yield"(%stack) : (tensor<!tf_type.resource>) -> ()
  }) {is_stateless = false}