// ParamFlags
//   0 ParamFeedsIfOrSwitch
// <endpropsdump>
// {"Flags":0,"ParamFlags":[32],"ResultFlags":null}
// callsite: acrosscall.go:58:9|0 flagstr "" flagval 0 score 8 mask 0 maskstr ""
// <endcallsites>
// <endfuncpreamble>
func T_feeds_if_via_call(x int) {
	feedsif(x)
}

// acrosscall.go T_feeds_if_via_call_conditional 69 0 1
// ParamFlags
//   0 ParamMayFeedIfOrSwitch
// <endpropsdump>

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

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

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

	var funcProps FuncProps
	var v uint64
	sl := []byte(s)
	v, sl = readULEB128(sl)
	funcProps.Flags = FuncPropBits(v)
	v, sl = readULEB128(sl)
	funcProps.ParamFlags = make([]ParamPropBits, v)
	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 {

}

func (fp *FuncProps) ToString(prefix string) string {
	var sb strings.Builder
	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

// of specific results. Note that 'ParamFlags' includes and entry for
// the receiver if applicable, and does include etries for blank
// params; for a function such as "func foo(_ int, b byte, _ float32)"
// the length of ParamFlags will be 3.
type FuncProps struct {
	Flags       FuncPropBits
	ParamFlags  []ParamPropBits // slot 0 receiver if applicable
	ResultFlags []ResultPropBits
}

		t.Errorf("testcase %q: Results mismatch for %q: got:\n%swant:\n%s",
			tc, dfn, rgot, rwant)
	}
	// Compare receiver + params.
	pgot := propBitsToString[ParamPropBits](dfp.ParamFlags)
	pwant := propBitsToString[ParamPropBits](efp.ParamFlags)
	if pgot != pwant {
		t.Errorf("testcase %q: Params mismatch for %q: got:\n%swant:\n%s",
			tc, dfn, pgot, pwant)
	}
	// Compare call sites.
	for k, ve := range ecsites {

	for idx := range call.Args {
		// ignore blanks
		if calleeRecvrParms[idx].Sym == nil ||
			calleeRecvrParms[idx].Sym.IsBlank() {
			continue
		}
		arg := call.Args[idx]
		pflag := calleeProps.ParamFlags[idx]
		if debugTrace&debugTraceScoring != 0 {
			fmt.Fprintf(os.Stderr, "=-= arg %d of %d: val %v flags=%s\n",
				idx, len(call.Args), arg, pflag.String())
		}

		if len(cs.ArgProps) == 0 {
			continue