}
        return snapshotter.snapshot(value);
    }

    private boolean isEqualEnum(@Nullable Object value) {
        if (value instanceof Enum<?>) {
            Enum<?> enumValue = (Enum<?>) value;
            return enumValue.name().equals(name) && enumValue.getDeclaringClass().getName().equals(className);
        }
        return false;
    }

    @Override
    public void appendToHasher(Hasher hasher) {

        writeEnumValueOf(value::class.java.superclass, value)
    }
}


private
fun WriteContext.writeEnumValueOf(enumClass: Class<out Any>, enumValue: Any) {
    writeClass(enumClass)
    writeSmallInt((enumValue as Enum<*>).ordinal)

	// the slot we used via an index into locations[v.Type].
	slots := f.Cache.allocIntSlice(f.NumValues())
	defer f.Cache.freeIntSlice(slots)
	for i := range slots {
		slots[i] = -1
	}

	// Pick a stack slot for each value needing one.
	used := f.Cache.allocBoolSlice(f.NumValues())
	defer f.Cache.freeBoolSlice(used)
	for _, b := range f.Blocks {
		for _, v := range b.Values {

        "minLength": 14,
        "pattern": "patternValue",
        "maxItems": 16,
        "minItems": 17,
        "uniqueItems": true,
        "multipleOf": 19.5,
        "enum": [
          "enumValue"
        ],
        "maxProperties": 21,
        "minProperties": 22,
        "required": [
          "requiredValue"
        ],
        "items": [
          {}
        ],
        "allOf": [

      default: defaultValue
      definitions:
        definitionsKey: {}
      dependencies:
        dependenciesKey:
        - <no json tag> PropertyValue
      description: descriptionValue
      enum:
      - enumValue
      example: exampleValue
      exclusiveMaximum: true
      exclusiveMinimum: true
      externalDocs:
        description: descriptionValue
        url: urlValue
      format: formatValue
      id: idValue

    val parameterName = StandardClassIds.Annotations.ParameterNames.value
    return computeTargetAnnotationArguments(annotation, builder, enumClassId, parameterName) {
        ElementType.entries.firstOrNull { enumValue -> enumValue.name == it }?.name
    }
}

private fun <T> FirAnnotation.findFromRawArguments(expectedEnumClass: ClassId, transformer: (String) -> T?): Set<T> = buildSet {
    fun addIfMatching(arg: FirExpression) {

        definitions:
          definitionsKey: {}
        dependencies:
          dependenciesKey:
          - <no json tag> PropertyValue
        description: descriptionValue
        enum:
        - enumValue
        example: exampleValue
        exclusiveMaximum: true
        exclusiveMinimum: true
        externalDocs:
          description: descriptionValue
          url: urlValue
        format: formatValue

        }
        if (value instanceof List) {
            return processList((List<?>) value, visitor);
        }
        if (value instanceof Enum) {
            return visitor.enumValue((Enum<?>) value);
        }
        if (value instanceof Class<?>) {
            return visitor.classValue((Class<?>) value);
        }
        Class<?> valueClass = value.getClass();

            "pattern": "patternValue",
            "maxItems": 16,
            "minItems": 17,
            "uniqueItems": true,
            "multipleOf": 19.5,
            "enum": [
              "enumValue"
            ],
            "maxProperties": 21,
            "minProperties": 22,
            "required": [
              "requiredValue"
            ],
            "items": [
              {}
            ],

func dse(f *Func) {
	var stores []*Value
	loadUse := f.newSparseSet(f.NumValues())
	defer f.retSparseSet(loadUse)
	storeUse := f.newSparseSet(f.NumValues())
	defer f.retSparseSet(storeUse)
	shadowed := f.newSparseMap(f.NumValues())
	defer f.retSparseMap(shadowed)