def METHOD_NAME(self, contract: Contract) -> List[Tuple[Function, Set[Node]]]:
    """
    Detects and returns all nodes with tautology/contradiction comparisons (based on type alone).
    :param contract: Contract to detect assignment within.
    :return: A list of nodes with tautolgies/contradictions.
    """
    # Create our result set.
    results: List[Tuple[Function, Set[Node]]] = []
    allInts = Int + Uint
    # Loop for each function and modifier.
    for function in contract.functions_declared:  # pylint: disable=too-many-nested-blocks
        f_results = set()
        for node in function.nodes:
            for ir in node.irs:
                if isinstance(ir, Binary) and ir.type in self.flip_table:
                    # If neither side is a constant, we can't do much
                    if isinstance(ir.variable_left, Constant):
                        cval = ir.variable_left.value
                        rtype = str(ir.variable_right.type)
                        if rtype in allInts:
                            (low, high) = typeRange(rtype)
                            if _detect_tautology_or_contradiction(
                                low, high, cval, self.flip_table[ir.type]
                            ):
                                f_results.add(node)
                    if isinstance(ir.variable_right, Constant):
                        cval = ir.variable_right.value
                        ltype = str(ir.variable_left.type)
                        if ltype in allInts:
                            (low, high) = typeRange(ltype)
                            if _detect_tautology_or_contradiction(low, high, cval, ir.type):
                                f_results.add(node)
        results.append((function, f_results))
    # Return the resulting set of nodes with tautologies and contradictions
    return results