// ResultFlags
//   0 ResultIsAllocatedMem
// <endpropsdump>
// {"Flags":0,"ParamFlags":null,"ResultFlags":[2]}
// callsite: acrosscall.go:123:19|0 flagstr "" flagval 0 score 2 mask 0 maskstr ""
// <endcallsites>
// <endfuncpreamble>
func T_acrosscall_returnsmem() *int {
	return returnsmem()
}

// acrosscall.go T_acrosscall_returnscci 134 0 1
// ResultFlags
//   0 ResultIsConcreteTypeConvertedToInterface

// Flags FuncPropNeverReturns
// <endpropsdump>
// {"Flags":1,"ParamFlags":null,"ResultFlags":null}
// <endcallsites>
// <endfuncpreamble>
func T_simple() {
	panic("bad")
}

// funcflags.go T_nested 32 0 1
// Flags FuncPropNeverReturns
// ParamFlags
//   0 ParamFeedsIfOrSwitch
// <endpropsdump>
// {"Flags":1,"ParamFlags":[32],"ResultFlags":null}
// <endcallsites>
// <endfuncpreamble>
func T_nested(x int) {

// callsite: returns2.go:77:14|0 flagstr "" flagval 0 score 10 mask 2048 maskstr "returnFeedsConstToIfAdj"
// <endcallsites>
// <endfuncpreamble>
func T_return_feeds_ifswitch(q int) int {
	x := meaning(q)
	if x < 42 {
		switch x {
		case 42:
			return 1
		}
	}
	return 0
}

// returns2.go T_multi_return_feeds_ifswitch 93 0 1
// <endpropsdump>
// {"Flags":0,"ParamFlags":[0],"ResultFlags":[0]}

// <endpropsdump>
// {"Flags":0,"ParamFlags":[0],"ResultFlags":null}
// callsite: calls.go:21:15|0 flagstr "CallSiteOnPanicPath" flagval 2 score 42 mask 1 maskstr "panicPathAdj"
// <endcallsites>
// <endfuncpreamble>
func T_call_in_panic_arg(x int) {
	if x < G {
		panic(callee(x))
	}
}

// calls.go T_calls_in_loops 32 0 1
// <endpropsdump>
// {"Flags":0,"ParamFlags":[0,0],"ResultFlags":null}

	for i := range funcProps.ParamFlags {
		v, sl = readULEB128(sl)
		funcProps.ParamFlags[i] = ParamPropBits(v)
	}
	v, sl = readULEB128(sl)
	funcProps.ResultFlags = make([]ResultPropBits, v)
	for i := range funcProps.ResultFlags {
		v, sl = readULEB128(sl)
		funcProps.ResultFlags[i] = ResultPropBits(v)
	}
	return &funcProps
}

func readULEB128(sl []byte) (value uint64, rsl []byte) {
	var shift uint

	for {
		b := sl[0]

	if fp.Flags != 0 {
		fmt.Fprintf(&sb, "%sFlags %s\n", prefix, fp.Flags)
	}
	flagSliceToSB[ParamPropBits](&sb, fp.ParamFlags,
		prefix, "ParamFlags")
	flagSliceToSB[ResultPropBits](&sb, fp.ResultFlags,
		prefix, "ResultFlags")
	return sb.String()
}

func flagSliceToSB[T interface {
	~uint32
	String() string
}](sb *strings.Builder, sl []T, prefix string, tag string) {
	var sb2 strings.Builder
	foundnz := false

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

package p

type resultFlags uint

// Example from #52031.
//
// The following shifts should not produce errors on Go < 1.13, as their
// untyped constant operands are representable by type uint.
const (
	_ resultFlags = (1 << iota) / 2

	reportEqual
	reportUnequal
	reportByIgnore
	reportByMethod
	reportByFunc

// be useful for inlining heuristics. Here 'Flags' are properties that
// we think apply to the entire function; 'RecvrParamFlags' are
// properties of specific function params (or the receiver), and
// 'ResultFlags' are things properties we think will apply to values
// of specific results. Note that 'ParamFlags' includes and entry for
// the receiver if applicable, and does include etries for blank

		t.Errorf("testcase %q: Flags mismatch for %q: got %s, wanted %s",
			tc, dfn, dfp.Flags.String(), efp.Flags.String())
	}
	// Compare returns
	rgot := propBitsToString[ResultPropBits](dfp.ResultFlags)
	rwant := propBitsToString[ResultPropBits](efp.ResultFlags)
	if rgot != rwant {
		t.Errorf("testcase %q: Results mismatch for %q: got:\n%swant:\n%s",
			tc, dfn, rgot, rwant)
	}
	// Compare receiver + params.

	for _, pf := range props.ParamFlags {
		if adj, ok := paramFlagToPositiveAdj[pf]; ok {
			score, tmask = adjustScore(adj, score, tmask)
		}
	}
	for _, rf := range props.ResultFlags {
		if adj, ok := resultFlagToPositiveAdj[rf]; ok {
			score, tmask = adjustScore(adj, score, tmask)
		}
	}

	if debugTrace&debugTraceScoring != 0 {
		fmt.Fprintf(os.Stderr, "=-= largestScore(%v) is %d\n",