expected[i] = 5300224;
    }
    // 97-111 are all 2342912
    for (int i = 97; i <= 111; i++) {
      expected[i] = 2342912;
    }
    // 113-117 are all 1048576
    for (int i = 113; i <= 117; i++) {
      expected[i] = 1048576;
    }
    // One offs
    expected[112] = 786432;
    expected[118] = 786432;
    expected[119] = 1048576;
    expected[120] = 458752;
    expected[121] = 524288;

	}

	testenv.MustHaveGoBuild(t)
	testenv.MustHaveCGO(t)
	t.Parallel()
	dir := t.TempDir()

	// NB: the use of -ldflags=-debugtextsize=1048576 tells the linker to
	// split text sections at a size threshold of 1M instead of the
	// architected limit of 67M or larger. The choice of building cmd/go
	// is arbitrary; we just need something sufficiently large that uses

		},
		{
			fs: &v1.ResourceFieldSelector{
				Resource: "requests.memory",
			},
			cName:         "foo",
			pod:           getPod("foo", podResources{memoryRequest: "100Mi"}),
			expectedValue: "104857600",
		},
		{
			fs: &v1.ResourceFieldSelector{
				Resource: "requests.memory",
				Divisor:  resource.MustParse("1Mi"),
			},
			cName:         "foo",

	// FSQuotaEnforcing for quotas for enforcement
	FSQuotaEnforcing QuotaType = 1 << iota
)

// FirstQuota is the quota ID we start with.
// XXXXXXX Need a better way of doing this...
var FirstQuota QuotaID = 1048577

// MountsFile is the location of the system mount data
var MountsFile = "/proc/self/mounts"

// MountParseRegexp parses out /proc/sys/self/mounts

					Typeflag:	'0',
					Uname:		"dsymonds",
					Gname:		"eng",
				},
				contents:	"Google.com\n",
			},
		},
	},
	// The truncated test file was produced using these commands:
	//   dd if=/dev/zero bs=1048576 count=16384 > /tmp/16gig.txt
	//   tar -b 1 -c -f- /tmp/16gig.txt | dd bs=512 count=8 > writer-big.tar
	&writerTest{
		file:	"testdata/writer-big.tar",
		entries: []*writerTestEntry{
			&writerTestEntry{

	if err != nil {
		t.Fatalf("can't create temp directory: %v\n", err)
	}
	defer os.RemoveAll(tmpdir)

	// Emit testcase.
	var w bytes.Buffer
	fmt.Fprintf(&w, issue41621prolog)
	for i := 0; i < 1048576+13; i++ {
		fmt.Fprintf(&w, "\t\"%d\",\n", i)
	}
	fmt.Fprintf(&w, issue41621epilog)
	err = os.WriteFile(tmpdir+"/large.go", w.Bytes(), 0666)
	if err != nil {
		t.Fatalf("can't write output: %v\n", err)
	}

	ADD	$0x000fffff, R0, R1 // ADD $1048575, R0, R1    // 011680e2011041e2
	ADC	$0x000fffff, R0, R1 // ADC $1048575, R0, R1    // 0116a0e2011041e2
	SUB	$0x000fffff, R0, R1 // SUB $1048575, R0, R1    // 011640e2011081e2
	SBC	$0x000fffff, R0, R1 // SBC $1048575, R0, R1    // 0116c0e2011081e2
	RSB	$0x000fffff, R0, R1 // RSB $1048575, R0, R1    // 011660e2011041e2
	RSC	$0x000fffff, R0, R1 // RSC $1048575, R0, R1    // 0116e0e2011041e2

		},
		{
			Name:        "stringArray",
			InputSchema: arraySchema("string", "", nil),
			// expected JSON is ["","",...] so our length should be (maxRequestSizeBytes - 2) / 3
			ExpectedMaxElements: 1048575,
		},
		{
			Name: "stringMap",
			InputSchema: &schema.Structural{
				Generic: schema.Generic{
					Type: "object",
				},

		},
		{
			Name:        "stringArray",
			InputSchema: arraySchema("string", "", nil),
			// expected JSON is ["","",...] so our length should be (maxRequestSizeBytes - 2) / 3
			ExpectedMaxElements: 1048575,
		},
		{
			Name: "stringMap",
			InputSchema: &spec.Schema{
				SchemaProps: spec.SchemaProps{
					Type: []string{"object"},
					AdditionalProperties: &spec.SchemaOrBool{
						Schema: &spec.Schema{

			s.Sources[src].Places = append(s.Sources[src].Places, StackSlot{i, j})
		}
	}
}

func (s *StackSet) assignColors() {
	// Assign different color indices to different packages.
	const numColors = 1048576
	for i, src := range s.Sources {
		pkg := packageName(src.FullName)
		h := sha256.Sum256([]byte(pkg))
		index := binary.LittleEndian.Uint32(h[:])
		s.Sources[i].Color = int(index % numColors)
	}