return "", fmt.Errorf("invalid name %q, last '%c' should be alphanumeric", name, c)
	}

	return annotationPrefix + name, nil
}

// annotationValue returns an annotation value for the given devices.
func annotationValue(devices []string) (string, error) {
	value, sep := "", ""
	for _, d := range devices {
		if _, _, _, err := parseQualifiedName(d); err != nil {
			return "", err
		}

        append(value.callableId?.asSingleFqName()?.asString())
    }

    private fun StringBuilder.renderAnnotationConstantValue(application: KaAnnotationApplicationValue) {
        renderAnnotationApplication(application.annotationValue)
    }

    private fun StringBuilder.renderAnnotationApplication(value: KaAnnotation) {
        append(value.classId)
        if (value.arguments.isNotEmpty()) {
            append("(")

    private fun renderConstantValueDebug(value: KaAnnotationValue, printer: PrettyPrinter) {
        when (value) {
            is KaAnnotationApplicationValue -> {
                renderAnnotationDebug(value.annotationValue.classId, value.annotationValue.arguments, printer)
            }

            is KaArrayAnnotationValue -> {
                printer.printCollection(value.values, separator = ", ", prefix = "[", postfix = "]") {

			if e, ok := annotationsMap[k]; ok {
				klog.V(4).InfoS("Skip existing annotation", "annotationKey", k, "annotationValue", v)
				if e != v {
					klog.ErrorS(nil, "Annotation has conflicting setting", "annotationKey", k, "expected", e, "got", v)
				}
				continue
			}
			klog.V(4).InfoS("Add annotation", "annotationKey", k, "annotationValue", v)
			annotationsMap[k] = v

					Infrastructure: &k8s.GatewayInfrastructure{
						Labels:      map[k8s.AnnotationKey]k8s.AnnotationValue{"foo": "bar", "gateway.networking.k8s.io/ignore": "true"},
						Annotations: map[k8s.AnnotationKey]k8s.AnnotationValue{"fizz": "buzz", "gateway.networking.k8s.io/ignore": "true"},
					},
				},
			},
			objects: defaultObjects,
		},
		{

			b := NewBackend(fb, defaultConfig, auditv1.SchemeGroupVersion)
			b.ProcessEvents(tc.event)

			require.Equal(t, !tc.wantDropped, event != nil, "Incorrect event presence")
			if tc.wantTruncated {
				require.Equal(t, annotationValue, event.Annotations[annotationKey], "Annotation should be present")
				require.Nil(t, event.RequestObject, "After truncation request should be nil")
				require.Nil(t, event.ResponseObject, "After truncation response should be nil")

	annotationValue, ok := rs.Annotations[annotationKey]
	if !ok {
		return int32(0), false
	}
	intValue, err := strconv.Atoi(annotationValue)
	if err != nil {
		logger.V(2).Info("Could not convert the value with annotation key for the replica set", "annotationValue", annotationValue, "annotationKey", annotationKey, "replicaSet", klog.KObj(rs))
		return int32(0), false

			},
			Listeners: []v1beta1.Listener{
				{
					Name: "detected-by-options",
					TLS: &v1beta1.GatewayTLSConfig{
						Mode: &passthroughMode,
						Options: map[v1beta1.AnnotationKey]v1beta1.AnnotationValue{
							constants.ListenerModeOption: constants.ListenerModeAutoPassthrough,
						},
					},
					Port: v1beta1.PortNumber(customPort),
				},
				{
					Name: "detected-by-number",

                    append(")")
                }

                is KaConstantValueForAnnotation -> {
                    append("KtConstantValueForAnnotation(")
                    append(value.annotationValue.renderAsSourceCode())
                    append(")")
                }
            }
        }
    }

    private fun KaSession.renderAnnotationsList(value: KaAnnotationList, printer: PrettyPrinter) {

		if err != nil {
			// Log this because it is not an expected situation.
			klog.V(4).InfoS("Skipping deletion of APF object with malformed "+flowcontrolv1.AutoUpdateAnnotationKey+" annotation", "name", name, "annotationValue", value, "parseError", err)
			continue
		}
		if !autoUpdate {
			klog.V(5).InfoS("Skipping deletion of APF object with "+flowcontrolv1.AutoUpdateAnnotationKey+"=false annotation", "name", name)
			continue
		}