Returns true if the element <code>e</code> has not been
unified yet with any DIFFERENT element.  Complexity: O(1).
480143
public boolean unUnified(E e) {
	Node<E> node = elmap.get(e);
	if(node == null) {
	    // never been the argument of a call to union -> true
	    return true;
	}
	// even if e was sent to union in the past, maybe it was
	// unified only with equal elements; the following tests
	// check this quickly
	if(node.parent != node) {
	    // already have a parent, so cannot be unUnified -> false
	    return false;
	}
	// node is a root! last chance is that it's only a root of itself!
	return node.nbElems == 1;
    }
804725
def is_unique(seq):
    ''''''
    try:
        s = set(seq)
        return len(s) == len(seq)
    except TypeError:
        buf = []
        for item in seq:
            if item in buf:
                return False
            buf.append(item)
        return True
1147146
public void hasFirstElement(@NullableDecl Object element) {
    if (actualAsNavigableSet().isEmpty()) {
      failWithActual("expected to have first element", element);
      return;
    }

    if (!Objects.equal(actualAsNavigableSet().first(), element)) {
      if (actualAsNavigableSet().contains(element)) {
        failWithoutActual(
            simpleFact(
                lenientFormat(
                    "Not true that %s has first element <%s>. "
                        + "It does contain this element, but the first element is <%s>",
                    actualAsString(), element, actualAsNavigableSet().first())));
        return;
      }
      failWithoutActual(
          simpleFact(
              lenientFormat(
                  "Not true that %s has first element <%s>. "
                      + "It does not contain this element, and the first element is <%s>",
                  actualAsString(), element, actualAsNavigableSet().first())));
    }
  }
994872
private boolean existsIn(String element, String[] a) {
        for (String s : a) {
            if (element.equals(s)) {
                return true;
            }
        }
        return false;
    }
287997
public boolean isSuperset(SmallSet<E> other) {
        if (this.list.size() < other.list.size()) {
            return false;
        }
        int j = 0;
        for (int i=0; i<list.size() && j<other.list.size(); i++) {
            E e1 = this.list.get(i);
            E e2 = other.list.get(j);
            int diff = e1.compareTo(e2);
            if (diff == 0) {
                // Equal entries. Just continue.
                j++;
                continue;
            } else if (diff > 0) {
                // e1 is greater than e2, which means e2 must not appear in this.list.
                return false;
            } else {
                // e1 is less than e2, so e2 might appear later in this.list.
                continue;
            }
        }
        if (j == other.list.size()) {
            return true;
        } else {
            return false;
        }
    }
85096
protected boolean equalElements(KTypeArrayDeque<?> other) {
    int max = size();
    if (other.size() != max) {
      return false;
    }

    Iterator<KTypeCursor<KType>> i1 = this.iterator();
    Iterator<? extends KTypeCursor<?>> i2 = other.iterator();

    while (i1.hasNext() && i2.hasNext()) {
      if (!Intrinsics.equals(this, i1.next().value, i2.next().value)) {
        return false;
      }
    }

    return !i1.hasNext() && 
           !i2.hasNext();
  }
131239
def unique(self, e, **kwargs):
        
        if not isinstance(e, claripy.ast.Base):
            return True

        # if we don't want to do symbolic checks, assume symbolic variables are multivalued
        if o.SYMBOLIC not in self.state.options and self.symbolic(e):
            return False

        r = self.eval_upto(e, 2, **kwargs)
        if len(r) == 1:
            self.add(e == r[0])
            return True
        elif len(r) == 0:
            raise SimValueError("unsatness during uniqueness check(ness)")
        else:
            return False
888765
public boolean contains(T element) {
    if (element == null) { return false; }
    return comparator.compare(element, min) > -1 && comparator.compare(element, max) < 1;
  }
946818
protected boolean containsElem(int index, final T key, int hashCode) {
    for (LinkedElement<T> e = entries[index]; e != null; e = e.next) {
      // element found
      if (hashCode == e.hashCode && e.element.equals(key)) {
        return true;
      }
    }
    // element not found
    return false;
  }
1108262
public boolean contains (E e) {
		for (int i = 0; size > i; i++) {
			if (e == data[i]) {
				return true;
			}
		}
		return false;
	}
1188963
public boolean eq(IntLongSortedVector other) {
        // This is slow, but correct.
        IntLongSortedVector v1 = IntLongSortedVector.getWithNoZeroValues(this);
        IntLongSortedVector v2 = IntLongSortedVector.getWithNoZeroValues(other);
                
        if (v2.size() != v1.size()) {
            return false;
        }

        for (IntLongEntry ve : v1) {
            if (!Primitives.equals(ve.get(), v2.get(ve.index()))) {
                return false;
            }
        }
        for (IntLongEntry ve : v2) {
            if (!Primitives.equals(ve.get(), v1.get(ve.index()))) {
                return false;
            }
        }
        return true;
    }
453825
protected static boolean elementsEquals(Object e1, Object e2) {
		return (e1 == null && e2 == null) || e1.equals(e2);
	}
1327148
public static boolean areEquivalent(Coordinate l, Coordinate r)
   {
      if (l == r)
      {
         return true;
      }
      if ((l == null) && (r == null))
      {
         return true;
      }
      else if ((l == null) || (r == null))
      {
         return false;
      }

      String lPackacking = l.getPackaging() == null ? "jar" : l.getPackaging();
      String rPackaging = r.getPackaging() == null ? "jar" : r.getPackaging();

      return !(l.getArtifactId() != null ? !l.getArtifactId()
               .equals(r.getArtifactId()) : r.getArtifactId() != null)
               &&
               !(l.getGroupId() != null ? !l.getGroupId()
                        .equals(r.getGroupId()) : r.getGroupId() != null)
               &&
               !(l.getClassifier() != null ? !l.getClassifier()
                        .equals(r.getClassifier()) : r.getClassifier() != null)
               &&
               lPackacking.equals(rPackaging);
   }
981488
public static int sameTagElNums(Element e) {
        Elements els = e.parent().getElementsByTag(e.tagName());
        return els.size();
    }
875643
public final boolean contains(final int e) {
        for (int i = 0; i < size; ++i)
            if (list[i] == e) return true;
        return false;
    }
181365
public boolean contains(final T element) {
        if (element == null) {
            return false;
        }

        return lowerEndpoint.includes(element) && upperEndpoint.includes(element);
    }
230691
public final boolean getFinalUnificationValue(Map<String, List<String>> uFeatures) {
    int tokUnified = 0;
    for (int j = 0; j < tokSequence.size(); j++) {
      boolean unifiedTokensFound = false; // assume that nothing has been found
      for (int i = 0; i < tokSequenceEquivalences.get(j).size(); i++) {
        int featUnified = 0;
        if (tokSequenceEquivalences.get(j).get(i).containsKey(UNIFY_IGNORE)) {
          if (i == 0) {
            tokUnified++;
          }
          unifiedTokensFound = true;
          continue;
        } else {
          for (Map.Entry<String, List<String>> feat : uFeatures.entrySet()) {
            if (tokSequenceEquivalences.get(j).get(i).containsKey(feat.getKey()) &&
                tokSequenceEquivalences.get(j).get(i).get(feat.getKey()).isEmpty()) {
              featUnified = 0;
            } else {
              featUnified++;
            }
            if (featUnified == unificationFeats.entrySet().size() && tokUnified <= j) {
              tokUnified++;
              unifiedTokensFound = true;
              break;
            }
          }
        }

      }
      if (!unifiedTokensFound) {
        return false;
      }
    }
    if (tokUnified == tokSequence.size()) {
      return true;
    }
    return false;
  }