// markUnsafePoints finds unsafe points and computes lv.unsafePoints.
func (lv *liveness) markUnsafePoints() {
	if IsUnsafe(lv.f) {
		// No complex analysis necessary.
		lv.allUnsafe = true
		return
	}

	lv.unsafePoints = bitvec.New(int32(lv.f.NumValues()))
	lv.unsafeBlocks = bitvec.New(int32(lv.f.NumBlocks()))

	// Mark architecture-specific unsafe points.
	for _, b := range lv.f.Blocks {
		for _, v := range b.Values {

	}
}

func TestListValueContains(t *testing.T) {
	lv := NewListValue()
	lv.Append(testValue(t, 1, "first"))
	lv.Append(testValue(t, 2, "second"))
	lv.Append(testValue(t, 3, "third"))
	for i := types.Int(0); i < lv.Size().(types.Int); i++ {
		e := lv.Get(i)
		contained := lv.Contains(e)
		if contained != types.True {

func (lv *ListValue) Iterator() traits.Iterator {
	return &baseListIterator{
		getter: lv.Get,
		sz:     len(lv.Entries),
	}
}

// Size returns the number of elements in the list.
func (lv *ListValue) Size() ref.Val {
	return types.Int(len(lv.Entries))
}

// Type returns the CEL ref.Type for the list.
func (lv *ListValue) Type() ref.Type {
	return types.ListType
}

// Value returns the Go-native value.

	lv := strings.Split(line, "\t")
	if len(lv) < 3 {
		// maybe ztunnel logs
		// TODO remove this when https://github.com/istio/ztunnel/issues/453 is fixed
		matches := ztunnelLogPattern.FindStringSubmatch(line)
		if len(matches) < 5 {
			return nil, "", "", false
		}
		lv = matches[1:]
	}
	ts, err := time.Parse(time.RFC3339Nano, lv[0])
	if err != nil {

typealias X<XT> = List<X>
class A {
    typealias Y<YS, YV> = Map<YS, YV>

    class B {
        typealias Q<QS, QV> = MutableMap<QS, QV>
    }
}

fun foo() {
    typealias L<LS, LV> = Map<LS, LV>

	if err != nil {
		return
	}
	addGauge := func(desc *metrics.Desc, pvcRef *stats.PVCReference, v float64, lv ...string) {
		lv = append([]string{pvcRef.Namespace, pvcRef.Name}, lv...)
		ch <- metrics.NewLazyConstMetric(desc, metrics.GaugeValue, v, lv...)
	}
	allPVCs := sets.Set[string]{}
	for _, podStat := range podStats {
		if podStat.VolumeStats == nil {
			continue
		}

			res[key] = *row.Counter.Value
		}
	}
	return res
}

func toMetricKey(row *dto.Metric, metric *dto.MetricFamily) metricKey {
	kvs := []attribute.KeyValue{}
	for _, lv := range row.Label {
		kvs = append(kvs, attribute.String(*lv.Name, *lv.Value))
	}
	key := metricKey{
		name:  *metric.Name,
		attrs: attribute.NewSet(kvs...),
	}
	return key
}

type Compare func(any) error

	f.rest.Record(-1)
}

func (f baseMetric) runRecordHook(value float64) {
	recordHookMutex.RLock()
	if rh, ok := recordHooks[f.name]; ok {
		lv := slices.Map(f.attrs, func(e attribute.KeyValue) LabelValue {
			return LabelValue{e}
		})
		rh.OnRecord(f.name, lv, value)
	}
	recordHookMutex.RUnlock()
}

func (f baseMetric) Register() error {
	return nil
}

func (f baseMetric) RecordInt(value int64) {

	return nil
}

func (d *derivedGauge) ValueFrom(valueFn func() float64, labelValues ...LabelValue) DerivedMetric {
	d.mu.Lock()
	defer d.mu.Unlock()
	lv := slices.Map(labelValues, func(e LabelValue) attribute.KeyValue {
		return e.keyValue
	})
	as := attribute.NewSet(lv...)
	d.attrs[as] = valueFn
	return d

	metrics.CounterMetric

	signer string
	called bool
}

func (m *testCounterVecMetric) WithLabelValues(lv ...string) metrics.CounterMetric {
	if len(lv) != 1 {
		panic(lv)
	}

	if len(m.signer) != 0 {
		panic("unexpected multiple WithLabelValues() calls")
	}

	signer := lv[0]

	if len(signer) == 0 {
		panic("invalid empty signer")
	}

	m.signer = signer
	return m
}