type BoolFlag bool

// String - returns string of BoolFlag.
func (bf BoolFlag) String() string {
	if bf {
		return "on"
	}

	return "off"
}

// MarshalJSON - converts BoolFlag into JSON data.
func (bf BoolFlag) MarshalJSON() ([]byte, error) {
	return json.Marshal(bf.String())
}

// UnmarshalJSON - parses given data into BoolFlag.
func (bf *BoolFlag) UnmarshalJSON(data []byte) (err error) {
	var s string

	"inlines/b"
)

func sum(s []*int) int {
	sum := 0
	for _, pi := range s {
		sum += *pi
	}
	return sum
}

func main() {
	af := a.F()
	bf, _ := b.F()
	abf := a.Fb()

	saf, sbf, sabf := sum(af), sum(bf), sum(abf)

	fmt.Printf("af, bf, abf sums = %d, %d, %d\n", saf, sbf, sabf)

	bf := bufio.NewReader(r)
	switch f := detect(bf); f {
	case formatGzip:
		gz, err := gzip.NewReader(bf)
		if err != nil {
			return err
		}
		defer gz.Close()
		r = gz
	case formatS2:
		r = s2.NewReader(bf)
	case formatZstd:
		// Limit to 16 MiB per stream.
		dec, err := zstd.NewReader(bf, zstd.WithDecoderMaxWindow(16<<20))
		if err != nil {

    assertEscaping(e, "%DF%BF", '\u07ff'); // xx-11111,x-111111
    assertEscaping(e, "%E0%A0%80", '\u0800'); // xxx-0000,x-100000,x-00,0000
    assertEscaping(e, "%EF%BF%BF", '\uffff'); // xxx-1111,x-111111,x-11,1111
    assertUnicodeEscaping(e, "%F0%90%80%80", '\uD800', '\uDC00');
    assertUnicodeEscaping(e, "%F4%8F%BF%BF", '\uDBFF', '\uDFFF');

    // simple string tests

00000150  4c 99 35 1d ba 31 01 0c  48 d2 f2 88 22 9c 91 7d  |L.5..1..H..."..}|
00000160  e3 74 f9 b3 52 bf 0e 0b  e1 31 7c 2c cb fd f2 8c  |.t..R....1|,....|
00000170  bf 27 40 6d 26 b7 62 47  56 91 22 00 67 9a df 4f  |.'@m&.bGV.".g..O|
00000180  f0 47 57 3c a6 46 4d 16  f6 8d fc 2d 91 c4 1a bf  |.GW<.FM....-....|
00000190  38 63 ec 63 fe 97 14 80  aa 5b 60 ff c8 77 57 9c  |8c.c.....[`..wW.|

	newLevels().
		// Level 1: bf=5(sync)
		Add(5, false).
		// Level 2: bf=2(sync)
		Add(2, false).
		// Level 3: bf=2(sync)
		Add(2, false).
		Build().
		Run(t)
}

func TestParallel(t *testing.T) {
	// Root is always run sync.
	newLevels().
		// Level 1: bf=20(parallel)
		Add(20, true).
		// Level 2: bf=5(parallel)
		Add(5, true).
		// Level 3: bf=2(parallel)
		Add(2, true).
		Build().

}

func parseGoroutineType2(path string) (map[time.Duration][]string, error) {
	f, err := os.Open(path)
	if err != nil {
		return nil, err
	}

	bf := bytes.Buffer{}

	save := func(s string) {
		bf.WriteString(s + "\n")
	}
	reset := func() {
		bf.Reset()
	}

	ret := make(map[time.Duration][]string)

	s := bufio.NewScanner(f)
	s.Split(bufio.ScanLines)

	var (
		t            time.Duration

000002e0  20 53 87 e6 77 26 be 45  e4 6d 31 e3 bf 02 42 01  | S..w&.E.m1...B.|
000002f0  70 c5 97 3a e4 7b 80 2b  1b eb c9 b2 0a 79 92 2e  |p..:.{.+.....y..|
00000300  3d b1 4d 13 69 d2 60 a9  fd e9 66 56 83 e4 f5 6a  |=.M.i.`...fV...j|
00000310  ae cd 8b 94 9f 0b 70 81  b1 ed c6 0d 5f 33 42 04  |......p....._3B.|
00000320  3d f7 b6 d3 e9 09 b8 bf  43 8c 19 d5 7d 60 d6 a9  |=.......C...}`..|

		log.Fatalf(`plugin.Open("iface_b.so"): %v`, err)
	}

	af, err := a.Lookup("F")
	if err != nil {
		log.Fatalf(`a.Lookup("F") failed: %v`, err)
	}
	bf, err := b.Lookup("F")
	if err != nil {
		log.Fatalf(`b.Lookup("F") failed: %v`, err)
	}
	if af.(func() interface{})() != bf.(func() interface{})() {
		panic("empty interfaces not equal")
	}

	ag, err := a.Lookup("G")
	if err != nil {

000001e0  d7 c9 6e d9 f6 7b de fa  f0 12 5d fc c0 71 1a bf  |..n..{....]..q..|
000001f0  76 d8 c4 ad c5 f7 e2 79  55 79 40 e5 55 ee bc dc  |v......yUy@.U...|
00000200  42 06 97 89 da 2d a7 e9  26 e4 82 e1 63 5f e2 ee  |B....-..&...c_..|
00000210  1a 37 6d 65 bf d7 5f 2e  86 a5 a8 4d b2 e1 31 2f  |.7me.._....M..1/|
00000220  8b c5 0b 88 03 bf 1f 37  8c 96 ec 54 4f 75 9b f9  |.......7...TOu..|