object = strings.Replace(object, "ClaimInfoStateListWithoutResourceHandles", "ClaimInfoStateList", 1)
	hash := fnv.New32a()
	fmt.Fprintf(hash, "%v", object)
	if checkSum != checksum.Checksum(hash.Sum32()) {
		return errors.ErrCorruptCheckpoint
	}
	return nil

    helperfuncs_test.go:56: 4
    --- FAIL: TestTBHelper/sub \([^)]+\)
        helperfuncs_test.go:59: 5
        helperfuncs_test.go:24: 6
        helperfuncs_test.go:58: 7
    --- FAIL: TestTBHelper/sub2 \([^)]+\)
        helperfuncs_test.go:80: 11
    helperfuncs_test.go:84: recover 12
    helperfuncs_test.go:86: GenericFloat64
    helperfuncs_test.go:87: GenericInt
    helper_test.go:22: 8
    helperfuncs_test.go:73: 9

	// initialization in this case.
	d.crc = update(d.crc, d.tab, p, false)
	return len(p), nil
}

func (d *digest) Sum32() uint32 { return d.crc }

func (d *digest) Sum(in []byte) []byte {
	s := d.Sum32()
	return append(in, byte(s>>24), byte(s>>16), byte(s>>8), byte(s))
}

// Checksum returns the CRC-32 checksum of data
// using the polynomial represented by the [Table].

		s1 %= mod
		s2 %= mod
		p = q
	}
	return digest(s2<<16 | s1)
}

func (d *digest) Write(p []byte) (nn int, err error) {
	*d = update(*d, p)
	return len(p), nil
}

func (d *digest) Sum32() uint32 { return uint32(*d) }

func (d *digest) Sum(in []byte) []byte {
	s := uint32(*d)
	return append(in, byte(s>>24), byte(s>>16), byte(s>>8), byte(s))
}

// Checksum returns the Adler-32 checksum of data.

        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 {

	object = strings.Replace(object, "CPUManagerCheckpointV1", "CPUManagerCheckpoint", 1)
	cp.Checksum = ck

	hash := fnv.New32a()
	fmt.Fprintf(hash, "%v", object)
	if cp.Checksum != checksum.Checksum(hash.Sum32()) {
		return errors.ErrCorruptCheckpoint
	}

	return nil
}

// VerifyChecksum verifies that current checksum of checkpoint is valid in v2 format
func (cp *CPUManagerCheckpointV2) VerifyChecksum() error {

	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

			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].

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