// Build a 32-byte stack frame for us for this call.
	// Saved LR (none available) is at the bottom,
	// then the PC argument for setsigsegv,
	// then a copy of the LR for us to restore.
	MOVD.W $0, -32(RSP)
	MOVD R1, 8(RSP)
	MOVD R2, 16(RSP)
	BL runtime·setsigsegv(SB)
	MOVD 8(RSP), R1
	MOVD 16(RSP), R2

	// Build a 16-byte stack frame for the simulated

	// badCharSkip[b] is len(pattern).
	//
	// Whenever a mismatch is found with byte b in the text, we can safely
	// shift the matching frame at least badCharSkip[b] until the next time
	// the matching char could be in alignment.
	badCharSkip [256]int

	// goodSuffixSkip[i] defines how far we can shift the matching frame given
	// that the suffix pattern[i+1:] matches, but the byte pattern[i] does
	// not. There are two cases to consider:
	//

// fn is the PC of a func(a unsafe.Pointer) function.
// The value of R2 is saved on the new stack frame, and not
// the caller's frame due to issue #43228.
TEXT crosscall2(SB),NOSPLIT|NOFRAME,$0
	// Start with standard C stack frame layout and linkage, allocate
	// 32 bytes of argument space, save callee-save regs, and set R0 to $0.
	STACK_AND_SAVE_HOST_TO_GO_ABI(32)

	tests := []struct {
		name     string
		pc       uintptr
		hasframe bool
	}{
		{"no frame func", abi.FuncPCABIInternal(sehf2), false},
		{"no func", sehf1pc - 1, false},
		{"func at entry", sehf1pc, true},
		{"func in prologue", sehf1pc + 1, true},
		{"anonymous func with frame", abi.FuncPCABIInternal(fnwithframe), true},
		{"anonymous func without frame", abi.FuncPCABIInternal(fnwithoutframe), false},

#define TLSBSS	256
// Do not insert instructions to allocate a stack frame for this function.
// Only valid on functions that declare a frame size of 0.
#define NOFRAME 512
// Function can call reflect.Type.Method or reflect.Type.MethodByName.
#define REFLECTMETHOD 1024
// Function is the outermost frame of the call stack. Call stack unwinders
// should stop at this function.
#define TOPFRAME 2048

	lock.Lock()
	defer lock.Unlock()

	var pcs [50]uintptr
	nCallers := runtime.Callers(2, pcs[:])
	frames := runtime.CallersFrames(pcs[:nCallers])
	thisTest := ""
	for {
		frame, more := frames.Next()
		if strings.HasSuffix(frame.File, "_test.go") && testFunction.MatchString(frame.Function) {
			thisTest = frame.Function
			break
		}
		if !more {
			break
		}
	}

	if len(thisTest) == 0 {

// the function returned from MakeFunc. It expects a *callReflectFunc
// as its context register, and its job is to invoke callReflect(ctxt, frame)
// where ctxt is the context register and frame is a pointer to the first
// word in the passed-in argument frame.
func makeFuncStub()

// The first 3 words of this type must be kept in sync with
// makeFuncImpl and runtime.reflectMethodValue.

// license that can be found in the LICENSE file.

// Macros for transitioning from the host ABI to Go ABI0.
//
// These save the frame pointer, so in general, functions that use
// these should have zero frame size to suppress the automatic frame
// pointer, though it's harmless to not do this.

#ifdef GOOS_windows

// REGS_HOST_TO_ABI0_STACK is the stack bytes used by
// PUSH_REGS_HOST_TO_ABI0.

		}
		n++
	}
	n++

	frame("runtime/debug/stack.go", "runtime/debug.Stack")
	frame("runtime/debug/stack_test.go", "runtime/debug_test.(*T).ptrmethod")
	frame("runtime/debug/stack_test.go", "runtime/debug_test.T.method")
	frame("runtime/debug/stack_test.go", "runtime/debug_test.TestStack")
	frame("testing/testing.go", "")
}

func TestSetCrashOutput(t *testing.T) {

      direction,
      streamId,
      length,
      formattedType,
      formattedFlags,
    )
  }

  /**
   * Returns a human-readable representation of a `WINDOW_UPDATE` frame. This frame includes the
   * window size increment instead of flags.
   */
  fun frameLogWindowUpdate(
    inbound: Boolean,
    streamId: Int,
    length: Int,
    windowSizeIncrement: Long,
  ): String {