Austin Clements <******@****.***> 1515619738 -0500

Emmanuel Odeke <******@****.***> 1460323946 -0700

	s = make([]int, i, 1)  // ERROR "make\(\[\]int, i, 1\) does not escape"
	_ = s
}

func slice12(x []int) *[1]int { // ERROR "leaking param: x to result ~r0 level=0$"
	return (*[1]int)(x)
}

func slice13(x []*int) [1]*int { // ERROR "leaking param: x to result ~r0 level=1$"
	return [1]*int(x)
}

func envForDir(dir string) []string { // ERROR "dir does not escape"
	env := os.Environ()

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

type Recv <-chan int

type sliceOf[E any] interface {
	~[]E
}

func _Append[S sliceOf[T], T any](s S, t ...T) S {
	return append(s, t...)
}

func main() {
	recv := make(Recv)
	a := _Append([]Recv{recv}, recv)
	if len(a) != 2 || a[0] != recv || a[1] != recv {

                                PatternRewriter& rewriter) const override;
};

// Pad slice to 4d.
struct PadSlice : public OpRewritePattern<TFL::SliceOp> {
  using OpRewritePattern<TFL::SliceOp>::OpRewritePattern;

  LogicalResult matchAndRewrite(TFL::SliceOp slice_op,
                                PatternRewriter& rewriter) const override;
};

// Fully connected to conv2d.

// 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.

//go:build !unix

package bio

func (r *Reader) sliceOS(length uint64) ([]byte, bool) {
	return nil, false

var x = reflect.New(reflect.StructOf([]reflect.StructField{
	{Name: "F5", Type: reflect.StructOf([]reflect.StructField{
		{Name: "F4", Type: reflect.ArrayOf(5462,
			reflect.SliceOf(typ(uint64(0))))},
	})},

// backing memory is read-only.
func (r *Reader) Slice(length uint64) ([]byte, bool, error) {
	if length == 0 {
		return []byte{}, false, nil
	}

	data, ok := r.sliceOS(length)
	if ok {
		return data, true, nil
	}

	data = make([]byte, length)
	_, err := io.ReadFull(r, data)
	if err != nil {
		return nil, false, err
	}
	return data, false, nil
}

                mlir::stablehlo::ReshapeOp, mlir::stablehlo::SelectOp,
                mlir::stablehlo::SliceOp, mlir::stablehlo::TransposeOp>(op)) {
    scale_spec->has_same_scale_requirement = true;
  }
  if (llvm::isa<mlir::stablehlo::DynamicSliceOp, mlir::stablehlo::GatherOp,
                mlir::stablehlo::PadOp, mlir::stablehlo::SliceOp>(op)) {
    scale_spec->has_same_operand_and_result_type_requirement = true;
  }
  return scale_spec;

//	OpenBSD   unlimited
var mmapLimit int32 = 1<<31 - 1

func init() {
	// Linux is the only practically concerning OS.
	if runtime.GOOS == "linux" {
		mmapLimit = 30000
	}
}

func (r *Reader) sliceOS(length uint64) ([]byte, bool) {
	// For small slices, don't bother with the overhead of a
	// mapping, especially since we have no way to unmap it.
	const threshold = 16 << 10
	if length < threshold {
		return nil, false