class SearchTerm {
        private String product;
        private String vendor;

        public SearchTerm(String vendor,String product) {
            this.product = product;
            this.vendor = StringUtils.isBlank(vendor) ? "*" : vendor;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            SearchTerm that = (SearchTerm) o;
            return product.equals(that.product) && Objects.equals(vendor, that.vendor);
        }

        public String getVendor() {
            return vendor;
        }

        public String getProduct() {
            return product;
        }

        @Override
        public int hashCode() {
            return Objects.hash(product, vendor);
        }
    }

    public List<VulnerableSoftware> fuzzyAnalysis(QueryManager qm, final Component component, us.springett.parsers.cpe.Cpe parsedCpe) {<FILL_FUNCTION_BODY>

        List<VulnerableSoftware>  fuzzyList = Collections.emptyList();
        if (component.getPurl() == null || !excludeComponentsWithPurl || "deb".equals(component.getPurl().getType())) {
            Set<SearchTerm> searches = new LinkedHashSet<>();
            try {
                boolean attemptLuceneFuzzing = true;
                Part part = Part.ANY;
                String nameToFuzz = component.getName();
                if (parsedCpe != null) {
                    part = parsedCpe.getPart();
                    searches.add(new SearchTerm(parsedCpe.getVendor(), parsedCpe.getProduct()));
                    nameToFuzz = parsedCpe.getProduct();
                }
                if (component.getPurl() != null) {
                    if (component.getPurl().getType().equals("golang")) {
                        searches.add(new SearchTerm(StringUtils.substringAfterLast(component.getPurl().getNamespace(), "/"), component.getPurl().getName()));
                    } else {
                        searches.add(new SearchTerm(component.getPurl().getNamespace(), component.getPurl().getName()));
                        if (component.getName().equals(nameToFuzz)) {
                            nameToFuzz = component.getPurl().getName();
                        }
                    }
                    attemptLuceneFuzzing = !SKIP_LUCENE_FUZZING_FOR_TYPE.contains(component.getPurl().getType());
                }
                searches.add(new SearchTerm(component.getGroup(), component.getName()));
                for (SearchTerm search : searches) {
                    fuzzyList = fuzzySearch(qm, part, search.getVendor(), search.getProduct());
                    if (fuzzyList.isEmpty() && !"*".equals(search.getVendor())) {
                        fuzzyList = fuzzySearch(qm, part, "*", search.getProduct());
                    }
                    if (!fuzzyList.isEmpty()) {
                        break;
                    }
                }

                // If no luck, get fuzzier but not with small values as fuzzy 2 chars are easy to match
                if (fuzzyList.isEmpty() && nameToFuzz.length() > 2 && attemptLuceneFuzzing && !DO_NOT_FUZZ.contains(nameToFuzz)) {
                    us.springett.parsers.cpe.Cpe justThePart = new us.springett.parsers.cpe.Cpe(part, "*", "*", "*", "*", "*", "*", "*", "*", "*", "*");
                    // wildcard all components after part to constrain fuzzing to components of same type e.g. application, operating-system
                    String fuzzyTerm = getLuceneCpeRegexp(justThePart.toCpe23FS());
                    LOGGER.debug(null, "Performing lucene ~ fuzz matching on '{}'", nameToFuzz);
                    //The tilde makes it fuzzy. e.g. Will match libexpat1 to libexpat and product exact matches with vendor mismatch
                    fuzzyList = fuzzySearch(qm, "product:" + nameToFuzz + "~0.88 AND " + fuzzyTerm);
                }
            } catch (CpeValidationException cve) {
                LOGGER.error("Failed to validate fuzz search CPE", cve);
            }
        }
        return fuzzyList;
    
<no_super_class>