return false; // This is the first occurrence
                    }
                })
                .toList();

        // Remove duplicates while preserving formatting
        duplicates.forEach(DomUtils::removeElement);

        return !duplicates.isEmpty();
    }

    private String createDependencyKey(Element dependency) {
        String groupId = dependency.childText(MavenPomElements.Elements.GROUP_ID);

):
    return [item, sub_item]


@app.post("/with-duplicates")
async def with_duplicates(item: Item, item2: Item = Depends(duplicate_dependency)):
    return [item, item2]


@app.post("/no-duplicates")
async def no_duplicates(item: Item, item2: Item = Depends(dependency)):
    return [item, item2]


@app.post("/with-duplicates-sub")
async def no_duplicates_sub(

            // Optimization to skip streaming, distincting, and collecting to a new list when there is zero or one
            // project, aka there can't be duplicates.
            return filtered;
        }

        // Distinct the projects to avoid duplicates.  Duplicates are possible in multi-module projects.
        //
        // Given a scenario where there is an aggregate POM with modules A, B, C, D, and E and project E depends on

    @SuppressWarnings("unchecked")
    E[] array = (E[]) elements.toArray();
    /*
     * For a Set, we guess that it contains no duplicates. That's just a guess for purpose of
     * sizing; if the Set uses different equality semantics, it might contain duplicates according
     * to equals(), and we will deduplicate those properly, albeit at some cost in allocations.
     */
    int expectedSize =

    return wrapList(key, (List<V>) collection, null);
  }

  // Following Javadoc copied from ListMultimap.

  /**
   * {@inheritDoc}
   *
   * <p>Because the values for a given key may have duplicates and follow the insertion ordering,
   * this method returns a {@link List}, instead of the {@link Collection} specified in the {@link
   * Multimap} interface.
   */
  @Override

        }
    }

    @Override
    public List<String> convert(final String text, final String field, final String... lang) throws IOException {
        // Use LinkedHashSet to maintain insertion order while eliminating duplicates
        final Set<String> resultSet = new LinkedHashSet<>();
        resultSet.add(text);

        // Start with the original text as the first input
        List<String> currentInputs = new ArrayList<>();

        assertEquals(cProject, sortedProjects.get(1));

        assertTrue(graph.getDownstreamProjects(aProject, false).contains(cProject));
    }

    // Test verifying that getDownstreamProjects does not contain duplicates.
    // This is a regression test for https://github.com/apache/maven/issues/2487.
    //
    // The graph is:
    // aProject -> bProject
    //        | -> dProject
    //        | -> eProject

        assertEquals("https://example.com/sitemap2.xml", sitemaps[1]);
    }

    public void test_addSitemapNoDuplicates() {
        // Test that addSitemap doesn't add duplicates
        RobotsTxt robotsTxt = new RobotsTxt();

        robotsTxt.addSitemap("https://example.com/sitemap.xml");
        robotsTxt.addSitemap("https://example.com/sitemap.xml");

    assertEquals(
        "multiset.count(wrongType) didn't return 0", 0, getMultiset().count(WrongType.VALUE));
  }

  /**
   * Returns {@link Method} instances for the read tests that assume multisets support duplicates so
   * that the test of {@code Multisets.forSet()} can suppress them.
   */
  @J2ktIncompatible
  @GwtIncompatible // reflection
  public static List<Method> getCountDuplicateInitializingMethods() {

				xhttp.AmzObjectAttributes: []string{"test1,test2"},
			},
			wantObjectAttrs: map[string]struct{}{
				"test1": {}, "test2": {},
			},
		},
		{
			name: "multiple header lines with some duplicates",
			headers: http.Header{
				xhttp.AmzObjectAttributes: []string{"test1,test2", "test3,test4", "test4,test3"},
			},
			wantObjectAttrs: map[string]struct{}{
				"test1": {}, "test2": {}, "test3": {}, "test4": {},