PSTB R1, $1, 12345678(R2)               // 061000bc9822614e
	PSTD R1, $1, 12345678(R2)               // 041000bcf422614e
	PSTFD F1, $1, 12345678(R2)              // 061000bcd822614e
	PSTFS F1, $1, 123456789(R7)             // 0610075bd027cd15
	PSTH R1, $1, 12345678(R2)               // 061000bcb022614e
	PSTQ R2, $1, 12345678(R2)               // 041000bcf042614e

	"XXSPLTI32DX",
	"XXPERMX",
	"XXEVAL",
	"XXBLENDVW",
	"XXBLENDVH",
	"XXBLENDVD",
	"XXBLENDVB",
	"PSTXVP",
	"PSTXV",
	"PSTXSSP",
	"PSTXSD",
	"PSTW",
	"PSTQ",
	"PSTH",
	"PSTFS",
	"PSTFD",
	"PSTD",
	"PSTB",
	"PNOP",
	"PMXVI8GER4SPP",
	"PMXVI8GER4PP",
	"PMXVI8GER4",
	"PMXVI4GER8PP",
	"PMXVI4GER8",
	"PMXVI16GER2SPP",
	"PMXVI16GER2S",
	"PMXVI16GER2PP",

	PMXVI8GER4PP:   "pmxvi8ger4pp",
	PMXVI8GER4SPP:  "pmxvi8ger4spp",
	PNOP:           "pnop",
	PSTB:           "pstb",
	PSTD:           "pstd",
	PSTFD:          "pstfd",
	PSTFS:          "pstfs",
	PSTH:           "psth",
	PSTQ:           "pstq",
	PSTW:           "pstw",
	PSTXSD:         "pstxsd",
	PSTXSSP:        "pstxssp",
	PSTXV:          "pstxv",
	PSTXVP:         "pstxvp",

}

// ValuesValidate validates the values of the tree using the supplied Func
func ValuesValidate(validations map[string]ValidatorFunc, node any, path util.Path) (errs util.Errors) {
	pstr := path.String()
	scope.Debugf("ValuesValidate %s", pstr)
	vf := validations[pstr]
	if vf != nil {
		errs = util.AppendErrs(errs, vf(path, node))
	}

	nn, ok := node.(map[string]any)
	if !ok {
		// Leaf, nothing more to recurse.
		return errs
	}

	pstr := path.String()
	msg := fmt.Sprintf("validate %s:%v(%T) ", pstr, val, val)
	if util.IsValueNil(val) || util.IsEmptyString(val) {
		if checkRequired && requiredValues[pstr] {
			return util.NewErrs(fmt.Errorf("field %s is required but not set", util.ToYAMLPathString(pstr)))
		}
		msg += fmt.Sprintf("validate %s: OK (empty value)", pstr)
		scope.Debug(msg)
		return nil
	}

// STATIC-RANGE-PTQ-TO-ALL-SAME: _quantization_method = "static_range_ptq { }"
// STATIC-RANGE-PTQ-TO-ALL-SAME: _tfl_quant_trait = "fully_quantizable"

// STATIC-RANGE-PTQ-TO-ALL: return %[[XLA_CALL_MODULE:.+]] : tensor<1x1x64xf32>
// STATIC-RANGE-PTQ-TO-ALL: }

// STATIC-RANGE-PTQ-TO-ALL-LABEL: private @composite_dot_general_fn_1
// STATIC-RANGE-PTQ-TO-ALL-SAME: tf_quant.composite_function

	for _, test := range []struct {
		in   string
		name string
		out  string
		ok   bool
	}{
		{"", "", "", false},
		{"X", "", "", false},
		{"PST", "PST", "", true},
		{"PST8PDT", "PST", "8PDT", true},
		{"PST-08", "PST", "-08", true},
		{"<A+B>+08", "A+B", "+08", true},
	} {
		name, out, ok := time.TzsetName(test.in)
		if name != test.name || out != test.out || ok != test.ok {

    assertThat("Thursday, 01-Jan-1970 00:00:00 PST".toHttpDateOrNull()!!.time)
      .isEqualTo(28800000L)
    // Ignore trailing junk
    assertThat("Thursday, 01-Jan-1970 00:00:00 PST JUNK".toHttpDateOrNull()!!.time)
      .isEqualTo(28800000L)

    // ANSI C's asctime() format
    // This format ignores the timezone entirely even if it is present and uses GMT.

enum class TestQuantizationSpecs {
  kEmpty,                         // empty
  kDisableAllDotGeneral,          // disable-all-dot-general
  kStaticRangePtqToAll,           // static-range-ptq-to-all
  kStaticRangePtqToComputeHeavy,  // static-range-ptq-to-compute-heavy
};

// Adds generated pass default constructors or options definitions.
#define GEN_PASS_DECL
// Adds generated pass registration functions.
#define GEN_PASS_REGISTRATION

	{"", "2006-01-02 15:04:05.999999999 -0700 MST", "2010-02-04 21:00:57.012345678 -0800 PST", true, false, 1, 9},
	// comma "," separator.
	{"", "2006-01-02 15:04:05,9999 -0700 MST", "2010-02-04 21:00:57 -0800 PST", true, false, 1, 0},
	{"", "2006-01-02 15:04:05,999999999 -0700 MST", "2010-02-04 21:00:57 -0800 PST", true, false, 1, 0},