bool isLegalToInline(Operation *call, Operation *callable,
                       bool wouldBeCloned) const final {
    // Skip inlining for TPUPartitionedCalls and RemoteCalls.
    if (isa<TPUPartitionedCallOp>(call)) return false;
    if (isa<RemoteCallOp>(call)) return false;
    // Maintain inlining for  `tf.function`s with jit_compile option.
    if (callable->hasAttr("tf._XlaMustCompile")) return true;

	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
}

func G() {
	F() // ERROR "inlining call to F"
	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

// lies between two functions.

package main

import (
	"runtime"
)

func main() {
	var stack [1]uintptr
	runtime.Callers(1, stack[:])
	f() // inlined function, to give main some inlining info
	for i := uintptr(0); true; i++ {
		f := runtime.FuncForPC(stack[0] + i)
		if f.Name() != "main.main" && f.Name() != "main.f" {
			// Reached next function successfully.
			break
		}
	}
}

func f() {

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

package inlheur

// This file defines a set of Go function "properties" intended to
// guide inlining heuristics; these properties may apply to the
// function as a whole, or to one or more function return values or
// parameters.
//
// IMPORTANT: function properties are produced on a "best effort"

	// Dummy implementation for non-debug build.
	// A non-empty implementation would be enabled with a build tag.
}

func bar() { // ERROR "can inline bar"
	value := 10
	debugf("value is %d", value) // ERROR "inlining call to debugf" "value does not escape" "\.\.\. argument does not escape"

// errorcheck -0 -m

//go:build amd64

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

// Test that inlining of math/bits.RotateLeft* treats those calls as intrinsics.

package p

import "math/bits"

var (
	x8  uint8
	x16 uint16
	x32 uint32
	x64 uint64
	x   uint
)

func f() { // ERROR "can inline f"

	return int32(f)
}

// pcinlineState holds the state used to create a function's inlining
// tree and the PC-value table that maps PCs to nodes in that tree.
type pcinlineState struct {
	globalToLocal map[int]int
	localTree     InlTree
}

// addBranch adds a branch from the global inlining tree in ctxt to
// the function's local inlining tree, returning the index in the local tree.

}

func inlinable2(x int) int {
	return noninl(-x)
}

//go:noinline
func noninl(x int) int {
	return x + 1
}

func tooLargeToInline(x int) int {
	if x > 101 {
		// Drive up the cost of inlining this func over the
		// regular threshold.
		return big(big(big(big(big(G + x)))))
	}
	if x < 100 {
		// make sure this callsite is scored properly
		G += inlinable(101, inlinable2)
		if G == 101 {
			return 0

// run

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

// Issue 4167: inlining of a (*T).Method expression taking
// its arguments from a multiple return breaks the compiler.

package main

type pa []int

type p int

func (this *pa) func1() (v *p, c int) {
	for _ = range *this {
		c++
	}
	v = (*p)(&c)
	return

// As of 2019-06, bug affects/ed amd64 and s390x.

package main

var foo = []byte{105, 57, 172, 152}

func main() {
	for i := 0; i < len(foo); i += 4 {
		// Requires inlining and non-constant i
		// Note the bug/fix also apply to different widths, but was unable to reproduce for those.
		println(readLittleEndian32_2(foo[i], foo[i+1], foo[i+2], foo[i+3]))
	}
}