// dead value in dead block
			Valu("deadval", OpConstBool, c.config.Types.Bool, 1, nil),
			If("deadval", "deadblock", "exit")))

	CheckFunc(fun.f)
	Deadcode(fun.f)
	CheckFunc(fun.f)

	for _, b := range fun.f.Blocks {
		if b == fun.blocks["deadblock"] {
			t.Errorf("dead block not removed")
		}
		for _, v := range b.Values {
			if v == fun.values["deadval"] {
				t.Errorf("control value of dead block not removed")

//       Bloc("exit",
//           Exit("mem")),
//       Bloc("deadblock",
//          Valu("deadval", OpConstBool, c.config.Types.Bool, 0, true),
//          If("deadval", "deadblock", "exit")))
//
// and the Blocks or Values used in the Func can be accessed
// like this:
//   fun.blocks["entry"] or fun.values["deadval"]

package ssa

// TODO(matloob): Choose better names for Fun, Bloc, Goto, etc.

		// If we see "values," then the element is a root and we shouldn't put it in our label name
		if k == "values" {
			labels = append(labels, readVal(v, path)...)
		} else {
			if len(path) > 0 || k.(string) != "features" {
				path = append(path, k.(string))
			}
			labels = append(labels, readVal(v, path)...)
			if len(path) > 0 {
				path = path[:len(path)-1]
			}
		}
	}
	return labels
}

	switch src := r.src.(type) {
	case *lockedSource:
		return src.read(p, &r.readVal, &r.readPos)
	case *runtimeSource:
		return src.read(p, &r.readVal, &r.readPos)
	}
	return read(p, r.src, &r.readVal, &r.readPos)
}

func read(p []byte, src Source, readVal *int64, readPos *int8) (n int, err error) {
	pos := *readPos
	val := *readVal
	rng, _ := src.(*rngSource)
	for n = 0; n < len(p); n++ {
		if pos == 0 {

			if _, err := p.readVal(); err != nil {
				return errMalformedVarint
			}
			ln, err := p.readVal()
			if err != nil {
				return err
			}
			if !p.discard(ln) {
				return fmt.Errorf("failed to read trace: %w", io.EOF)
			}
		} else {
			// String dictionary entry [ID, length, string].
			id, err := p.readVal()
			if err != nil {
				return err
			}

	Key2_Val2	Feature = "key2.val2"`

func TestReadVal(t *testing.T) {
	m := make(map[any]any)

	err := yaml.Unmarshal([]byte(testYaml), &m)
	if err != nil {
		t.Errorf(err.Error())
	}

	s1 := readVal(m, make([]string, 0))

	sort.Strings(s1)

	if strings.Join(s1, "\n") != expectedResult {
		t.Errorf("Expected '%s' got '%s'", expectedResult, strings.Join(s1, "\n"))
	}

    const UniformQuantizedValueConverter &converter) {
  return realFPElementsAttr.mapValues(
      quantizedElementType.getStorageType(),
      [&converter](const APFloat &realVal) {
        return converter.quantizeFloatToInt(realVal);
      });
}

/// Converts a real expressed SplatElementsAttr to a corresponding
/// SplatElementsAttr containing quantized storage values assuming the given

// attribute already exists with a different value, returns an error.
template <typename ContainerT,
          typename = typename std::enable_if<
              std::is_same<mlir::Type, decltype(*std::declval<ContainerT>()
                                                     .begin())>::value>::type>
Status SetTypeAttribute(absl::string_view name, ContainerT types,
                        AttrValueMap* values) {
  AttrValue value;

		panic("variable value type must be a pointer")
	}
	defVal := reflect.ValueOf(val)
	if defVal.Kind() == reflect.Ptr {
		defVal = defVal.Elem()
	}
	if defVal.Type() != ptrVal.Type().Elem() {
		panic(fmt.Sprintf("default type does not match variable type: %v != %v", defVal.Type(), ptrVal.Type().Elem()))
	}
	ptrVal.Elem().Set(defVal)
	return textValue{p}
}

func (v textValue) Set(s string) error {

	AssertEqual(t, err, nil)

	defVal, ok := columnType.DefaultValue()
	AssertEqual(t, defVal, "null")
	AssertEqual(t, ok, true)

	columnType2, err := findColumnType(tableName, "active")
	AssertEqual(t, err, nil)

	defVal, ok = columnType2.DefaultValue()
	bv, _ := strconv.ParseBool(defVal)
	AssertEqual(t, bv, false)
	AssertEqual(t, ok, true)