if err != nil {
		metrics.CountManifestRenderError(cf.ComponentName(), metrics.HelmTranslateIOPToValuesError)
		return "", err
	}

	scope.Debugf("Merged values:\n%s\n", mergedYAML)

	my, err := cf.renderer.RenderManifestFiltered(mergedYAML, func(s string) bool {
		return cf.Filter.IsEmpty() || cf.Filter.Contains(s)
	})
	if err != nil {

	cf.StringVar(&testList, "list", "", "")
	cf.StringVar(&testMemProfile, "memprofile", "", "")
	cf.String("memprofilerate", "", "")
	cf.StringVar(&testMutexProfile, "mutexprofile", "", "")
	cf.String("mutexprofilefraction", "", "")
	cf.Var(&testOutputDir, "outputdir", "")
	cf.Int("parallel", 0, "")
	cf.String("run", "", "")
	cf.Bool("short", false, "")
	cf.String("skip", "", "")

// CHECK:   [[PRED:%.+]] = tensor.extract [[TOBOOL]][] : tensor<i1>
// CHECK:   cf.cond_br [[PRED]], ^bb1, ^bb2
// CHECK: ^bb1:
// CHECK:   [[THEN:%.+]] = call @testIf1Then(%arg1, %arg2)
// CHECK:   cf.br ^bb3([[THEN]] : tensor<*xf32>)
// CHECK: ^bb2:
// CHECK:   [[ELSE:%.+]] = call @testIf1Else(%arg1, %arg2)
// CHECK:   cf.br ^bb3([[ELSE]] : tensor<*xf32>)
// CHECK: ^bb3([[BBARG0:%.+]]: tensor<*xf32>):

	for i := range cf.Omitted {
		cf.Omitted[i].Path = filepath.Join(dir, cf.Omitted[i].Path)
	}
	for i := range cf.Invalid {
		cf.Invalid[i].Path = filepath.Join(dir, cf.Invalid[i].Path)
	}
	return cf, cf.Err()
}

// CheckZip reports whether the files contained in a zip file satisfy the name
// and size constraints listed in the package documentation.
//

00000210  30 33 cf 04 16 03 03 00  04 0e 00 00 00           |03...........|
>>> Flow 3 (client to server)
00000000  16 03 03 00 25 10 00 00  21 20 2f e5 7d a3 47 cd  |....%...! /.}.G.|
00000010  62 43 15 28 da ac 5f bb  29 07 30 ff f6 84 af c4  |bC.(.._.).0.....|
00000020  cf c2 ed 90 99 5f 58 cb  3b 74 14 03 03 00 01 01  |....._X.;t......|
00000030  16 03 03 00 20 69 ac be  cf f1 3d 8a 4e f3 3a 54  |.... i....=.N.:T|

	// Helper to read a single counter data file.
	readcdf := func(cdf string) error {
		cf, err := os.Open(cdf)
		if err != nil {
			return fmt.Errorf("opening counter data file %s: %s", cdf, err)
		}
		defer cf.Close()
		var cdr *decodecounter.CounterDataReader
		cdr, err = decodecounter.NewCounterDataReader(cdf, cf)
		if err != nil {
			return fmt.Errorf("reading counter data file %s: %s", cdf, err)
		}

00000280  39 7e 17 d8 74 ae 05 a3  f5 3a 71 74 e8 b4 c9 a4  |9~..t....:qt....|
00000290  1c 82 04 ca fe 5f 97 23  8a c1 f9 ce d1 5d 0e 81  |....._.#.....]..|
000002a0  da 5f e1 b6 76 80 3c cf  9f 19 79 cf 33 d0 0a fe  |._..v.<...y.3...|
000002b0  19 fc 2d 9a bb 24 cd d4  79 14 03 03 00 01 01 16  |..-..$..y.......|
000002c0  03 03 00 28 00 00 00 00  00 00 00 00 28 78 b8 0b  |...(........(x..|

	// regular loop body unrolled 4x
	ADDQ CX, CX		// restore CF
	MOVQ 0(R8)(SI*8), R11
	MOVQ 8(R8)(SI*8), R12
	MOVQ 16(R8)(SI*8), R13
	MOVQ 24(R8)(SI*8), R14
	ADCQ 0(R9)(SI*8), R11
	ADCQ 8(R9)(SI*8), R12
	ADCQ 16(R9)(SI*8), R13
	ADCQ 24(R9)(SI*8), R14
	MOVQ R11, 0(R10)(SI*8)
	MOVQ R12, 8(R10)(SI*8)
	MOVQ R13, 16(R10)(SI*8)
	MOVQ R14, 24(R10)(SI*8)
	SBBQ CX, CX		// save CF

	ADDQ $4, SI		// i += 4
	SUBQ $4, DI		// n -= 4

	MOVL z+0(FP), DI
	MOVL x+12(FP), SI
	MOVL y+24(FP), CX
	MOVL z_len+4(FP), BP
	MOVL $0, BX		// i = 0
	MOVL $0, DX		// c = 0
	JMP E1

L1:	MOVL (SI)(BX*4), AX
	ADDL DX, DX		// restore CF
	ADCL (CX)(BX*4), AX
	SBBL DX, DX		// save CF
	MOVL AX, (DI)(BX*4)
	ADDL $1, BX		// i++

E1:	CMPL BX, BP		// i < n
	JL L1

	NEGL DX
	MOVL DX, c+36(FP)
	RET


// func subVV(z, x, y []Word) (c Word)

	VLGVG $1, V0, R4          // put cf into R4
	SUB   $1, R4              // save cf

A1:
	ADD $12, R3 // n += 16
	BLT v1      // if n < 0 goto v1

U1:  // n >= 0
	// regular loop body unrolled 4x
	MOVD 0(R8)(R10*1), R5
	MOVD 8(R8)(R10*1), R6
	MOVD 16(R8)(R10*1), R7
	MOVD 24(R8)(R10*1), R1
	MOVD R0, R11
	SUBC R4, R11            // restore CF
	MOVD 0(R9)(R10*1), R11
	SUBE R11, R5