core.ResourceCPU: resource.MustParse(cpuOverhead),
					},
				},
				Scheduling: &node.Scheduling{
					NodeSelector: map[string]string{"extra-soft": "true"},
					Tolerations: []core.Toleration{{
						Key:      "stinky",
						Operator: core.TolerationOpExists,
						Effect:   core.TaintEffectNoSchedule,
					}},
				},
			},
			external: &v1alpha1.RuntimeClass{
				ObjectMeta: metav1.ObjectMeta{Name: name},

	})

	shouldPanic(func() {
		var a [3]int
		sinkS = a /*line :999999:1*/ [ /*line :1100:1*/ i:]
	})
	shouldPanic(func() {
		var a []int
		sinkS = a /*line :999999:1*/ [ /*line :1200:1*/ i:]
	})
	shouldPanic(func() {
		var a [3]int
		sinkS = a /*line :999999:1*/ [: /*line :1300:1*/ i]
	})
	shouldPanic(func() {
		var a []int
		sinkS = a /*line :999999:1*/ [: /*line :1400:1*/ i]
	})

		z = &t.x[i]
		*z = 2
	}
}

// Issue 15730: copy causes unnecessary escape

var sink []byte
var sink2 []int
var sink3 []*int

func f15730a(args ...interface{}) { // ERROR "args does not escape"
	for _, arg := range args {
		switch a := arg.(type) {
		case string:
			copy(sink, a)
		}
	}
}

func f15730b(args ...interface{}) { // ERROR "args does not escape"

 * A test factory for byte or char sources or sinks. In addition to creating sources or sinks, the
 * factory specifies what content should be expected to be read from a source or contained in a sink
 * given the content data that was used to create the source or that was written to the sink.
 *
 * <p>A single {@code SourceSinkFactory} implementation generally corresponds to one specific way of

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

//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || netbsd || openbsd || solaris || wasip1

package os

// According to sticky(8), neither open(2) nor mkdir(2) will create
// a file with the sticky bit set.

// Copyright 2019 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 main

import "C"

var sink []byte

//export GoFunction7
func GoFunction7() {
	sink = make([]byte, 4096)
}

func main() {

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

package main

var ncall int;

type Iffy interface {
	Me() Iffy
}

type Stucky struct {
	n int
}

func (s *Stucky) Me() Iffy {
	ncall++;
	return s
}

func main() {
	s := new(Stucky);
	i := s.Me();
	j := i.Me();
	j.Me();
	if ncall != 3 {
		panic("bug111")
	}

	testMultiWriter(t, struct {
		Writer
		fmt.Stringer
	}{sink, sink})
}

func TestMultiWriter_String(t *testing.T) {
	testMultiWriter(t, new(bytes.Buffer))
}

// Test that a multiWriter.WriteString calls results in at most 1 allocation,
// even if multiple targets don't support WriteString.
func TestMultiWriter_WriteStringSingleAlloc(t *testing.T) {
	var sink1, sink2 bytes.Buffer

	p := new([4]int64)
	sink2 = unsafe.Slice(&p[1], 3)
}

func CheckPtrSliceFail() {
	p := new(int64)
	sink2 = p
	sink2 = unsafe.Slice(p, 100)
}

func CheckPtrStringOK() {
	p := new([4]byte)
	sink2 = unsafe.String(&p[1], 3)
}

func CheckPtrStringFail() {
	p := new(byte)
	sink2 = p
	sink2 = unsafe.String(p, 100)
}

func CheckPtrAlignmentNested() {
	s := make([]int8, 100)

    .sidebar {
        font-size: 100%
    }
}

@supports (position: -webkit-sticky) or (position: sticky) {
    .sidebar {
        position: -webkit-sticky;
        position: sticky;
        top: 3.7rem;
        z-index: 1000
    }
}

@supports (position: -webkit-sticky) or (position: sticky) {
    .sidebar .directory {
        max-height: calc(100vh - 9rem)
    }
}