


SCREAMING_SNAKE_CASE			: Optional[Any]				   =					tuple[float, float, float]
SCREAMING_SNAKE_CASE			: int				   =					tuple[float, float, float]



def 							UpperCamelCase_( lowerCamelCase_				,					lowerCamelCase_					)       ->		Vectorad:
    _lowercase			:				int 						=						end_pointa[0] - end_pointa[0]
    _lowercase			:				List[Any] 						=						end_pointa[1] - end_pointa[1]
    _lowercase			:				Optional[int] 						=						end_pointa[2] - end_pointa[2]
    return (x, y, z)



def 							UpperCamelCase_( lowerCamelCase_				,					lowerCamelCase_					)       ->		Vectorad:
    _lowercase			:				Optional[int] 						=						ab[1] * ac[2] - ab[2] * ac[1]  # *i
    _lowercase			:				Dict 						=						(ab[0] * ac[2] - ab[2] * ac[0]) * -1  # *j
    _lowercase			:				Tuple 						=						ab[0] * ac[1] - ab[1] * ac[0]  # *k
    return (x, y, z)



def 							UpperCamelCase_( lowerCamelCase_				,					lowerCamelCase_					)       ->		bool:
    return tuple(round(lowerCamelCase_				,					lowerCamelCase_					) for x in vector					) == (0, 0, 0)



def 							UpperCamelCase_( lowerCamelCase_				,					lowerCamelCase_				,					lowerCamelCase_				,					lowerCamelCase_ = 10					)       ->		bool:
    _lowercase			:				int 						=						create_vector(lowerCamelCase_				,					lowerCamelCase_					)
    _lowercase			:				Any 						=						create_vector(lowerCamelCase_				,					lowerCamelCase_					)
    return is_zero_vector(get_ad_vectors_cross(lowerCamelCase_				,					lowerCamelCase_					)				,					lowerCamelCase_					)






class     __UpperCAmelCase							:


     """simple docstring"""


     def __init__(	self  ,       __A    ):
        __a					=  set_counts
        __a					=  max(__A    )
        __a					=  len(__A    )
        __a					=  [1] * num_sets
        __a					=  list(range(__A    )    )


     def 	snake_case_  (	self  ,       __A  ,       __A    ):
        __a					=  self.get_parent(__A    )
        __a					=  self.get_parent(__A    )

        if src_parent == dst_parent:
           return False

        if self.ranks[dst_parent] >= self.ranks[src_parent]:
           self.set_counts[dst_parent] += self.set_counts[src_parent]
           __a					=  0
           __a					=  dst_parent
           if self.ranks[dst_parent] == self.ranks[src_parent]:
              self.ranks[dst_parent] += 1
           __a					=  self.set_counts[dst_parent]
        else:
           self.set_counts[src_parent] += self.set_counts[dst_parent]
           __a					=  0
           __a					=  src_parent
           __a					=  self.set_counts[src_parent]

        __a					=  max(self.max_set  ,       __A    )
        return True


     def 	snake_case_  (	self  ,       __A    ):
        if self.parents[disj_set] == disj_set:
           return disj_set
        __a					=  self.get_parent(self.parents[disj_set]    )
        return self.parents[disj_set]



