#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!


class Mentor:
    def __init__(self, aName):
        self._name = aName
        self._students = []

    def setName(self, aName):
        self._name = aName
        return True

    def getName(self):
        return self._name

    def getStudent(self, index):
        return self._students[index]

    def getStudents(self):
        return tuple(self._students)

    def numberOfStudents(self):
        return len(self._students)

    def hasStudents(self):
        return len(self._students) > 0

    def indexOfStudent(self, aStudent):
        return next((i for i, x in enumerate(self._students) if x is aStudent), -1)

    @staticmethod
    def minimumNumberOfStudents():
        return 0

    def addStudent(self, aStudent):
        if any(x is aStudent for x in self._students):
            return False
        self._students.append(aStudent)
        if aStudent.indexOfMentor(self) == -1 and not aStudent.addMentor(self):
            del self._students[next((i for i, x in enumerate(self._students) if x is aStudent), -1)]
            return False
        self._students.sort(key=lambda x: x.getId())
        return True

    def removeStudent(self, aStudent):
        oldIndex = next((i for i, x in enumerate(self._students) if x is aStudent), -1)
        if oldIndex == -1:
            return False
        del self._students[oldIndex]
        if aStudent.indexOfMentor(self) != -1 and not aStudent.removeMentor(self):
            self._students.insert(oldIndex, aStudent)
            return False
        return True

    def delete(self):
        copyOfStudents = tuple(self._students)
        self._students.clear()
        for aStudent in copyOfStudents:
            aStudent.removeMentor(self)

    def __str__(self):
        return (super().__str__() + "["
                + "name:" + str(self.getName())
                + "]")

#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!


class Student:
    def __init__(self, aId):
        self._id = aId
        self._mentors = []

    def setId(self, aId):
        self._id = aId
        return True

    def getId(self):
        return self._id

    def getMentor(self, index):
        return self._mentors[index]

    def getMentors(self):
        return tuple(self._mentors)

    def numberOfMentors(self):
        return len(self._mentors)

    def hasMentors(self):
        return len(self._mentors) > 0

    def indexOfMentor(self, aMentor):
        return next((i for i, x in enumerate(self._mentors) if x is aMentor), -1)

    @staticmethod
    def minimumNumberOfMentors():
        return 0

    def addMentor(self, aMentor):
        if any(x is aMentor for x in self._mentors):
            return False
        self._mentors.append(aMentor)
        if aMentor.indexOfStudent(self) == -1 and not aMentor.addStudent(self):
            del self._mentors[next((i for i, x in enumerate(self._mentors) if x is aMentor), -1)]
            return False
        self._mentors.sort(key=lambda x: x.getName())
        return True

    def removeMentor(self, aMentor):
        oldIndex = next((i for i, x in enumerate(self._mentors) if x is aMentor), -1)
        if oldIndex == -1:
            return False
        del self._mentors[oldIndex]
        if aMentor.indexOfStudent(self) != -1 and not aMentor.removeStudent(self):
            self._mentors.insert(oldIndex, aMentor)
            return False
        return True

    def delete(self):
        copyOfMentors = tuple(self._mentors)
        self._mentors.clear()
        for aMentor in copyOfMentors:
            aMentor.removeStudent(self)

    def __str__(self):
        return (super().__str__() + "["
                + "id:" + str(self.getId())
                + "]")