for (auto& iter : attrs) {
    auto& attr = iter.second;
    if (attr.has_func()) {
      try_use_original_func_name(attr.mutable_func()->mutable_name());
    } else if (attr.has_list()) {
      for (auto& func_attr : *attr.mutable_list()->mutable_func()) {
        try_use_original_func_name(func_attr.mutable_name());
      }
    }
  }
}

  for (auto& iter : attrs) {
    auto& attr = iter.second;
    if (attr.has_func()) {
      try_use_original_func_name(attr.mutable_func()->mutable_name());
    } else if (attr.has_list()) {
      for (auto& func_attr : *attr.mutable_list()->mutable_func()) {
        try_use_original_func_name(func_attr.mutable_name());
      }
    }
  }
}

        return mlir::UnrankedTensorType::get(
            mlir::TF::ResourceType::get(builder.getContext()));
      }
    } else if (auto shape = node.attrs().Find("_output_shapes")) {
      if (shape->has_list() && shape->list().shape_size() == 1) {
        return ConvertToMlirTensorType(shape->list().shape().at(0), dtype,
                                       &builder);
      }
    }
  }

	if base.fileIndex >= 0 {
		panic("PosBase already registered with a PosTable")
	}

	if t.indexMap == nil {
		t.baseList = append(t.baseList, nil)
		t.indexMap = make(map[*PosBase]int)
		t.nameMap = make(map[string]int)
	}

	i := len(t.baseList)
	t.indexMap[base] = i
	t.baseList = append(t.baseList, base)

	fileIndex, ok := t.nameMap[base.absFilename]
	if !ok {
		fileIndex = len(t.nameMap)

    List<String> b = asList("c", "d");
    ImmutableSortedMultiset<String> multiset =
        ImmutableSortedMultiset.<String>naturalOrder().addAll(a).addAll(b).build();
    assertEquals(HashMultiset.create(asList("a", "b", "c", "d")), multiset);
  }

  public void testBuilderAddAllMultiset() {
    Multiset<String> a = HashMultiset.create(asList("a", "b", "b"));

                Contributor.newBuilder().email("******@****.***").build();

        Model target =
                Model.newBuilder().contributors(Arrays.asList(contributor)).build();

        Model source =
                Model.newBuilder().contributors(Arrays.asList(contributor)).build();

        Model merged = mavenMerger.merge(target, source, true, null);

        assertThat(merged.getContributors(), contains(contributor));

			}
			xpos = xposWith
		}
	}

	if len(tab.baseList) != 1+len(tab.indexMap) { // indexMap omits nil
		t.Errorf("table length discrepancy: %d != 1+%d", len(tab.baseList), len(tab.indexMap))
	}

	const wantLen = 4
	if len(tab.baseList) != wantLen {
		t.Errorf("got table length %d; want %d", len(tab.baseList), wantLen)
	}

	if got := tab.XPos(NoPos); got != NoXPos {

    Multiset<String> ms2 = HashMultiset.create(Arrays.asList("a"));
    assertThat(Multisets.difference(ms1, ms2)).containsExactly("a", "b");
  }

  public void testDifferenceWithRemovedElement() {
    Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a"));
    Multiset<String> ms2 = HashMultiset.create(Arrays.asList("b"));

            (K k, V v) -> {
              int index = keys().asList().indexOf(k);
              return values().asList().get(index + 1);
            });
    List<Entry<K, V>> expectedEntries = new ArrayList<>();
    for (Entry<K, V> entry : getSampleEntries()) {
      int index = keys().asList().indexOf(entry.getKey());
      expectedEntries.add(Helpers.mapEntry(entry.getKey(), values().asList().get(index + 1)));
    }

        actual = Arrays.asList(KuromojiCSVUtil.parse(value));
        assertThat(actual, is(expected));

        value = "\"Fess,FESS\"";
        expected = Arrays.asList("\"Fess,FESS\"");
        actual = Arrays.asList(KuromojiCSVUtil.parse(value));
        assertThat(actual, is(expected));

        value = " ";
        expected = Arrays.asList(" ");