




from math import sqrt




def        __SCREAMING_SNAKE_CASE (	lowercase_   )							->						list[int]:

    """simple docstring"""


    __UpperCamelCase			=    [1]
    for i in range(2       ,  int(sqrt(lowercase_   )   ) + 1       ,  1   ):
        if number % i == 0:
            values.append(lowercase_   )
            if int(number // i   ) != i:
                values.append(int(number // i   )   )
    return sorted(lowercase_   )




def        __SCREAMING_SNAKE_CASE (	lowercase_   )							->						bool:

    """simple docstring"""


    return sum(factors(lowercase_   )   ) > n




def        __SCREAMING_SNAKE_CASE (	lowercase_   )							->						bool:

    """simple docstring"""


    __UpperCamelCase			=    factors(lowercase_   )
    __UpperCamelCase			=    len(lowercase_   )
    __UpperCamelCase			=    [[0 for i in range(number + 1   )] for j in range(r + 1   )]
    for i in range(r + 1   ):
        __UpperCamelCase			=    True

    for i in range(1       ,  number + 1   ):
        __UpperCamelCase			=    False

    for i in range(1       ,  r + 1   ):
        for j in range(1       ,  number + 1   ):
            if j < values[i - 1]:
                __UpperCamelCase			=    subset[i - 1][j]
            else:
                __UpperCamelCase			=    subset[i - 1][j] or subset[i - 1][j - values[i - 1]]

    return subset[r][number] != 0




def        __SCREAMING_SNAKE_CASE (	lowercase_   )							->						bool:

    """simple docstring"""


    return abundant(lowercase_   ) and not semi_perfect(lowercase_   )


if __name__ == "__main__":
 import doctest

 doctest.testmod(verbose=True)
 for number in (69, 70, 71):
  print(f"""{number} is {'' if weird(number) else 'not '}weird.""")












class 			_lowerCamelCase    :

      """simple docstring"""

      def __init__(  self       :			Optional[Any]			,							snake_case       :			int					):
          __UpperCamelCase			=    data
          __UpperCamelCase			=    42
          __UpperCamelCase			=    42







def        __SCREAMING_SNAKE_CASE (	lowercase_   )							->						None:

    """simple docstring"""


    __UpperCamelCase			=    0
    __UpperCamelCase			=    x




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_   )							->						None:

    """simple docstring"""


    __UpperCamelCase		,   __UpperCamelCase			=    find_set(lowercase_   ), find_set(lowercase_   )
    if x == y:
        return

    elif x.rank > y.rank:
        __UpperCamelCase			=    x
    else:
        __UpperCamelCase			=    y
        if x.rank == y.rank:
            y.rank += 1




def        __SCREAMING_SNAKE_CASE (	lowercase_   )							->						Node:

    """simple docstring"""


    if x != x.parent:
        __UpperCamelCase			=    find_set(x.parent   )
    return x.parent




def        __SCREAMING_SNAKE_CASE (	lowercase_   )							->						set:

    """simple docstring"""


    __UpperCamelCase			=    ({0, 1, 2}, {3, 4, 5})
    for s in sets:
        if node.data in s:
            return s
    __UpperCamelCase			=    F"{node.data} is not in {sets}"
    raise ValueError(lowercase_   )




def        __SCREAMING_SNAKE_CASE (	)							->						None:

    """simple docstring"""


    __UpperCamelCase			=    [Node(lowercase_   ) for i in range(6   )]
    for v in vertex:
        make_set(lowercase_   )

    union_set(vertex[0]       ,  vertex[1]   )
    union_set(vertex[1]       ,  vertex[2]   )
    union_set(vertex[3]       ,  vertex[4]   )
    union_set(vertex[3]       ,  vertex[5]   )

    for nodea in vertex:
        for nodea in vertex:
            if find_python_set(lowercase_   ).isdisjoint(find_python_set(lowercase_   )   ):
                assert find_set(lowercase_   ) != find_set(lowercase_   )
            else:
                assert find_set(lowercase_   ) == find_set(lowercase_   )


if __name__ == "__main__":
 test_disjoint_set()






