String callableNameForDocComment = interceptedCallable.getKind() == CallableKindInfo.AFTER_CONSTRUCTOR ? className.simpleName() : interceptedCallable.getCallableName();
        List<ParameterInfo> params = request.getInterceptedCallable().getParameters();
        List<ParameterInfo> methodParameters = params.stream().filter(parameter -> parameter.getKind().isSourceParameter()).collect(Collectors.toList());

func FuzzHeaderMatcher(data []byte) int {
	k, v, err := getKandV(data)
	if err != nil {
		return 0
	}
	_ = matcher.HeaderMatcher(k, v)
	return 1
}

func FuzzHostMatcherWithRegex(data []byte) int {
	k, v, err := getKandV(data)
	if err != nil {
		return 0
	}
	_ = matcher.HostMatcherWithRegex(k, v)
	return 1
}

func FuzzHostMatcher(data []byte) int {
	k, v, err := getKandV(data)
	if err != nil {
		return 0
	}

            'dependencies {'
        }

        @Override
        public String getEnd() {
            '}'
        }
    },
    API {
        @Override
        public String getBegin() {
            'api { dependencies {'
        }

        @Override
        public String getEnd() {
            '}}'
        }
    },
    SOURCES {
        @Override

  return type && type.getRank() == rank &&
         mlir::isa<FloatType>(type.getElementType());
}

// Returns true if the given `value` has the specified rank or has unranked
// type.
inline bool IsOfRankOrUnranked(Value value, int64_t rank) {
  RankedTensorType type = GetRankedTensorTypeForOperand(value);
  return !type || type.getRank() == rank;
}

    ShapedType& updates_type, ConversionPatternRewriter& rewriter) {
  auto canonical_update_window_dims = llvm::to_vector(
      llvm::seq<int64_t>(indices_type.getRank() - 1, updates_type.getRank()));

  if (canonical_update_window_dims == update_window_dims) return success();

  // Permute updates if `update_window_dims` are leading indices.

        return callableInfo.getParameters().stream().anyMatch(it -> it.getKind() == ParameterKindInfo.CALLER_CLASS_NAME);
    }

    public static boolean hasInjectVisitorContext(CallableInfo callableInfo) {
        return callableInfo.getParameters().stream().anyMatch(it -> it.getKind() == ParameterKindInfo.INJECT_VISITOR_CONTEXT);
    }

        return symbol;
    }

    private static boolean isPackageInfoFile(TaskEvent e, File asSourceFile) {
        return e.getKind() == TaskEvent.Kind.ANALYZE && "package-info.java".equals(asSourceFile.getName());
    }

    private static boolean isClassGenerationPhase(TaskEvent e) {
        return e.getKind() == TaskEvent.Kind.GENERATE;
    }

    public void registerMapping(String key, String symbol) {

        Optional<ParameterInfo> varargParameter = callable.getParameters().stream().filter(it -> it.getKind() == ParameterKindInfo.VARARG_METHOD_PARAMETER).findAny();
        CallableKindInfo kind = callable.getKind();
        return Stream.of(
            // Match the `Class<?>` in `receiver` for static methods and constructors
            kind == STATIC_METHOD || kind == AFTER_CONSTRUCTOR

    }

    public static String interceptedJvmMethodName(CallableInfo callableInfo) {
        if (callableInfo.getKind() == CallableKindInfo.GROOVY_PROPERTY_GETTER) {
            return getterName(callableInfo.getCallableName(), callableInfo.getReturnType().getType());
        }
        if (callableInfo.getKind() == CallableKindInfo.GROOVY_PROPERTY_SETTER) {
            return setterName(callableInfo.getCallableName());
        }

  if (!dims_type) return success();
  if (dims_type.getRank() > 1)
    return emitError(loc, "dimensions can only be 0D or 1D tensor");

  auto input_type = mlir::dyn_cast<RankedTensorType>(input.getType());
  if (!input_type) return success();
  int64_t rank = input_type.getRank();

  DenseIntElementsAttr dims_attr;
  if (!matchPattern(dims, m_Constant(&dims_attr))) return success();