if !z.wroteHeader {
		z.err = z.writeHeader()
	}
	if z.err != nil {
		return z.err
	}
	z.err = z.compressor.Close()
	if z.err != nil {
		return z.err
	}
	checksum := z.digest.Sum32()
	// ZLIB (RFC 1950) is big-endian, unlike GZIP (RFC 1952).
	binary.BigEndian.PutUint32(z.scratch[:], checksum)
	_, z.err = z.w.Write(z.scratch[0:4])
	return z.err

	typ := &b.Func.Config.Types
	// match: (Lsh64x32 x s)
	// result: (Int64Make (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Hi x) s) (Rsh32Ux32 <typ.UInt32> (Int64Lo x) (Sub32 <typ.UInt32> (Const32 <typ.UInt32> [32]) s))) (Lsh32x32 <typ.UInt32> (Int64Lo x) (Sub32 <typ.UInt32> s (Const32 <typ.UInt32> [32])))) (Lsh32x32 <typ.UInt32> (Int64Lo x) s))
	for {
		x := v_0
		s := v_1
		v.reset(OpInt64Make)

        path = Path.path(':sub')

        then:
        path.relativePath(':') == ':'
        path.relativePath(':sub') == ':sub'
        path.relativePath(':sub:path') == 'path'
        path.relativePath(':sub2:path') == ':sub2:path'
        path.relativePath(':other:path') == ':other:path'
    }

    def 'converts relative path to relative path'() {
        def path = path(':')

        expect:

		wg.Add(1)
		go func() {
			notHelperCallingHelper(t, "parallel")
			wg.Done()
		}()
	}
	wg.Wait()
}

func helperSubCallingHelper(t *testing.T, msg string) {
	t.Helper()
	t.Run("sub2", func(t *testing.T) {
		t.Helper()
		t.Fatal(msg)
	})
}

func recoverHelper(t *testing.T, msg string) {
	t.Helper()
	defer func() {
		t.Helper()
		if err := recover(); err != nil {

			err = io.ErrUnexpectedEOF
		}
		z.err = err
		return n, z.err
	}
	// ZLIB (RFC 1950) is big-endian, unlike GZIP (RFC 1952).
	checksum := binary.BigEndian.Uint32(z.scratch[:4])
	if checksum != z.digest.Sum32() {
		z.err = ErrChecksum
		return n, z.err
	}
	return n, io.EOF
}

// Calling Close does not close the wrapped [io.Reader] originally passed to [NewReader].

			}
			sub1 := h.WithAttrs([]Attr{Bool("sub1", true)})
			sub2 := h.WithAttrs([]Attr{Bool("sub2", true)})
			var wg sync.WaitGroup
			for i := 0; i < count; i++ {
				sub1Record := NewRecord(time.Time{}, LevelInfo, "hello from sub1", 0)
				sub1Record.AddAttrs(Int("i", i))
				sub2Record := NewRecord(time.Time{}, LevelInfo, "hello from sub2", 0)
				sub2Record.AddAttrs(Int("i", i))
				wg.Add(1)
				go func() {

// CHECK: %[[CLIPBYVALUE_2:.*]] = "tf.ClipByValue"
// CHECK-SAME: (tensor<1x96x96x1xi32>, tensor<i32>, tensor<i32>) -> tensor<1x96x96x1xi32>
// CHECK: %[[SUB_2:.*]] = "tf.Sub"(%[[CLIPBYVALUE_2]], {{.*}}) : (tensor<1x96x96x1xi32>, tensor<i32>) -> tensor<1x96x96x1xi32>
}

func.func @consecutive_add_add(%arg0: tensor<i32>) -> (tensor<i32>) {

     -

BUILD SUCCESSFUL"""
    }

    def "listsCommonDynamicAvailableValues"() {
        createDirs("sub1", "sub2")
        when:
        run "help", "--task", "hello"
        then:
        output.contains """Detailed task information for hello

Paths
     :sub1:hello
     :sub2:hello

Type
     CustomTask (CustomTask)

Options
     --stringValue     Configures a string value in CustomTask.

pkg math/bits, func Mul32(uint32, uint32) (uint32, uint32)
pkg math/bits, func Mul64(uint64, uint64) (uint64, uint64)
pkg math/bits, func Sub(uint, uint, uint) (uint, uint)
pkg math/bits, func Sub32(uint32, uint32, uint32) (uint32, uint32)
pkg math/bits, func Sub64(uint64, uint64, uint64) (uint64, uint64)
pkg net/http, const StatusTooEarly = 425
pkg net/http, const StatusTooEarly ideal-int

	{name: "Add64F", argLength: 2, commutative: true},

	{name: "Sub8", argLength: 2}, // arg0 - arg1
	{name: "Sub16", argLength: 2},
	{name: "Sub32", argLength: 2},
	{name: "Sub64", argLength: 2},
	{name: "SubPtr", argLength: 2},
	{name: "Sub32F", argLength: 2},
	{name: "Sub64F", argLength: 2},

	{name: "Mul8", argLength: 2, commutative: true}, // arg0 * arg1
	{name: "Mul16", argLength: 2, commutative: true},