return f;
}

void init() {
        SansTypeface = loadfont();
}

// issue 5242
// Cgo incorrectly computed the alignment of structs
// with no Go accessible fields as 0, and then panicked on
// modulo-by-zero computations.

// issue 50987
// disable arm64 GCC warnings
#cgo CFLAGS: -Wno-psabi -Wno-unknown-warning-option

typedef struct {
} foo;

typedef struct {
	int x : 1;

func TestCVE202230633(t *testing.T) {
	if testing.Short() || runtime.GOARCH == "wasm" {
		t.Skip("test requires significant memory")
	}
	defer func() {
		p := recover()
		if p != nil {
			t.Fatal("Unmarshal panicked")
		}
	}()
	var example struct {
		Things []string
	}
	Unmarshal(bytes.Repeat([]byte("<a>"), 17_000_000), &example)

				// we're not guaranteeing a fully unbroken trace until the last
				// byte...
				seen = true
			}
		}
	}
	if err := cmd.Wait(); err == nil {
		t.Error("the process should have panicked")
	}
	if !seenSync {
		t.Errorf("expected at least one full generation to have been emitted before the trace was considered broken")
	}
	if !seen {

	defer func() {
		if got := recover(); !reflect.DeepEqual(got, 0xdead) {
			t.Errorf("panic() = (%T)(%v), want 0xdead", got, got)
		}
	}()
	Marshal(&marshalPanic{})
	t.Error("Marshal should have panicked")
}

func TestMarshalUncommonFieldNames(t *testing.T) {
	v := struct {
		A0, À, Aβ int
	}{}
	b, err := Marshal(v)
	if err != nil {
		t.Fatal("Marshal error:", err)
	}

		{"s[i:j] is valid and j > len(s)", s, nil, 0, 4},
	} {
		ss, vv := Clone(test.s), Clone(test.v)
		if !panics(func() { _ = Replace(ss, test.i, test.j, vv...) }) {
			t.Errorf("Replace %s: should have panicked", test.name)
		}
	}
}

func TestReplaceGrow(t *testing.T) {
	// When Replace needs to allocate a new slice, we want the original slice
	// to not be changed.
	a, b, c, d, e, f := 1, 2, 3, 4, 5, 6

		if err := isSticky(rc); err != nil {
			t.Errorf("%d. error: %v", i, err)
		}
	}
}

// Issue 45101: maxBytesReader's Read panicked when n < -1. This test
// also ensures that Read treats negative limits as equivalent to 0.
func TestMaxBytesReaderDifferentLimits(t *testing.T) {
	const testStr = "1234"
	tests := [...]struct {
		limit   int64

abi.RF_DONE = 0      // body of loop has exited in a non-panic way
abi.RF_READY = 1     // body of loop has not exited yet, is not running
abi.RF_PANIC = 2     // body of loop is either currently running, or has panicked
abi.RF_EXHAUSTED = 3 // iterator function call, e.g. f(func(x t){...}), returned so the sequence is "exhausted".

abi.RF_MISSING_PANIC = 4 // used to report errors.

The value of #stateK transitions