a = 42
	go func() {
		_ = a
		c <- 1
	}()
	return a, 10
}

func issue5431() {
	var p **inltype
	if inlinetest(p).x && inlinetest(p).y {
	} else if inlinetest(p).x || inlinetest(p).y {
	}
}

type inltype struct {
	x, y bool
}

func inlinetest(p **inltype) *inltype {
	return *p
}

type iface interface {
	Foo() *struct{ b bool }
}

type Int int

#include "pclinetest.h"
BYTE $2;
#include "pclinetest.h"
BYTE $2;
BYTE $255;

TEXT ·pcfromline(SB),4,$0	// Each record stores its line delta, then n, then n more bytes
BYTE $32; BYTE $0;
BYTE $1; BYTE $1; BYTE $0;
BYTE $1; BYTE $0;

BYTE $2; BYTE $4; BYTE $0; BYTE $0; BYTE $0; BYTE $0;


#include "pclinetest.h"
BYTE $4; BYTE $0;

Austin Clements <******@****.***> 1541097261 -0400

		t.Skipf("skipping in short mode on non-Linux system %s", runtime.GOARCH)
	}
	var err error
	pclineTempDir, err = os.MkdirTemp("", "pclinetest")
	if err != nil {
		t.Fatal(err)
	}
	pclinetestBinary = filepath.Join(pclineTempDir, "pclinetest")
	cmd := exec.Command(testenv.GoToolPath(t), "build", "-o", pclinetestBinary)
	cmd.Dir = "testdata"
	cmd.Env = append(os.Environ(), "GOOS=linux")
	cmd.Stdout = os.Stdout

func blocksText(bs []md.Block) string {
	var d strings.Builder
	for _, b := range bs {
		io.WriteString(&d, text(b))
		fmt.Fprintln(&d)
	}
	return d.String()
}

// inlineText returns all the next in a slice of inline nodes.
func inlineText(ins []md.Inline) string {
	var buf bytes.Buffer
	for _, in := range ins {
		in.PrintText(&buf)
	}
	return buf.String()
}

	// (3) List separators in content values as in inline-lists:
	//    <style>
	//    ul.inlineList { list-style: none; padding:0 }
	//    ul.inlineList > li { display: inline }
	//    ul.inlineList > li:before { content: ", " }
	//    ul.inlineList > li:first-child:before { content: "" }
	//    </style>
	//    <ul class=inlineList><li>One<li>Two<li>Three</ul>
	// (4) Attribute value selectors as in a[href="http://example.com/"]
	//

			}
		}

		bigCaller := base.Flag.LowerL != 0 && inline.IsBigFunc(fn)
		if bigCaller && base.Flag.LowerM > 1 {
			fmt.Printf("%v: function %v considered 'big'; reducing max cost of inlinees\n", ir.Line(fn), fn)
		}

		match := func(n ir.Node) bool {
			switch n := n.(type) {
			case *ir.CallExpr:
				return true
			case *ir.TailCallStmt:
				n.Call.NoInline = true // can't inline yet
			}