input:        []int{1, 2, 3},
			replace:      []int{10, 2, 3},
			insertBefore: []int{10, 1, 2, 3},
			insertAfter:  []int{1, 10, 2, 3},
			applied:      true,
		},
		{
			name:         "the middle",
			input:        []int{0, 1, 2, 3},
			replace:      []int{0, 10, 2, 3},
			insertBefore: []int{0, 10, 1, 2, 3},
			insertAfter:  []int{0, 1, 10, 2, 3},
			applied:      true,
		},
		{

	testenv.MustHaveGoBuild(t)

	// Start with a "self test" to make sure that if we *don't* pass in a
	// terminal, the test can correctly detect that. (cmd/go doesn't guarantee
	// that it won't add a terminal in the middle, but that would be pretty weird.)
	t.Run("pipe", func(t *testing.T) {
		r, w, err := os.Pipe()
		if err != nil {
			t.Fatalf("pipe failed: %s", err)
		}
		defer r.Close()
		defer w.Close()

}

// WriteStringN writes the first n bytes of s.
// If n is larger than len(s) then it is padded with zero bytes.
func (out *OutBuf) WriteStringN(s string, n int) {
	out.WriteStringPad(s, n, zeros[:])
}

// WriteStringPad writes the first n bytes of s.
// If n is larger than len(s) then it is padded with the bytes in pad (repeated as needed).
func (out *OutBuf) WriteStringPad(s string, n int, pad []byte) {

	case v1.PodQOSGuaranteed:
		// Guaranteed containers should be the last to get killed.
		return guaranteedOOMScoreAdj
	case v1.PodQOSBestEffort:
		return besteffortOOMScoreAdj
	}

	// Burstable containers are a middle tier, between Guaranteed and Best-Effort. Ideally,
	// we want to protect Burstable containers that consume less memory than requested.
	// The formula below is a heuristic. A container requesting for 10% of a system's

     * A value of -1 indicates that no character is in the buffer.
     */
    private int[] readAheadChars = new int[2];

    /**
     * Whether or not the parser is currently in the middle of a string literal.
     */
    private boolean inString;

    /**
     * Whether or not the last char has been a backslash.
     */
    private boolean quoted;

package p

... `, false},
		// Special comment has rogue interior space.
		{`//     Code generated by gen. DO NOT EDIT.
package p
`, false},
		// Special comment lacks the middle portion.
		{`// Code generated DO NOT EDIT.
package p
`, false},
		// Special comment (incl. "//") appears within a /* block */ comment,
		// an obscure corner case of the spec.
		{`/* start of a general comment

// to "rate" bytes of the input are XORed into the sponge's state. The sponge
// is then "full" and the permutation is applied to "empty" it. This process is
// repeated until all the input has been "absorbed". The input is then padded.
// The digest is "squeezed" from the sponge in the same way, except that output
// is copied out instead of input being XORed in.
//
// A sponge is parameterized by its generic security strength, which is equal

So, you should be able to pin to a version like:

```txt
fastapi>=0.45.0,<0.46.0
```

Breaking changes and new features are added in "MINOR" versions.

!!! tip
    The "MINOR" is the number in the middle, for example, in `0.2.3`, the MINOR version is `2`.

## Upgrading the FastAPI versions

You should add tests for your app.

import (
	"unsafe"
)

// The Data struct size is expected to be rounded up to 16 bytes.
type Data struct {
	Value  uint32   // 4 bytes
	Label  [10]byte // 10 bytes
	Active bool     // 1 byte
	// padded with 1 byte to make it align
}

func main() {
	assert(unsafe.Sizeof(Data{}) == 16)
}
`,
	},
}

func TestGCSizes(t *testing.T) {
	types2.DefPredeclaredTestFuncs()

// Replaces aten.avg_pool2d with ceil mode with (T -> tfl.pad -> tfl.average_pool_2d -> mul -> T). Multiplies by a constant
// which corrects the overcounting of divisors that would occur if doing this computation on a padded tensor with ceil mode off.
def LegalizeAvgPoolCeilModeTrue: Pat<
                    (MHLO_CompositeOp:$old_val
                    (variadic $a_input),