kinds := findResourceInSpec(un.GetObjectKind().GroupVersionKind())
	if kinds == "" {
		kinds = strings.ToLower(un.GetKind()) + "s"
	}
	// Override with special kind if it exists in the map
	if specialKind, exists := specialKinds[un.GetKind()]; exists {
		kinds = specialKind
	}
	return kinds
}

    private static List<ParameterInfo> modifiedParameters(List<ParameterInfo> originalParameters) {
        ArrayList<ParameterInfo> result = new ArrayList<>(originalParameters);
        if (result.size() == 0 || result.get(0).getKind() != ParameterKindInfo.RECEIVER) {
            throw new UnsupportedOperationException("extensions with static references that do not have a receiver parameter are not supported");
        }

     */
    default void validatePropertyMetadata(PropertyMetadata propertyMetadata, TypeValidationContext validationContext) {}

    /**
     * Returns the kind of properties this handler handles.
     */
    Kind getKind();

    enum Kind {
        INPUT, OUTPUT, OTHER
    }

        return annotatedClassElements
            .flatMap(element -> element.getKind() == ElementKind.METHOD ? Stream.of(element) : element.getEnclosedElements().stream())
            .filter(it -> it.getKind() == ElementKind.METHOD)
            .map(it -> (ExecutableElement) it)

        }
        Set<String> typeNames = new LinkedHashSet<>();
        for (Element element : originatingElements) {
            // TODO: Support for modules
            if (!element.getKind().name().equals("MODULE")) {
                String topLevelTypeName = getTopLevelTypeName(element);
                typeNames.add(topLevelTypeName);
            }
        }
        return typeNames;
    }

public class AnnotationCallInterceptionRequestReaderImpl implements AnnotatedMethodReaderExtension {

    @Override
    public Collection<Result> readRequest(ExecutableElement input) {
        if (input.getKind() != ElementKind.METHOD) {
            return emptyList();
        }

        if (!input.getModifiers().containsAll(Arrays.asList(Modifier.STATIC, Modifier.PUBLIC))) {
            return emptyList();
        }

  // The default debug string includes a shape, dtype and FullType.
  // Implementations are free to override it with something more informative.
  virtual std::string DebugString() const;

  AbstractTensorHandleKind getKind() const { return kind_; }

 private:
  const AbstractTensorHandleKind kind_;
};

namespace internal {
struct AbstractTensorHandleDeleter {
  void operator()(AbstractTensorHandle* p) const {

func (c *sigctxt) set_r30(x uint64)  { c.regs().gpr[30] = x }
func (c *sigctxt) set_pc(x uint64)   { c.regs().nip = x }
func (c *sigctxt) set_sp(x uint64)   { c.regs().gpr[1] = x }
func (c *sigctxt) set_link(x uint64) { c.regs().link = x }

func (c *sigctxt) set_sigcode(x uint32) { c.info.si_code = int32(x) }
func (c *sigctxt) set_sigaddr(x uint64) {
	*(*uintptr)(add(unsafe.Pointer(c.info), 2*goarch.PtrSize)) = uintptr(x)

	}
	f := fuzz.NewConsumer(data[1:])
	err = f.GenerateStruct(object)
	if err != nil {
		return 0
	}
	err = checkForNilValues(object)
	if err != nil {
		return 0
	}
	typeAcc.SetKind(kgvk.Kind)
	typeAcc.SetAPIVersion(kgvk.GroupVersion().String())

	roundTrip(json.NewSerializer(json.DefaultMetaFactory, scheme, scheme, false), object)
	return 1
}

// roundTrip performs the roundtrip of the object.

import java.util.List;

public class TypeMirrorToType extends AbstractTypeVisitor8<Type, Void> {

    @Override
    public Type visitPrimitive(PrimitiveType t, Void unused) {
        TypeKind kind = t.getKind();
        if (kind == TypeKind.INT) {
            return Type.INT_TYPE;
        }
        if (kind == TypeKind.BYTE) {
            return Type.BYTE_TYPE;
        }
        if (kind == TypeKind.BOOLEAN) {