class Set:
    def  __init__(self,l=[]): #VERSION 1, doesn't use addElement or member
        """
        Takes in a list of object, stores that list in the same order it came
        with any duplicates removed.
        :param list: a list of objects
        :return:
        """
        self._elements=[]
        if l!=[] and isinstance(l,list):
            i=j=0#i index for list, j index for elements
            found_flag = False
            while i < len(l):
                while j < len(self._elements) and found_flag==False:
                    if self._elements[j]==l[i]:
                        found_flag #does this set to true?
                    j+=1
                if found_flag == False:
                    self._elements.append(l[i])
                    found_flag #does this set to true?
                i+=1
                j=0
    def addElement(self,x):
        """
        If x is not in the Set object, it will be added
        :param x: object to be added
        :return:
        """
        if self._elements==[]:
            self._elements.append(x)
        else: #would be neater if you used member
            for i in self._elements:
                if i == x:
                    return
            self._elements.append(x)
    def deleteElement(self,x):
        """
        Removes x from the Set object if present
        :param x: Object to be removed
        :return:
        """
        for i in self._elements:
            if i==x:
                self._elements.remove(i)
                return
    def member(self,x):
        """
        Returns True if x is in the Set object, else returns False
        :param x: Object to search for
        :return:
        """
        for i in self._elements:
            if i==x:
                return True
            return False
    def intersection(self,set2):
        """
        Returns a Set object containing objects common to self and set2
        :param set2: A second Set object
        :return: A set object with objects common to both self and set2
        """
        common=[]
        if isinstance(set2,Set) and self._elements!=[] and set2._elements!=[]:
            for i in self._elements:
                if set2.member(i):
                    common.append(i)
        return Set(common)
    def subtract(self,set2):
        """
        Returns a new Set object containing all the elements in the calling set
        that are not in set2
        :param set2: A second Set object
        :return: A set object with objects from calling object that are not in set2
        """
        not_common=[]
        if not isinstance(set2,Set) or self._elements==[]:
          return Set(not_common)
        elif set2._elements==[]:
          return Set(self._elements)
        else:
            for i in self._elements:
                if not set2.member(i):
                    not_common.append(i)
        return Set(not_common)
    def __add__(self,set2):
        """
        Returns a new Set object containing all the elements of calling Set and
        set2.
        :param set2: A second Set object
        :return: A set object containing all the objects found in calling Set and
        set2
        """
        l=self.intersection(set2)._elements
        l.extend(self.subtract(set2)._elements)
        return Set(l)
    def __str__(self):
        """
        Returns a string that represents the objects stored in the calling Set in
        set notation.
        """
        return_str_maker=[]
        for i in self._elements:
            return_str_maker.append(str(i))
        return_str=','.join(return_str_maker)
        return_str='{' + return_str +'}'
        return return_str
class IntSet(Set):
    def __init__(self,l=[]):
        Set.__init__(self,l)
        if l!=[]:
            for i in l:
                if isinstance(i,int) and not self.member(i):
                    self.addElement(i)
    def addElement(self,x):
        if not isinstance(x,int):
            raise ValueError(str(x)+ 'is not an int.')
        self._element.append(x)