encoder         runtime.Encoder
	framer          io.Writer

	buffer      runtime.Splice
	eventBuffer runtime.Splice

	currentEmbeddedIdentifier runtime.Identifier
	identifiers               map[watch.EventType]runtime.Identifier
}

func newWatchEncoder(ctx context.Context, kind schema.GroupVersionKind, embeddedEncoder runtime.Encoder, encoder runtime.Encoder, framer io.Writer) *watchEncoder {
	return &watchEncoder{

// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package trace

// Frame is a frame in stack traces.
type Frame struct {
	PC   uint64
	Fn   string
	File string
	Line int
}

const (
	// Special P identifiers:
	FakeP    = 1000000 + iota
	TimerP   // depicts timer unblocks
	NetpollP // depicts network unblocks

			if !ok {
				print("BUG: bug347: cannot find caller\n")
				return
			}
			if !strings.Contains(file, "bug347.go") || runtime.FuncForPC(pc).Name() != "main.f" {
				// walk past runtime frames
				continue
			}
			if line != 22 {
				print("BUG: bug347: panic at ", file, ":", line, " in ", runtime.FuncForPC(pc).Name(), "\n")
			}
			return
		}
	}()
	f()

			// Make sure x.data hasn't been collected.
			if got := *x.data; got != i {
				panic(fmt.Sprintf("bad data want %d, got %d", i, got))
			}
		}
		return
	}
	// Put 2 objects in each frame, to test intra-frame pointers.
	// Use both orderings to ensure the linked list isn't always in address order.
	var a, b T
	if n%3 == 0 {
		a.data = newInt(n)
		a.next = x
		a.next2 = x
		b.data = newInt(n - 1)
		b.next = &a

	if err != nil {
		return Event{}, err
	}
	if spec.IsStack {
		len := int(args[1])
		for i := 0; i < len; i++ {
			// Each stack frame has four args: pc, func ID, file ID, line number.
			frame, err := r.readArgs(4)
			if err != nil {
				return Event{}, err
			}
			args = append(args, frame...)
		}
	}
	var data []byte
	if spec.HasData {
		data, err = r.readData()
		if err != nil {
			return Event{}, err
		}
	}

			if !ok {
				print("BUG: bug348: cannot find caller\n")
				return
			}
			if !strings.Contains(file, "bug348.go") || runtime.FuncForPC(pc).Name() != "main.f" {
				// walk past runtime frames
				continue
			}
			if line != 17 {
				print("BUG: bug348: panic at ", file, ":", line, " in ", runtime.FuncForPC(pc).Name(), "\n")
				return
			}
			recover()
			return
		}
	}()
	f()

        this.classifiers = ImmutableList.copyOf(classifiers);
    }

    @Nullable
    @Override
    public StackTraceRelevance classify(StackTraceElement frame) {
        for (StackTraceClassifier classifier : classifiers) {
            StackTraceRelevance relevance = classifier.classify(frame);
            if (relevance != null) {
                return relevance;
            }
        }
        return null;
    }

	// Save callback register arguments R0-R7.
	// We do this at the top of the frame so they're contiguous with stack arguments.
	// The 7*8 setting up R14 looks like a bug but is not: the eighth word
	// is the space the assembler reserved for our caller's frame pointer,
	// but we are not called from Go so that space is ours to use,
	// and we must to be contiguous with the stack arguments.

	conn.resetTimeout()
	switch conn.codec {
	case rawCodec:
		frame := make([]byte, len(data)+1)
		frame[0] = num
		copy(frame[1:], data)
		if err := websocket.Message.Send(conn.ws, frame); err != nil {
			return 0, err
		}
	case base64Codec:
		frame := string('0'+num) + base64.StdEncoding.EncodeToString(data)
		if err := websocket.Message.Send(conn.ws, frame); err != nil {
			return 0, err
		}
	}

}

// stackGuardMultiplier returns a multiplier to apply to the default
// stack guard size. Larger multipliers are used for non-optimized
// builds that have larger stack frames or for specific targets.
func stackGuardMultiplier(race bool) int {
	// This arithmetic must match that in runtime/internal/sys/consts.go:StackGuardMultiplier.
	n := 1
	// On AIX, a larger stack is needed for syscalls.