Compare two ItemStacks and see if their items match - take wildcards into account, don't take stacksize into account.
@param A ItemStack A
@param B ItemStack B
@return true if the stacks contain matching items.
350165
private static boolean itemStackIngredientsMatch(ItemStack A, ItemStack B)
    {
        if (A == null && B == null)
            return true;
        if (A == null || B == null)
            return false;
        if (A.getMetadata() == OreDictionary.WILDCARD_VALUE || B.getMetadata() == OreDictionary.WILDCARD_VALUE)
            return A.getItem() == B.getItem();
        return ItemStack.areItemsEqual(A, B);
    }
842983
public static boolean equalsBottomElement(final LinkedList<String> stack, final String str) {
        
        if(stack.isEmpty()) {
            return false;
        }
        
        return stack.peekLast().equals(str);
        
    }
826436
private static boolean isInBackStackAndroidX(final Fragment fragment) {
        final StringWriter writer = new StringWriter();
        fragment.dump("", null, new PrintWriter(writer), null);
        final String dump = writer.toString();
        return !dump.contains("mBackStackNesting=0");
    }
482079
public static boolean overlap(@Nullable String[] as, @Nullable String[] bs)
  {
    if (as == null || bs == null) {
      // They only have overlap if both are null.
      return as == null && bs == null;
    }
    if (as.length == 0 && bs.length == 0) {
      return true;
    }

    for (String a : as) {
      for (String b : bs) {
        if (Objects.equals(a, b)) {
          return true;
        }
      }
    }

    return false;
  }
314958
function (a, b) {
        var done = this._done,
            indexOfA,
            comparedWith;
        indexOfA = done.indexOf(a);
        while (-1 < indexOfA) {
            comparedWith = this._getPair(done, indexOfA);
            if (comparedWith === b) {
                return false; // Already compared
            }
            indexOfA = done.indexOf(a, indexOfA + 1);
        }
        return true;
    }
87244
public boolean matches(ESigItem item) {
        if (selected != null && item.isSelected() != selected) {
            return false;
        }
        
        if (eSigType != null && !item.getESigType().equals(eSigType)) {
            return false;
        }
        
        if (session != null && !item.getSession().equals(session)) {
            return false;
        }
        
        if (ids != null && !ids.contains(item.getId())) {
            return false;
        }
        
        return true;
    }
59168
private static boolean deepEquals(byte[] a, byte[] b) {
        return a == b || !(a == null || b == null) && Arrays.equals(a, b);
    }
886344
public static boolean equalsAnyTopElement(final LinkedList<String> stack, final String[] strs) {
        
        ArgUtils.notNull(stack, "stack");
        ArgUtils.notEmpty(strs, "strs");
        
        if(stack.isEmpty()) {
            return false;
        }
        
        final String top = stack.peekFirst();
        for(String str : strs) {
            if(str.equals(top)) {
                return true;
            }
        }
        
        return false;
        
    }
275693
def matches(self, a, b, **config):
        
        package_a = self.processor._u2p(a['msg']['update']['title'])[0]
        package_b = self.processor._u2p(b['msg']['update']['title'])[0]
        if package_a != package_b:
            return False
        return True
566905
public boolean contains(T transaction, I item) {
		int t = transactionToIndex(transaction);
		if (t < 0)
			return false;
		int i = itemToIndex(item);
		if (i < 0)
			return false;
		return matrix.contains(t, i);
	}
144212
public boolean isMatchingAny() {
        if (this.levels == null) {
            return false;
        }
        int i = 0;
        int n = this.levelCounter;
        while (n-- != 0) {
            if (this.levels[i].isSelectionActive()) {
                return true;
            }
            i++;
        }
        return false;
    }
43484
public static <T> boolean compareLists(List<T> list1, List<T> list2) {
        if (list1 == list2)
            return true;
        if (list1 == null || list2 == null)
            return false;
        if (list1.size() != list2.size())
            return false;

        for (int i = 0; i < list1.size(); i++) {
            if (!list1.get(i).equals(list2.get(i))) {
                return false;
            }
        }
        return true;
    }
682789
@Override
    public final boolean matches(Object item, Description mismatch) {
        if (matches(item)) {
            return true;
        } else {
            describeMismatch(item, mismatch);
            return false;
        }
    }
730123
public static  boolean equalsTopElement(final LinkedList<String> stack, final String str) {
        
        if(stack.isEmpty()) {
            return false;
        }
        
        return stack.peekFirst().equals(str);
        
    }
878859
function (other) {
        assertNotNull(other);

        var c = collectionCount(other);

        if (c !== -1) {
            if (this.count() === 0) {
                return c > 0;
            }

            // faster if other is a hashset (and we're using same equality comparer)
            else if (areEqualityComparersEqual(this, other)) {
                if (this.count() >= c) {
                    return false;
                }

                // this has strictly less than number of items in other, so the following
                // check suffices for proper subset.
                else {
                    return containsAllElements(other, this);
                }
            }
        }

        var result = checkUniqueAndUnfoundElements(this, other, false);
        return (result.uniqueCount === this.count() && result.unfoundCount > 0);
    }
313569
public static boolean arrayEquals(List<String> a, List<String> b) {
        if (a == null) {
            a = new ArrayList<>();
        }
        if (b == null) {
            b = new ArrayList<>();
        }
        if (a.size() != b.size()) {
            return false;
        }

        for (int i = 0; i < a.size(); i ++) {
            if (!a.get(i).equals(b.get(i))) {
                return false;
            }
        }
        return true;
    }
934496
public static final <T> boolean containsOnly(short[] array, T... items)
    {
        for (short b : array)
        {
            if (!contains(items, b))
            {
                return false;
            }
        }
        return true;
    }