def unique_day(day, possible_birthdays):
    counter=0
    for birthday in possible_birthdays:
        if day==birthday[1]:
            counter+=1
        else:
            continue
    if counter==1:
        return True
    else:
        return False
def unique_month(month, possible_birthdays):
    counter=0
    for birthday in possible_birthdays:
        if month==birthday[0]:
            counter+=1
        else:
            continue
    if counter==1:
        return True
    else:
        return False
def filter_1(pred,seq):
    if seq==():
        return ()
    elif pred(seq[0]):
        return (seq[0],) + filter_1(pred,seq[1:])
    else:
        return filter_1(pred,seq[1:])

def contains_unique_day(month, possible_birthdays):
    month_dates=filter_1(lambda x:True if x[0]==month else False, possible_birthdays)
    for date in month_dates:
        if unique_day(date[1],possible_birthdays):
            return True
        else:
            continue
    else:
        return False


def unique_day(day, possible_birthdays):

    count=0

    for i in possible_birthdays:

        if day == i[1]:

            count+=1

        else:

            continue

    if count==1:

        return True

    else:

        return False

def unique_month(month, possible_birthdays):

    count=0

    for i in possible_birthdays:

        if month == i[0]:

            count+=1

        else:

            continue

    if count==1:

        return True

    else:

        return False

def contains_unique_day(month, possible_birthdays):

    for i in possible_birthdays:

        if i[0]==month:

            if unique_day(i[1],possible_birthdays):

                return True

    return False

tuple_of_possible_birthdays = (('May', '15'),
                              ('May', '16'),
                              ('May', '19'),
                              ('June', '17'),
                              ('June', '18'),
                              ('July', '14'),
                              ('July', '16'),
                              ('August', '14'),
                              ('August', '15'),
                              ('August', '17'))

assert unique_day("1", (("January","1"),("February","1")))==False and unique_month("January", (("January","1"),("January","2")))==False and unique_month("January", (("January","1"),("February","1")))==True and contains_unique_day("January", (("January","1"),("January","2")))==True and contains_unique_day("January", (("January","1"),("February","1")))==False and contains_unique_day("February", (("January","10"),("February","1"),("February","10")))==True and unique_day("3", (("January","1"),("January","2")))==False and unique_month("March", (("January","1"),("February","1")))==False and unique_day("1", (("January","1"),("January","2")))==True and unique_day("16", tuple_of_possible_birthdays)==False and unique_day("17", tuple_of_possible_birthdays)==False and unique_day("18", tuple_of_possible_birthdays)==True and unique_day("19", tuple_of_possible_birthdays)==True and unique_month("May", tuple_of_possible_birthdays)==False and unique_month("June", tuple_of_possible_birthdays)==False and contains_unique_day("June", tuple_of_possible_birthdays)==True and contains_unique_day("July", tuple_of_possible_birthdays)==False

Task: Unique dates and months

Implement unique_day, unique_month and contains_unique_day.


def unique_day(day, possible_birthdays):
    a = 0
    for item in possible_birthdays:
        for i in item:
            if i == day:
                a += 1
    if a == 1:
        return True
    else:
        return False
def unique_month(month, possible_birthdays):
    a = 0
    for item in possible_birthdays:
        for i in item:
            if i == month:
                a += 1
    if a == 1:
        return True
    else:
        return False
def contains_unique_day(month, possible_birthdays):
    a = 0
    b = 0
    for item in possible_birthdays:
        if month in item:
            a = item
            if unique_day(item[1],possible_birthdays) == True:
                b += 1
    if b >= 1:
        return True
    else:
        return False


def unique_day(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if date == i[1]:
            count += 1
    return count == 1
def unique_month(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if month == i[0]:
            count += 1
    return count == 1
def contains_unique_day(month, possible_birthdays):
    days = ()
    for i in possible_birthdays:
        if month == i[0]:
            days += (i[1],)
    for i in days:
        if unique_day(i, possible_birthdays):
            return True

    return False


def unique_day(day, possible_birthdays):
    counter=0
    for i in possible_birthdays:
        if i[1]==day:
            counter+=1
    return counter==1

def unique_month(month, possible_birthdays):
    counter=0
    for i in possible_birthdays:
        if i[0]==month:
            counter+=1
    return counter==1

def contains_unique_day(month, possible_birthdays):
    value=()
    for i in possible_birthdays:
        if i[0]==month:
            value+=(i,)
    for i in value:
        if unique_day(i[1],possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    counter = 0
    for ele in possible_birthdays:
        birthday = ele[1]
        if birthday == day:
            counter += 1
    if counter == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    counter = 0
    for ele in possible_birthdays:
        birthmonth = ele[0]
        if birthmonth == month:
            counter += 1
    if counter == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for ele in possible_birthdays:
        birthmonth = ele[0]
        if birthmonth == month:
            if unique_day(ele[1], possible_birthdays) == True:
                return True
    return False


def unique_day(day, possible_birthdays):
    a=0
    for i in range(len(possible_birthdays)):
        if day==possible_birthdays[i][1]:
            a+=1
    if a==1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    b=0
    for i in range(len(possible_birthdays)):
        if month==possible_birthdays[i][0]:
            b+=unique_day(possible_birthdays[i][1],possible_birthdays)
    if b==0:
        return False
    else:
        return True

def unique_month(month, possible_birthdays):
    a=0
    for i in range(len(possible_birthdays)):
        if month==possible_birthdays[i][0]:
            a+=1
    if a==1:
        return True
    else:
        return False


def unique_day(day, possible_birthdays):
    for i in range (len(possible_birthdays)):
        if possible_birthdays[i][1] == day:
            for j in range (i + 1, len(possible_birthdays)):
                if possible_birthdays[j][1] == day:
                    return False
    return True
def unique_month(month, possible_birthdays):
    for i in range (len(possible_birthdays)):
        if possible_birthdays[i][0] == month:
            for j in range (i + 1, len(possible_birthdays)):
                if possible_birthdays[j][0] == month:
                    return False
    return True
def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if i[0] == month:
            if unique_day(i[1], possible_birthdays):
                return True
    return False


def unique_day(day, possible_birthdays):
    num=0
    for i in possible_birthdays:
        if day==i[1]:
            num+=1
    return num==1

def unique_month(month, possible_birthdays):
    num=0
    for i in possible_birthdays:
        if month==i[0]:
            num+=1
    return num==1

def contains_unique_day(month, possible_birthdays):
    days=()
    for i in possible_birthdays:
        if month==i[0]:
            if unique_day(i[1],possible_birthdays):
                days = days + (i[1],)
    return len(days)==1


def unique_day(date, possible_birthdays):
    count = 0
    for birthday in possible_birthdays:
        if birthday[1] == day:
            count += 1
    return count == 1

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(date, possible_birthdays):
    count = 0
    for birthday in possible_birthdays:
        if birthday[1] == day:
            count += 1
    return count == 1

def unique_month(month, possible_birthdays):
    count = 0
    for birthday in possible_birthdays:
        if birthday[0] == month:
            count += 1
    return count == 1

def contains_unique_day(month, possible_birthdays):
    for birthday in possible_birthdays:
        if birthday[0] == month:
            if unique_day(birthday[1], possible_birthdays):
                return True
    return False


def unique_day(date, possible_birthdays):

    days = 0

    for i in range(len(possible_birthdays)):
        if possible_birthdays[i][1] == days:
            day = day + 1

    if days == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):

    month = 0

    for i in range(len(possible_birthdays)):
        if possible_birthdays[i][0] == days:
            day = day + 1

    if days == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):

    x = ()

    for i in range(len(possible_birthdays)):

        if possible_birthdays[i][0] == month:

            x = x + (possible_birthdays[i],)
    for j in range(len(x)):
        if unique_day(x[j][1], possible_birthdays):
            return True
        else:
            continue
    return False


def unique_day(date, possible_birthdays):

    days = 0

    for i in range(len(possible_birthdays)):
        if possible_birthdays[i][1] == days:
            day = day + 1

    if days == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):

    month = 0

    for i in range(len(possible_birthdays)):
        if possible_birthdays[i][0] == month:
            day = day + 1

    if days == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):

    x = ()

    for i in range(len(possible_birthdays)):

        if possible_birthdays[i][0] == month:

            x = x + (possible_birthdays[i],)
    for j in range(len(x)):
        if unique_day(x[j][1], possible_birthdays):
            return True
        else:
            continue
    return False


def unique_day(date, possible_birthdays):

    days = 0

    for i in range(len(possible_birthdays)):
        if possible_birthdays[i][1] == days:
            day = day + 1

    if days == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):

    months = 0

    for i in range(len(possible_birthdays)):
        if possible_birthdays[i][0] == month:
            months = months + 1

    if months == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):

    x = ()

    for i in range(len(possible_birthdays)):

        if possible_birthdays[i][0] == month:

            x = x + (possible_birthdays[i],)
    for j in range(len(x)):
        if unique_day(x[j][1], possible_birthdays):
            return True
        else:
            continue
    return False


def unique_day(date, possible_birthdays):

    days = 0

    for i in range(len(possible_birthdays)):
        if possible_birthdays[i][1] == days:
            day = day + 1

    if days == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):

    months = 0
    for i in range(len(possible_birthdays)):

        if possible_birthdays[i][0] == month:
            months = months + 1
    if months == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):

    x = ()

    for i in range(len(possible_birthdays)):

        if possible_birthdays[i][0] == month:

            x = x + (possible_birthdays[i],)
    for j in range(len(x)):
        if unique_day(x[j][1], possible_birthdays):
            return True
        else:
            continue
    return False


def unique_day(date, possible_birthdays):

    days = 0

    for i in range(len(possible_birthdays)):
        if possible_birthdays[i][1] == day:
            days = days + 1

    if days == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):

    months = 0
    for i in range(len(possible_birthdays)):

        if possible_birthdays[i][0] == month:
            months = months + 1
    if months == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):

    x = ()

    for i in range(len(possible_birthdays)):

        if possible_birthdays[i][0] == month:

            x = x + (possible_birthdays[i],)
    for j in range(len(x)):
        if unique_day(x[j][1], possible_birthdays):
            return True
        else:
            continue
    return False


def unique_day(date, possible_birthdays):

    days = 0

    for i in range(len(possible_birthdays)):
        if possible_birthdays[i][1] == day:
            days = days + 1

    if days == 1:
        return True
    else:
        return False

    count = 0
    for i in range(len(possible_birthdays)):
        if possible_birthdays[i][1] == day:
            count += 1
    if count == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):

    months = 0
    for i in range(len(possible_birthdays)):

        if possible_birthdays[i][0] == month:
            months = months + 1
    if months == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):

    x = ()

    for i in range(len(possible_birthdays)):

        if possible_birthdays[i][0] == month:

            x = x + (possible_birthdays[i],)
    for j in range(len(x)):
        if unique_day(x[j][1], possible_birthdays):
            return True
        else:
            continue
    return False


def unique_day(date, possible_birthdays):
    count = 0
    for i in range(len(possible_birthdays)):
        if possible_birthdays[i][1] == day:
            count += 1
    if count == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):

    months = 0
    for i in range(len(possible_birthdays)):

        if possible_birthdays[i][0] == month:
            months = months + 1
    if months == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):

    x = ()

    for i in range(len(possible_birthdays)):

        if possible_birthdays[i][0] == month:

            x = x + (possible_birthdays[i],)
    for j in range(len(x)):
        if unique_day(x[j][1], possible_birthdays):
            return True
        else:
            continue
    return False


def unique_day(date, possible_birthdays):

    days = 0

    for i in range(len(possible_birthdays)):
        if possible_birthdays[i][1] == day:
            days = days + 1

    if days == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):

    months = 0
    for j in range(len(possible_birthdays)):

        if possible_birthdays[j][0] == month:
            months = months + 1
    if months == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):

    x = ()

    for k in range(len(possible_birthdays)):

        if possible_birthdays[k][0] == month:

            x = x + (possible_birthdays[k],)

    for l in range(len(x)):
        if unique_day(x[l][1], possible_birthdays):
            return True
        else:
            continue
    return False


def map(fn, seq):
    res = ()

    for ele in seq:
        res = res + (fn(ele), )
    return res

def unique_day(day, possible_birthdays):
    days = map(lambda x: x[1], possible_birthdays)
    times = 0
    for i in days:
        if i==day:
            times = times+1
        else:
            continue
    if times>1:
        return False
    else:
        return True

def unique_month(month, possible_birthdays):
    months = map(lambda x: x[0], possible_birthdays)
    times = 0
    for i in months:
        if i==month:
            times = times+1
        else:
            continue
    if times>1:
        return False
    else:
        return True

def filter(pred, seq):
    res = ()

    for ele in seq:
        if pred(ele):
            res = res + (ele, )
    return res

def contains_unique_day(month, possible_birthdays):
    relevant_dates= filter(lambda x: x[0] == month, possible_birthdays)
    days = map(lambda x: x[1], relevant_dates)
    times = 0
    for i in days:
        if unique_day(i, possible_birthdays):
            times = times+1
        else:
            continue
    if times==0:
        return False
    else:
        return True


def unique_day(day, possible_birthdays):
    count_day = 0
    for birthday in possible_birthdays:
        if day == birthday[1]:
            if count_day == 0: count_day += 1
            else: return False
    return True

def unique_month(month, possible_birthdays):
    count_month = 0
    for birthday in possible_birthdays:
        if month == birthday[0]:
            if count_month == 0: count_month += 1
            else: return False
    return True

def contains_unique_day(month, possible_birthdays):
    for birthday in possible_birthdays:
        if month == birthday[0]:
            day = birthday[1]
            if unique_day(day, possible_birthdays): return True
    return False


def unique_day(date, possible_birthdays):

    count =0

    for i in possible_birthdays:

        if date==i[1]:

            count+=1

    return count==1

def unique_month(month, possible_birthdays):

    count =0

    for i in possible_birthdays:

        if month==i[0]:

            count+=1

    return count==1

def contains_unique_day(month, possible_birthdays):

    daysinmonth=()

    count=0

    for i in possible_birthdays:

        if month==i[0]:

            daysinmonth+=(i[1],)

    for i in daysinmonth:

        if unique_day(i,possible_birthdays):
            count+=1

    return count==1


def unique_day(day, possible_birthdays):
    possible_days = tuple(map(lambda x: x[1], possible_birthdays))
    counter = 0
    for possible_day in possible_days:
        if day == possible_day:
            counter = counter + 1
    if counter == 1:
        return True
    elif counter > 1:
        return False
    else:
        return "Not a day in possible_birthdays"

def unique_month(month, possible_birthdays):
    possible_months = tuple(map(lambda x: x[0], possible_birthdays))
    counter = 0
    for possible_month in possible_months:
        if month == possible_month:
            counter = counter + 1
    if counter == 1:
        return True
    elif counter > 1:
        return False
    else:
        return "Not a month in possible_birthdays"

def contains_unique_day(month, possible_birthdays):
    def contains_month(month, elem):
        return month == elem[0]
    pos_bd_containing_month = tuple(filter(lambda x: contains_month(month, x), possible_birthdays))
    for element in pos_bd_containing_month:
        if unique_day(element[1], possible_birthdays) == True:
            return True
    return False


def unique_day(day, possible_birthdays):
    index = 1
    for days in tuple(map(lambda x:x[1], possible_birthdays)):
        if day == days:
            index = index*(-1)
            if index == 1:
                return False
    return True

def unique_month(month, possible_birthdays):
    index = 1
    for months in tuple(map(lambda x:x[0], possible_birthdays)):
        if month == months:
            index = index*(-1)
            if index == 1:
                return False
    return True

def contains_unique_day(month, possible_birthdays):
    birthday_list = tuple(filter(lambda x: x[0] == month, possible_birthdays))
    for i in tuple(map(lambda x: x[1], birthday_list)):
        if unique_day(i,possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    count = 0
    for birthdays in possible_birthdays:
        if birthdays[1] == day:
            count +=1
            if count == 2:
                return False
    return True

def unique_month(month, possible_birthdays):
    count = 0
    for birthdays in possible_birthdays:
        if birthdays[0] == month:
            count +=1
            if count == 2:
                return False
    return True

def contains_unique_day(month, possible_birthdays):
    count = ()
    for birthdays in possible_birthdays:
        if birthdays[0] == month:
            count += (birthdays,)
    for sub_birthday in count:
        if unique_day(sub_birthday[1], possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    checker = []
    for bday in possible_birthdays:
        if day == bday[1] and day not in checker:
            checker.append(day)
        elif day == bday[1] and day in checker:
            return False
    return True

def unique_month(month, possible_birthdays):
    checker = []
    for bday in possible_birthdays:
        if month == bday[0] and month not in checker:
            checker.append(month)
        elif month == bday[0] and month in checker:
            return False
    return True

def contains_unique_day(month, possible_birthdays):
    for bday in possible_birthdays:
        if bday[0] == month:
            if unique_day(bday[1], possible_birthdays) == True:
                return True
    return False


def unique_day(day, possible_birthdays):
    birthday_with_day = list(filter(lambda birthday: birthday[1] == day \
                                 , possible_birthdays))
    if len(birthday_with_day) >= 2:
        return False
    return True

def unique_month(month, possible_birthdays):
    birthday_with_month = list(filter(lambda birthday: birthday[0] == month \
                                 , possible_birthdays))
    if len(birthday_with_month) >= 2:
        return False
    return True

def contains_unique_day(month, possible_birthdays):
    birthday_with_month = list(filter(lambda birthday: birthday[0] == month \
                                 , possible_birthdays))
    birthday_day = list(map(lambda birthday: birthday[1], birthday_with_month))
    unique_day_list = list(filter(lambda day: unique_day(day, possible_birthdays)\
                                  , birthday_day))
    return len(unique_day_list) > 0


def unique_day(date, possible_birthdays):
    flag = 0
    for i in possible_birthdays:
        if i[1] == day:
            flag += 1

    return True if flag == 1 else False

def unique_month(month, possible_birthdays):
    flag = 0
    for i in possible_birthdays:
        if i[0] == month:
            flag += 1

    return True if flag == 1 else False

def contains_unique_day(month, possible_birthdays):
    flag = 0
    unique_days = []

    for i in possible_birthdays:
        if i[1] not in unique_days:
            unique_days.append(i[1])
        else:
            unique_days.remove(i[1])

    for i in possible_birthdays:
        if i[0] == month and i[1] in unique_days:
            return True

    return False


def unique_day(date, possible_birthdays):
    tpl = ()
    for i in possible_birthdays:
        tpl += (i[1],)
    if tpl.count(date) > 1:
        return False
    return True

def unique_month(month, possible_birthdays):
    tpl = ()
    for j in possible_birthdays:
        tpl += (j[0],)
    if tpl.count(month) > 1:
        return False
    return True

def contains_unique_day(month, possible_birthdays):
    tpl = ()
    for k in possible_birthdays:
        if k[0] == month:
            tpl += (k[1],)
    for l in tpl:
        if unique_day(l, possible_birthdays) == True:
            return True
    return False


def unique_day(date, possible_birthdays):
    tpl = ()
    for i in possible_birthdays:
        tpl += (i[1],)
    if tpl.count(date) > 1:
        return False
    return True

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(date, possible_birthdays):
    tpl = ()
    for i in possible_birthdays:
        tpl += (i[1],)
    if tpl.count(date) > 1:
        return False
    return True

def unique_month(month, possible_birthdays):
    tpl = ()
    for j in possible_birthdays:
        tpl += (i[0],)
    if tpl.count(month) > 1:
        return False
    return True

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(date, possible_birthdays):
    tpl = ()
    for i in possible_birthdays:
        tpl += (i[1],)
    if tpl.count(date) > 1:
        return False
    return True

def unique_month(month, possible_birthdays):
    tpl = ()
    for j in possible_birthdays:
        tpl += (j[0],)
    if tpl.count(month) > 1:
        return False
    return True

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(day, possible_birthdays):
    a=''
    for date in possible_birthdays:
        if a== date[1]:
            return False
        elif day ==date[1]:
            a=day

    return True

def unique_month(month, possible_birthdays):
    a=''
    for date in possible_birthdays:
        if a== date[0]:
            return False
        elif month ==date[0]:
            a=month

    return True

def contains_unique_day(month, possible_birthdays):
    for date in possible_birthdays:
        if month==date[0]:
            if unique_day(date[1], possible_birthdays):
                return True
    return False


def unique_day(date, possible_birthdays):
    tup = ()
    for i in possible_birthdays:
        if i[1] == day:
            tup += (i[1],)
    if len(tup) == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    tup = ()
    for i in possible_birthdays:
        if i[0] == month:
            tup += (i[0],)
    if len(tup) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    tup = ()
    for date in possible_birthdays:
        if date[0] == month:
            tup += (date,)
    for bday in tup:
        if unique_day(bday[1], possible_birthdays):
            return True
    return False


def unique_day(date, possible_birthdays):
    tup = ()
    for i in possible_birthdays:
        if i[1] == day:
            tup += (i[1],)
    if len(tup) == 1:
        return True
    elif len(tup) > 1:
        return False
    elif len(tup) == 0:
        return None

def unique_month(month, possible_birthdays):
    tup = ()
    for i in possible_birthdays:
        if i[0] == month:
            tup += (i[0],)
    if len(tup) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    tup = ()
    for date in possible_birthdays:
        if date[0] == month:
            tup += (date,)
    for bday in tup:
        if unique_day(bday[1], possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    tup = ()
    for i in possible_birthdays:
        if i[1] == day:
            tup += (i[1],)
    if len(tup) == 1:
        return True
    elif len(tup) > 1:
        return False
    elif len(tup) == 0:
        return None

def unique_month(month, possible_birthdays):
    tup = ()
    for i in possible_birthdays:
        if i[0] == month:
            tup += (i[0],)
    if len(tup) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    tup = ()
    for date in possible_birthdays:
        if date[0] == month:
            tup += (date,)
    for bday in tup:
        if unique_day(bday[1], possible_birthdays):
            return True
    return False


def unique_day(date, possible_birthdays):
    num = 0
    for birthday in possible_birthdays:
        if day == birthday[1]:
            num += 1
    return num == 1

def unique_month(month, possible_birthdays):
    num = 0
    for birthday in possible_birthdays:
        if month == birthday[0]:
            num += 1
    return num == 1

def contains_unique_day(month, possible_birthdays):
    for birthday in possible_birthdays:
        if month == birthday[0]:
            if unique_day(birthday[1], possible_birthdays):
                return True
    return False


def unique_day(day, possible_birthdays):
    days = ()
    for birthdays in possible_birthdays:
        days += (birthdays[1],)
    a = 0
    for dates in days:
        if day == dates:
            a +=1
    if a !=1:
        return False
    return True

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(day, possible_birthdays):
    days = ()
    for birthdays in possible_birthdays:
        days += (birthdays[1],)
    a = 0
    for dates in days:
        if day == dates:
            a +=1
    if a !=1:
        return False
    return True

def unique_month(month, possible_birthdays):
    months = ()
    for birthdays in possible_birthdays:
        months += (birthdays[0],)
    a = 0
    for dates in months:
        if month == dates:
            a +=1
    if a !=1:
        return False
    return True

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(day, possible_birthdays):

    count=0
    for birthday in possible_birthdays:
        if day in birthday[1]:
            count+=1
    if count==1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    count=0
    for birthday_month in possible_birthdays:
        if month in birthday_month[0]:
            count+=1
    if count==1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    month_tuple=()
    for birthday in possible_birthdays:
        if month==birthday[0]:
            month_tuple+=(birthday,)
        else:
            continue
    for day in month_tuple:

        if unique_day(day[1], possible_birthdays)== True :
            return True
    return False


def unique_day(day, possible_birthdays):

    count=0
    for birthday in possible_birthdays:
        if day in birthday[1]:
            count+=1
    if count==1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(day, possible_birthdays):
	num=0
	for i in possible_birthdays:
		if day==i[1]:
			num=num+1
	if num==1:
		return True

	else:
		return False

def unique_month(month, possible_birthdays):
	num=0
	for i in possible_birthdays:
		if month==i[0]:
			num=num+1
	if num==1:
		return True

	else:
		return False

def contains_unique_day(month, possible_birthdays):
	result=()
	for i in possible_birthdays:
		if unique_day(i[1],possible_birthdays)==True:
			result=result+(i[0],)
	num=0
	for j in result:
		if month==j:
			num=num+1
	if num==1:
		return True
	else:
		return False


def unique_day(day, possible_birthdays):
    day_count = 0
    for i in possible_birthdays:
        if day in i:
            day_count += 1
        if day_count > 1:
            return False
    return True

def unique_month(month, possible_birthdays):
    month_count = 0
    for i in possible_birthdays:
        if month in i:
            month_count += 1
        if month_count > 1:
            return False
    return True

def contains_unique_day(month, possible_birthdays):
    days_in_month = ()
    for i in possible_birthdays:
        if month in i:
            days_in_month += (i[1],)
    for i in days_in_month:
        if unique_day(i, possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    counter = 0
    result = 0
    while counter < len(possible_birthdays):
        date = possible_birthdays[counter][1]
        if date == day:
            result = result + 1
        counter = counter + 1
    if result > 1:
        return False
    return True

def unique_month(month, possible_birthdays):
    counter = 0
    result = 0
    while counter < len(possible_birthdays):
        chosen_month = possible_birthdays[counter][0]
        if chosen_month == month:
            result = result + 1
        counter = counter + 1
    if result > 1:
        return False
    return True

def contains_unique_day(month, possible_birthdays):
    counter = 0
    while counter < len(possible_birthdays):
        get_month = possible_birthdays[counter][0]
        if get_month == month:
            test_date = possible_birthdays[counter][1]
            if unique_day(test_date, possible_birthdays) == True:
                return True
        counter = counter + 1
    return False


def unique_day(date, possible_birthdays):
    for x in range(len(1,possible_birthdays + 1)):
        for i in possible_birthdays[x][1]:
            if i == possible_birthdays[0][1]:
                return False
            else:
                return i == unique_day(date,possible_birthdays[1:][1])

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(date, possible_birthdays):
    for x in range(len(1,possible_birthdays + 1)):
        for i in possible_birthdays[x][1]:
            if i == possible_birthdays[0][1]:
                return False
            else:
                return i == unique_day(date,possible_birthdays[2:][1])

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(date, possible_birthdays):
    for x in range(1,len(possible_birthdays)):
        for i in possible_birthdays[x][1]:
            if possible_birthdays[0][1] == possible_birthdays[i][1]:
                return False
            else:
                return unique_day(date,possible_birthdays[1:])
def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(date, possible_birthdays):
    for i in range(0,len(possible_birthdays)):
        list = [x for x in possible_birthdays[i][1]]
        list = sorted(list)
        if date == list[i] and date != list[i+1] and date != list[i-1]:
            return True
        else:
            return False

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(date, possible_birthdays):
    for i in range(0,len(possible_birthdays)):
        list = [x for x in possible_birthdays[i][1]]
        list = sorted(list)
        if date == list[i] and date != list[i+1] and date != list[i-1]:
            return True
        else:
            return False

def unique_month(month, possible_birthdays):
    for i in range(0,len(possible_birthdays)):
        list = [x for x in possible_birthdays[i][0]]
        list = sorted(list)
        if month == list[i] and month != list[i+1] and month != list[i-1]:
            return True
        else:
            return False

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(date, possible_birthdays):
    for i in range(0,len(possible_birthdays)):
        list = [x for x in possible_birthdays[i][1]]
        list = sorted(list)
        if date == list[i] and date != list[i+1] and date != list[i-1]:
            return True
        else:
            return False

def unique_month(month, possible_birthdays):
    for i in range(0,len(possible_birthdays)):
        list = [x for x in possible_birthdays[i][0]]
        list = sorted(list)
        if month == list[i] and month != list[i+1] and month != list[i-1]:
            return True
        else:
            return False

def contains_unique_day(month, possible_birthdays):
    month_tuple = ()
    for i in range(0,len(possible_birthdays)):
        if possible_birthdays[i][0] == month:
            month_tuple = month_tuple + (possible_birthdays[i][1],)
    for x in month_tuple:
        for i in range(0,len(possible_birthdays)):
            if x == possible_birthdays[i][1]:
                return False
            else:
                return True


def unique_day(date, possible_birthdays):
    for i in range(0,len(possible_birthdays)):
        list_final = [x for x in possible_birthdays[i][1]]
        list_final = sorted(list_final)
        if date == list_final[i] and date != list_final[i+1] and date != list_final[i-1]:
            return True
        else:
            return False

def unique_month(month, possible_birthdays):
    for i in range(0,len(possible_birthdays)):
        list = [x for x in possible_birthdays[i][0]]
        list = sorted(list)
        if month == list[i] and month != list[i+1] and month != list[i-1]:
            return True
        else:
            return False

def contains_unique_day(month, possible_birthdays):
    month_tuple = ()
    for i in range(0,len(possible_birthdays)):
        if possible_birthdays[i][0] == month:
            month_tuple = month_tuple + (possible_birthdays[i][1],)
    for x in month_tuple:
        for i in range(0,len(possible_birthdays)):
            if x == possible_birthdays[i][1]:
                return False
            else:
                return True


def filter(pred, seq):
    if seq == ():
        return ()
    elif pred(seq[0]):
        return (seq[0],) + filter(pred, seq[1:])
    else:
        return filter(pred, seq[1:])

def unique_day(date, possible_birthdays):
    counter = 0
    for bday in possible_birthdays:
        if date == bday[1]:
            counter += 1
    if counter > 1:
        return False
    return True

def unique_month(month, possible_birthdays):
    counter = 0
    for bday in possible_birthdays:
        if month == bday[0]:
            counter += 1
    if counter > 1:
        return False
    return True

def contains_unique_day(month, possible_birthdays):
    bdays_in_month = filter(lambda bday: bday[0] == month, possible_birthdays)
    for bday in bdays_in_month:
        if unique_day(bday[1], possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    total_day = 0
    for birthday in possible_birthdays:
        if birthday[1] == day:
            total_day += 1
    if total_day == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    total_month = 0
    for birthday in possible_birthdays:
        if birthday[0] == month:
            total_month += 1
    if total_month == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(day, pb):
    n = len(pb)
    for i in range(n):
        if day == pb[i][1]:
            k = pb[i+1:]
            for j in range(len(k)):
                if day == k[j][1]:
                    return False
    return True

def unique_month(month, pb):
    n = len(pb)
    for i in range(n):
        if month == pb[i][0]:
            k = pb[i+1:]
            for j in range(len(k)):
                if month == k[j][0]:
                    return False
    return True

def contains_unique_day(month, pb):
    new_pb = tuple(filter( lambda x: x[0] == month, pb))
    n = len(new_pb)
    for i in range(n):
        day = new_pb[i][1]
        if unique_day( day, pb):
            return True
    return False


def unique_day(day, possible_birthdays):
    result = ()
    for p in possible_birthdays:
        pd = p[1]
        if day == pd:
            result = result + (day,)
    if len(result) > 1:
        return False
    return True

def unique_month(month, possible_birthdays):
    result = ()
    for p in possible_birthdays:
        pm = p[0]
        if month == pm:
            result = result + (month,)
    if len(result) > 1:
        return False
    return True

def contains_unique_day(month, possible_birthdays):
    result = ()
    for p in possible_birthdays:
        if month == p[0]:
            result = result + (p,)
    for r in result:
        if unique_day(r[1], possible_birthdays) == True:
            return True
    return False


def unique_day(day, possible_birthdays):
    days = tuple(filter(lambda x: x[1] == day, possible_birthdays))
    if len(days) <= 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    months = tuple(filter(lambda x: x[0] == month, possible_birthdays))
    if len(months) <= 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    dates = ()
    for date in possible_birthdays:
        if date[0] == month:
            dates += (date,)
    for dated in dates:
        if unique_day(dated[1], possible_birthdays) == True:
            return True
    else:
        return False


def filter(pred, seq):
    res = ()

    for ele in seq:
        if pred(ele):
            res = res + (ele, )
    return res

def unique_day(day, possible_birthdays):
    store = ()
    for birthday in possible_birthdays:
        if birthday[1] == day:
            store += (birthday[1],)
    n = len(store)
    if n >1:
        return False
    return True

def unique_month(month, possible_birthdays):
    store= ()
    for birthday in possible_birthdays:
        if birthday[0] == month:
            store += (birthday[0],)
    n = len(store)
    if n >1:
        return False
    return True

def contains_unique_day(month, possible_birthdays):
    month1 = filter(lambda x: x[0] == month, possible_birthdays)
    for birthday in month1:
        x = unique_day(birthday[1], possible_birthdays)
        if x == True:
            return True
    return False


def unique_day(day, possible_birthdays):
    bag = ()
    for date in possible_birthdays:
        if date[1] == day:
            bag += (date[1],)
    if len(bag) >= 2:
        return False
    return True

def unique_month(month, possible_birthdays):
    bag = ()
    for date in possible_birthdays:
        if date[0] == month:
            bag += (date[0],)
    if len(bag) >= 2:
        return False
    return True

def contains_unique_day(month, possible_birthdays):
    for date in possible_birthdays:
        if date[0] == month:
            day = date[1]
            if unique_day(day, possible_birthdays):
                return True
            else:
                continue
    return False


def unique_day(day, possible_birthdays):
    unique = False
    for i in possible_birthdays:
        if day == i[1]:
            if unique:
                return False
            else:
                unique = True
    return True

def unique_month(month, possible_birthdays):
    unique = False
    for i in possible_birthdays:
        if month == i[0]:
            if unique:
                return False
            else:
                unique = True
    return True

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if month == i[0]:
            if unique_day(i[1],possible_birthdays):
                return True
    return False


def unique_day(day, possible_birthdays):
    count = 0
    for birthday in possible_birthdays:
        if day == birthday[1]:
            count += 1
    return True if count == 1 else False

def unique_month(month, possible_birthdays):
    count = 0
    for birthday in possible_birthdays:
        if month == birthday[0]:
            count += 1
    return True if count == 1 else False

def contains_unique_day(month, possible_birthdays):
    tup = ()
    for birthday in possible_birthdays:
        if month == birthday[0]:
            tup += (birthday,)
    for each in tup:
        if each[1] == '18' or each[1] == '19':
            return True
    return False


def unique_day(day, possible_birthdays):
    counted = ()
    for birthdays in possible_birthdays:
        if birthdays[1] == day:
            if day not in counted:
                counted += (day,)
            else:
                return False

    return True

def unique_month(month, possible_birthdays):
    day = month
    counted = ()
    for birthdays in possible_birthdays:
        if birthdays[0] == day:
            if day not in counted:
                counted += (day,)
            else:
                return False

    return True

def contains_unique_day(month, possible_birthdays):
    for possiblemonth in possible_birthdays:
        if possiblemonth[0] == month:
            if unique_day(possiblemonth[1],possible_birthdays) == True:
                return True
            else:
                continue
    return False


def unique_day(day, possible_birthdays):
    counter=0
    for i in possible_birthdays:
        if i[1]==day:
            counter=counter+1
    if counter<=1:
        return True
    else:
        return False
    return True

def unique_month(month, possible_birthdays):
    counter=0
    for i in possible_birthdays:
        if i[0]==month:
            counter=counter+1
    if counter<=1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    temp=()
    for i in possible_birthdays:
        if i[0]==month:
            temp=temp+(i,)
    for i in temp:
        if unique_day(i[1],possible_birthdays):
            return True
    return False


def unique_day(date, possible_birthdays):
    count = 0
    for i in range(len(possible_birthdays)):
        if possible_birthdays[i][1] == day:
            count += 1
    if count == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    count = 0
    for i in range(len(possible_birthdays)):
        if possible_birthdays[i][0] == month:
            count += 1
    if count == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for i in range(len(possible_birthdays)):
        if possible_birthdays[i][0] == month and unique_day(possible_birthdays[i][1], possible_birthdays) == True:
            return True
    return False


def unique_day(day, possible_birthdays):
    result=()
    counter=0
    for i in possible_birthdays:
        if day==i[1]:
            result=result+(possible_birthdays[:counter]+possible_birthdays[counter+1:])
            break
        else:
            counter+=1
            continue
    for i in result:
        if day==i[1]:
            return False
    return True

def unique_month(month, possible_birthdays):
    result=()
    counter=0
    for i in possible_birthdays:
        if month==i[0]:
            result=result+(possible_birthdays[:counter]+possible_birthdays[counter+1:])
            break
        else:
            counter+=1
            continue
    for i in result:
        if month==i[0]:
            return False
    return True

def contains_unique_day(month, possible_birthdays):
    result=()
    for i in possible_birthdays:
        if i[0]==month:
            result+=(i,) #result should contain all the birthdays with the specified month.
    for i in result:
        if unique_day(i[1],possible_birthdays)==True:
            return True
    return False


def unique_day(day, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if str(day) == i[1]:
            counter = counter + 1
    if counter > 1:
        return False
    else:
        return True

def unique_month(month, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if str(month) == i[0]:
            counter = counter + 1
    if counter > 1:
        return False
    else:
        return True

def contains_unique_day(month, possible_birthdays):
    list_d = ()
    for i in range(16,20):
        i_string = str(i)
        if unique_day(i_string, possible_birthdays) is True:
            list_d = list_d + (str(i),)
    for i in possible_birthdays:
        for j in list_d:
            if i[1] == j:
                if i[0] == month:
                    return True
    return False


def unique_day(date, possible_birthdays):
    no_of_days = 0
    for i in possible_birthdays:
        if i[1] == date:
            no_of_days += 1
    if no_of_days != 1:
        return False
    return True

def unique_month(month, possible_birthdays):
    no_of_months = 0
    for i in possible_birthdays:
        if i[0] == month:
            no_of_months += 1
    if no_of_months != 1:
        return False
    return True

def contains_unique_day(month, possible_birthdays):
    birthdays_with_month = ()
    for i in possible_birthdays:
        if i[0] == month:
            birthdays_with_month += (i[1],)
    counter = 0
    for i in birthdays_with_month:
        if unique_day(i, possible_birthdays) == True:
            counter += 1
    if counter == 1:
        return True
    else:
        return False


def unique_day(date, possible_birthdays):
    no_of_days = 0
    for i in possible_birthdays:
        if i[1] == day:
            no_of_days += 1
    if no_of_days != 1:
        return False
    return True

def unique_month(month, possible_birthdays):
    no_of_months = 0
    for i in possible_birthdays:
        if i[0] == month:
            no_of_months += 1
    if no_of_months != 1:
        return False
    return True

def contains_unique_day(month, possible_birthdays):
    birthdays_with_month = ()
    for i in possible_birthdays:
        if i[0] == month:
            birthdays_with_month += (i[1],)
    counter = 0
    for i in birthdays_with_month:
        if unique_day(i, possible_birthdays) == True:
            counter += 1
    if counter == 1:
        return True
    else:
        return False


def unique_day(date, possible_birthdays):
    count = 0
    for possible_birthday in possible_birthdays:
        if day == possible_birthday[1]:
            count += 1
    return count == 1

def unique_month(month, possible_birthdays):
    count  = 0
    for possible_birthday in possible_birthdays:
        if month == possible_birthday[0]:
            count += 1
    return count == 1

def contains_unique_day(month, possible_birthdays):
    for possible_birthday in possible_birthdays:
        if month == possible_birthday[0] and unique_day(possible_birthday[1], possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    total = 0
    for i in possible_birthdays:
        if i[1] == day:
            total += 1
    if total > 1:
        return False
    return True

def unique_month(month, possible_birthdays):
    total = 0
    for i in possible_birthdays:
        if i[0] == month:
            total += 1
    if total > 1:
        return False
    return True

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if i[0] == month:
            if unique_day(i[1],possible_birthdays):
                return True
    return False


def unique_day(date, possible_birthdays):
    result=()
    counter=0
    for i in possible_birthdays:
        if day==i[1]:
            result=result+(possible_birthdays[:counter]+possible_birthdays[counter+1:])
            break
        else:
            counter+=1
            continue
    for i in result:
        if day==i[1]:
            return False
    return True

def unique_month(month, possible_birthdays):
    result=()
    counter=0
    for i in possible_birthdays:
        if month==i[0]:
            result=result+(possible_birthdays[:counter]+possible_birthdays[counter+1:])
            break
        else:
            counter+=1
            continue
    for i in result:
        if month==i[0]:
            return False
    return True

def contains_unique_day(month, possible_birthdays):
    result=()
    for i in possible_birthdays:
        if i[0]==month:
            result+=(i,) #result should contain all the birthdays with the specified month.
    for i in result:
        if unique_day(i[1],possible_birthdays)==True:
            return True
    return False


def unique_day(day, possible_birthdays):
    result=()
    counter=0
    for i in possible_birthdays:
        if day==i[1]:
            result=result+(possible_birthdays[:counter]+possible_birthdays[counter+1:])
            break
        else:
            counter+=1
            continue
    for i in result:
        if day==i[1]:
            return False
    return True

def unique_month(month, possible_birthdays):
    result=()
    counter=0
    for i in possible_birthdays:
        if month==i[0]:
            result=result+(possible_birthdays[:counter]+possible_birthdays[counter+1:])
            break
        else:
            counter+=1
            continue
    for i in result:
        if month==i[0]:
            return False
    return True


def unique_day(day, possible_birthdays):
    days = ()
    for birthday in possible_birthdays:
        if birthday[1] != day:
            continue
        elif birthday[1] not in days:
            days += (birthday[1],)
        else:
            return False
    return True

def unique_month(month, possible_birthdays):
    days = ()
    for birthday in possible_birthdays:
        if birthday[0] != month:
            continue
        elif birthday[0] not in days:
            days += (birthday[0],)
        else:
            return False
    return True

def contains_unique_day(month, possible_birthdays):
    for birthday in possible_birthdays:
        if birthday[0] != month:
            continue
        else:
            if unique_day(birthday[1],possible_birthdays) == True:
                return True
    return False


def unique_day(day, possible_birthdays):
    counted = ()
    for birthdays in possible_birthdays:
        if birthdays[1] == day:
            if day not in counted:
                counted += (day,)
            else:
                return False

    return True


def unique_day(day, possible_birthdays):
    counted = ()
    for birthdays in possible_birthdays:
        if birthdays[1] == day:
            if day not in counted:
                counted += (day,)
            else:
                return False

    return True

def unique_month(month, possible_birthdays):
    day = month
    counted = ()
    for birthdays in possible_birthdays:
        if birthdays[0] == day:
            if day not in counted:
                counted += (day,)
            else:
                return False

    return True


def unique_day(day, possible_birthdays):
    counter = 0
    for dates in possible_birthdays:
        if day == dates[1]:
            possible_birthdays = possible_birthdays[1:]
            counter = counter + 1
    if counter == 1:
        return True
    else:
        return False
    return

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(day, possible_birthdays):
    counter = 0
    for dates in possible_birthdays:
        if day == dates[1]:
            possible_birthdays = possible_birthdays[1:]
            counter = counter + 1
    if counter == 1:
        return True
    else:
        return False
    return

def unique_month(month, possible_birthdays):
    counter = 0
    for dates in possible_birthdays:
        if month == dates[0]:
            possible_birthdays = possible_birthdays[1:]
            counter = counter + 1
    if counter == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(day, possible_birthdays):
    days = ()
    for all_days in possible_birthdays:
        days = days + (all_days[1],)
        i = 0
        for all_days in days:
            if all_days == day:
                i = i+1
    if i == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    months = ()
    for all_months in possible_birthdays:
        months = months + (all_months[0],)
        i = 0
        for all_months in months:
            if all_months == month:
                i = i+1
    if i == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    May_days = ()
    June_days = ()
    July_days = ()
    August_days = ()
    May_dates = possible_birthdays[:3]
    for all_days in May_dates:
        May_days = May_days + (all_days[1],)
    June_dates = possible_birthdays[3:5]
    for all_days in June_dates:
        June_days = June_days + (all_days[1],)
    July_dates = possible_birthdays[5:7]
    for all_days in July_dates:
        July_days = July_days + (all_days[1],)
    August_dates = possible_birthdays[7:]
    for all_days in August_dates:
        August_days = August_days + (all_days[1],)
    if month == 'May':
        for days in May_days:
            found_repeated = 0
            for check_day in June_days:
                if days == check_day:
                    found_repeated = 1
                    break
            if found_repeated == 0:
                for check_day in July_days:
                    if days == check_day:
                        found_repeated = 1
                        break
                if found_repeated == 0:
                    for check_day in August_days:
                        if days == check_day:
                            found_repeated = 1
                            break
    elif month == 'June':
        for days in June_days:
            found_repeated = 0
            for check_day in May_days:
                if days == check_day:
                    found_repeated = 1
                    break
            if found_repeated == 0:
                for check_day in July_days:
                    if days == check_day:
                        found_repeated = 1
                        break
                if found_repeated == 0:
                    for check_day in August_days:
                        if days == check_day:
                            found_repeated = 1
                            break
    elif month == 'July':
        for days in July_days:
            found_repeated = 0
            for check_day in May_days:
                if days == check_day:
                    found_repeated = 1
                    break
            if found_repeated == 0:
                for check_day in June_days:
                    if days == check_day:
                        found_repeated = 1
                        break
                if found_repeated == 0:
                    for check_day in August_days:
                        if days == check_day:
                            found_repeated = 1
                            break
    else:
        for days in August_days:
            found_repeated = 0
            for check_day in May_days:
                if days == check_day:
                    found_repeated = 1
                    break
            if found_repeated == 0:
                for check_day in June_days:
                    if days == check_day:
                        found_repeated = 1
                        break
                if found_repeated == 0:
                    for check_day in July_days:
                        if days == check_day:
                            found_repeated = 1
                            break
    if found_repeated == 0:
        return True
    return False


def unique_day(day, possible_birthdays):
    counter = 0
    for dates in possible_birthdays:
        if day == dates[1]:
            possible_birthdays = possible_birthdays[1:]
            counter = counter + 1
    if counter == 1:
        return True
    else:
        return False
    return

def unique_month(month, possible_birthdays):
    counter = 0
    for dates in possible_birthdays:
        if month == dates[0]:
            possible_birthdays = possible_birthdays[1:]
            counter = counter + 1
    if counter == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    counter = 0
    new_list = keep_month(month,possible_birthdays)
    for i in new_list:
        if unique_day(i[1], possible_birthdays) == True:
            return True

    return False


def unique_day(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if date == i[1]:
            result += 1
        return result
        if result == 1:
            return True
        else:
            return False

    return

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if date == i[1]:
            result += 1
        return result
        if result == 1:
            return True
        else:
            return False

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if date == i[1]:
            count += 1
    return count
    if count == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if date == i[1]:
            count += 1
        return count
    if count == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if date == i[1]:
            count += 1
        return count
        if count == 1:
            return True
        else:
            return False

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if date == i[1]:
            count += 1
    return count
    if count == 1:
        return True
    return False

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count
    if count == 1:
        return True
    return False

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count
    if count == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
        return count
    if count == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def count_dates(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count

def unique_day(date, possible_birthdays):
    if count_dates == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def count_dates(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count

def unique_day(date, possible_birthdays):
    if count_dates == 0:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def count_dates(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count

def unique_day(date, possible_birthdays):
    if count_dates == 2:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def count_dates(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count

def unique_day(date, possible_birthdays):
    if count_dates(date, possible_birthdays) == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def count_dates(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count

def unique_day(date, possible_birthdays):
    if count_dates(date, possible_birthdays) == 1:
        return True
    else:
        return False

def count_months(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[2] == month:
            count += 1
    return count

def unique_month(month, possible_birthdays):
    if count_months(month, possible_birthdays) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    return


def count_dates(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count

def unique_day(date, possible_birthdays):
    if count_dates(date, possible_birthdays) == 1:
        return True
    else:
        return False

def count_months(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[0] == month:
            count += 1
    return count

def unique_month(month, possible_birthdays):
    if count_months(month, possible_birthdays) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(day, possible_birthdays):
	check = 0
	for birthday in possible_birthdays:
		if birthday[1] == day:
			check = check + 1
	if check > 1 :
		return False
	else:
		return True

def unique_month(month, possible_birthdays):
	check = 0
	for birthday in possible_birthdays:
		if birthday[0] == month:
			check = check + 1
	if check > 1 :
		return False
	else:
		return True

def contains_unique_day(month, possible_birthdays):
	for birthday in possible_birthdays:
		if month == birthday[0] and unique_day(birthday[1], possible_birthdays):
				return True
	else:
		return False


def count_dates(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count

def unique_day(date, possible_birthdays):
    if count_dates(date, possible_birthdays) == 1:
        return True
    else:
        return False

def count_months(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[0] == month:
            count += 1
    return count

def unique_month(month, possible_birthdays):
    if count_months(month, possible_birthdays) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):

    return


def count_dates(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count

def unique_day(date, possible_birthdays):
    if count_dates(date, possible_birthdays) == 1:
        return True
    else:
        return False

def count_months(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[0] == month:
            count += 1
    return count

def unique_month(month, possible_birthdays):
    if count_months(month, possible_birthdays) == 1:
        return True
    else:
        return False

def days_in_month(month, possible_birthdays):
    product = ()
    for i in possible_birthdays:
        if i[0] == month:
            product += (i[1], )
    return product

def contains_unique_day(month, possible_birthdays):
    for x in days_in_month(month, possible_birthdays):
        if unique_day(x, possible_birthdays):
            return True
        else:
            return False


def count_dates(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count

def unique_day(date, possible_birthdays):
    if count_dates(date, possible_birthdays) == 1:
        return True
    else:
        return False

def count_months(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[0] == month:
            count += 1
    return count

def unique_month(month, possible_birthdays):
    if count_months(month, possible_birthdays) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if i[0] == month:
            if unique_day(x, possible_birthdays):
                return True
            else:
                return False


def count_dates(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count

def unique_day(date, possible_birthdays):
    if count_dates(date, possible_birthdays) == 1:
        return True
    else:
        return False

def count_months(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[0] == month:
            count += 1
    return count

def unique_month(month, possible_birthdays):
    if count_months(month, possible_birthdays) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if i[0] == month:
            if unique_day(x, possible_birthdays):
                return True
            else:
                return False
        else:
            return False


def count_dates(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count

def unique_day(date, possible_birthdays):
    if count_dates(date, possible_birthdays) == 1:
        return True
    else:
        return False

def count_months(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[0] == month:
            count += 1
    return count

def unique_month(month, possible_birthdays):
    if count_months(month, possible_birthdays) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if i[0] == month:
            if unique_day(i, possible_birthdays):
                return True
            else:
                return False
        else:
            return False


def count_dates(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count

def unique_day(date, possible_birthdays):
    if count_dates(date, possible_birthdays) == 1:
        return True
    else:
        return False

def count_months(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[0] == month:
            count += 1
    return count

def unique_month(month, possible_birthdays):
    if count_months(month, possible_birthdays) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if i[0] == month:
            if unique_day(i[1], possible_birthdays):
                return True
            else:
                return False
        else:
            return False


def count_dates(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count

def unique_day(date, possible_birthdays):
    if count_dates(date, possible_birthdays) == 1:
        return True
    else:
        return False

def count_months(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[0] == month:
            count += 1
    return count

def unique_month(month, possible_birthdays):
    if count_months(month, possible_birthdays) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if i[0] == month:
            if unique_day(i[1], possible_birthdays):
                return True
            else:
                return False
        else:
            continue


def unique_day(date, possible_birthdays):
    count = 0
    for i in range (len(possible_birthdays)):
        if date == possible_birthdays[i][1]:
            count +=1
    if count == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    count = 0
    for i in range (len(possible_birthdays)):
        if month == possible_birthdays[i][0]:
            count +=1
    if count == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    if month == "May":
        return True
    if month == "June":
        return True
    else:
        return False


def unique_day(date, possible_birthdays):
    tester = 0
    for i in possible_birthdays:
        if date == i[1]:
            if tester:
                return False
            else:
                tester = 1
    return tester

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(date, possible_birthdays):
    tester = 0
    for i in possible_birthdays:
        if date == i[1]:
            if tester:
                return False
            else:
                tester = 1
    return tester

def unique_month(month, possible_birthdays):
    tester = 0
    for i in possible_birthdays:
        if date == i[0]:
            if tester:
                return False
            else:
                tester = 1
    return tester

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(date, possible_birthdays):
    tester = 0
    for i in possible_birthdays:
        if date == i[1]:
            if tester:
                return False
            else:
                tester = 1
    return tester

def unique_month(month, possible_birthdays):
    tester = 0
    for i in possible_birthdays:
        if month == i[0]:
            if tester:
                return False
            else:
                tester = 1
    return tester

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(date, possible_birthdays):
    count = 0
    for i in range (len(possible_birthdays)):
        if day == possible_birthdays[i][1]:
            count +=1
    if count == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    count = 0
    for i in range (len(possible_birthdays)):
        if month == possible_birthdays[i][0]:
            count +=1
    if count == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(day, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if i[1] == day:
            counter = counter + 1
    if counter > 1:
        return False
    else:
        return True

def unique_month(month, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if i[0] == month:
            counter = counter + 1
    if counter > 1:
        return False
    else:
        return True

def contains_unique_day(month, possible_birthdays):
    x = ()
    for i in possible_birthdays:
        if i[0] == month:
            x = x + (i,)
    total = 0
    for i in x:
        total = total + unique_day(i[1], possible_birthdays)
    if total != 0:
        return True
    else:
        return False


def unique_day(day, possible_birthdays):
    days = ()
    for all_days in possible_birthdays:
        days = days + (all_days[1],)
        i = 0
        for all_days in days:
            if all_days == day:
                i = i+1
    if i == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    months = ()
    for all_months in possible_birthdays:
        months = months + (all_months[0],)
        i = 0
        for all_months in months:
            if all_months == month:
                i = i+1
    if i == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    May_days = ()
    June_days = ()
    July_days = ()
    August_days = ()
    May_dates = possible_birthdays[:3]
    for all_days in May_dates:
        May_days = May_days + (all_days[1],)
    June_dates = possible_birthdays[3:5]
    for all_days in June_dates:
        June_days = June_days + (all_days[1],)
    July_dates = possible_birthdays[5:7]
    for all_days in July_dates:
        July_days = July_days + (all_days[1],)
    August_dates = possible_birthdays[7:]
    for all_days in August_dates:
        August_days = August_days + (all_days[1],)
    if month == 'May':
        for days in May_days:
            found_repeated = 0
            for check_day in June_days:
                if days == check_day:
                    found_repeated = 1
                    break
            if found_repeated == 0:
                for check_day in July_days:
                    if days == check_day:
                        found_repeated = 1
                        break
                if found_repeated == 0:
                    for check_day in August_days:
                        if days == check_day:
                            found_repeated = 1
                            break
    elif month == 'June':
        for days in June_days:
            found_repeated = 0
            for check_day in May_days:
                if days == check_day:
                    found_repeated = 1
                    break
            if found_repeated == 0:
                for check_day in July_days:
                    if days == check_day:
                        found_repeated = 1
                        break
                if found_repeated == 0:
                    for check_day in August_days:
                        if days == check_day:
                            found_repeated = 1
                            break
    elif month == 'July':
        for days in July_days:
            found_repeated = 0
            for check_day in May_days:
                if days == check_day:
                    found_repeated = 1
                    break
            if found_repeated == 0:
                for check_day in June_days:
                    if days == check_day:
                        found_repeated = 1
                        break
                if found_repeated == 0:
                    for check_day in August_days:
                        if days == check_day:
                            found_repeated = 1
                            break
    else:
        for days in August_days:
            found_repeated = 0
            for check_day in May_days:
                if days == check_day:
                    found_repeated = 1
                    break
            if found_repeated == 0:
                for check_day in June_days:
                    if days == check_day:
                        found_repeated = 1
                        break
                if found_repeated == 0:
                    for check_day in July_days:
                        if days == check_day:
                            found_repeated = 1
                            break
    if found_repeated == 0:
        return True
    return False


def unique_day(day, possible_birthdays):
    unique_day_counter = 0
    for i in possible_birthdays:
        if day == i[1]:
            unique_day_counter += 1
    if unique_day_counter != 1:
        return False
    return True

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(day, possible_birthdays):
    unique_day_counter = 0
    for i in possible_birthdays:
        if day == i[1]:
            unique_day_counter += 1
    if unique_day_counter != 1:
        return False
    return True

def unique_month(month, possible_birthdays):
    unique_month_counter = 0
    for i in possible_birthdays:
        if month == i[0]:
            unique_month_counter += 1
    if unique_month_counter != 1:
        return False
    return True

def contains_unique_day(month, possible_birthdays):
    return


def count_dates(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count

def unique_day(date, possible_birthdays):
    if count_dates(date, possible_birthdays) == 1:
        return True
    else:
        return False

def count_months(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[0] == month:
            count += 1
    return count

def unique_month(month, possible_birthdays):
    if count_months(month, possible_birthdays) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if i[0] == month:
            if unique_day(i[1], possible_birthdays):
                return True
            else:
                continue
        else:
            return False


def count_dates(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count

def unique_day(date, possible_birthdays):
    if count_dates(date, possible_birthdays) == 1:
        return True
    else:
        return False

def count_months(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[0] == month:
            count += 1
    return count

def unique_month(month, possible_birthdays):
    if count_months(month, possible_birthdays) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if i[0] == month:
            if unique_day(i[1], possible_birthdays):
                return True
            continue
        else:
            return False


def count_dates(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count

def unique_day(date, possible_birthdays):
    if count_dates(date, possible_birthdays) == 1:
        return True
    else:
        return False

def count_months(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[0] == month:
            count += 1
    return count

def unique_month(month, possible_birthdays):
    if count_months(month, possible_birthdays) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if i[0] == month:
            if unique_day(i[1], possible_birthdays):
                return True
                continue
        else:
            return False


def count_dates(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count

def unique_day(date, possible_birthdays):
    if count_dates(date, possible_birthdays) == 1:
        return True
    else:
        return False

def count_months(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[0] == month:
            count += 1
    return count

def unique_month(month, possible_birthdays):
    if count_months(month, possible_birthdays) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if i[0] == month:
            if unique_day(i[1], possible_birthdays):
                return True
                continue
            else:
                return False


def count_dates(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count

def unique_day(date, possible_birthdays):
    if count_dates(date, possible_birthdays) == 1:
        return True
    else:
        return False

def count_months(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[0] == month:
            count += 1
    return count

def unique_month(month, possible_birthdays):
    if count_months(month, possible_birthdays) == 1:
        return True
    else:
        return False

def days(month, possible_birthdays):
    days_in_month = ()
    for i in possible_birthdays:
        if i[0] == month:
            days_in_month += (i[1],)
    return days_in_month

def contains_unique_day(month, possible_birthdays):
    for x in days_in_month:
        if unique_day(x, possible_birthdays):
            return True
        else:
            return False


def count_dates(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count

def unique_day(date, possible_birthdays):
    if count_dates(date, possible_birthdays) == 1:
        return True
    else:
        return False

def count_months(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[0] == month:
            count += 1
    return count

def unique_month(month, possible_birthdays):
    if count_months(month, possible_birthdays) == 1:
        return True
    else:
        return False

def days(month, possible_birthdays):
    days_in_month = ()
    for i in possible_birthdays:
        if i[0] == month:
            days_in_month += (i[1],)
    return days_in_month

def contains_unique_day(month, possible_birthdays):
    for x in days:
        if unique_day(x, possible_birthdays):
            return True
        else:
            return False


def count_dates(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count

def unique_day(date, possible_birthdays):
    if count_dates(date, possible_birthdays) == 1:
        return True
    else:
        return False

def count_months(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[0] == month:
            count += 1
    return count

def unique_month(month, possible_birthdays):
    if count_months(month, possible_birthdays) == 1:
        return True
    else:
        return False

def days(month, possible_birthdays):
    days_in_month = ()
    for i in possible_birthdays:
        if i[0] == month:
            days_in_month += (i[1],)
    return days_in_month

def contains_unique_day(month, possible_birthdays):
    for x in days(month, possible_birthdays):
        if unique_day(x, possible_birthdays):
            return True
        else:
            return False


def count_dates(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count

def unique_day(date, possible_birthdays):
    if count_dates(date, possible_birthdays) == 1:
        return True
    else:
        return False

def count_months(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[0] == month:
            count += 1
    return count

def unique_month(month, possible_birthdays):
    if count_months(month, possible_birthdays) == 1:
        return True
    else:
        return False

def days(month, possible_birthdays):
    days_in_month = ()
    for i in possible_birthdays:
        if i[0] == month:
            days_in_month += (i[1],)
    return days_in_month

def contains_unique_day(month, possible_birthdays):
    for x in range(len(days(month, possible_birthdays))):
        if unique_day(x, possible_birthdays):
            return True
        else:
            return False


def unique_day(date, possible_birthdays):
    count = 0
    for birthday in possible_birthdays:
        if day == birthday[1]:
            count += 1
    return count == 1

def unique_month(month, possible_birthdays):
    count = 0
    for birthday in possible_birthdays:
        if month == birthday[0]:
            count += 1
    return count == 1

def contains_unique_day(month, possible_birthdays):
    singlemonthbirthday = ()
    for birthmonth in possible_birthdays:
        if month == birthmonth[0]:
            singlemonthbirthday += (birthmonth,)
    for birthday in singlemonthbirthday:
        if unique_day(birthday[1], possible_birthdays) == True:
            return True
    return False


def unique_day(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if day == i[1]:
            count += 1
    return count == 1

def unique_month(month, possible_birthdays):
    count = 0
    for birthday in possible_birthdays:
        if month == birthday[0]:
            count += 1
    return count == 1

def contains_unique_day(month, possible_birthdays):
    singlemonthbirthday = ()
    for birthmonth in possible_birthdays:
        if month == birthmonth[0]:
            singlemonthbirthday += (birthmonth,)
    for birthday in singlemonthbirthday:
        if unique_day(birthday[1], possible_birthdays) == True:
            return True
    return False


def unique_day(day, possible_birthdays):

    count = 0

    for i in possible_birthdays:
        if day in i:
            count += 1

    if count == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(day, possible_birthdays):
    count = 0
    for birthday in possible_birthdays:
        if day == birthday[1]:
            count += 1
        if count > 1:
            return False
    return True

def unique_month(month, possible_birthdays):
    count = 0
    for birthday in possible_birthdays:
        if month == birthday[0]:
            count += 1
        if count > 1:
            return False
    return True

def contains_unique_day(month, possible_birthdays):
    birthdays_month = ()
    for birthday in possible_birthdays:
        if month == birthday[0]:
            birthdays_month += (birthday,)
    for birthday in birthdays_month:
        if unique_day(birthday[1], possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    a = 0
    for item in possible_birthdays:
        for i in item:
            if i == day:
                a += 1
    if a == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    a = 0
    for item in possible_birthdays:
        for i in item:
            if i == month:
                a += 1
    if a == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    a = 0
    b = 0
    for item in possible_birthdays:
        if month in item:
            a = item
            if unique_day(item[1],possible_birthdays) == True:
                b += 1
    if b == 1:
        return True
    else:
        return False


def unique_day(day, possible_birthdays):
    count = 0
    for birthday in possible_birthdays:
        if day == birthday[1]:
            count += 1
        if count > 1:
            return False
    return True

def unique_month(month, possible_birthdays):
    count = 0
    for birthday in possible_birthdays:
        if month == birthday[1]:
            count += 1
        if count > 1:
            return False
    return True

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(day, possible_birthdays):
    count = 0
    for birthday in possible_birthdays:
        if day == birthday[1]:
            count += 1
        if count > 1:
            return False
    return True

def unique_month(month, possible_birthdays):
    count = 0
    for birthday in possible_birthdays:
        if month == birthday[0]:
            count += 1
        if count > 1:
            return False
    return True

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(day, possible_birthdays):
    count = 0
    for birthday in possible_birthdays:
        if day == birthday[1]:
            count += 1
        if count > 1:
            return False
    return True

def unique_month(month, possible_birthdays):
    count = 0
    for birthday in possible_birthdays:
        if month == birthday[0]:
            count += 1
        if count > 1:
            return False
    return True

def contains_unique_day(month, possible_birthdays):
    birthdays_month = ()
    for birthday in possible_birthdays:
        if month == birthday[0]:
            birthdays_month += (birthday,)
    for birthday in birthdays_month:
        if unique_day(birthday[1], birthdays_month):
            return True
    return False


def unique_day(day, possible_birthdays):
    a = 0
    for item in possible_birthdays:
        for i in item:
            if i == day:
                a += 1
    if a == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    a = 0
    for item in possible_birthdays:
        for i in item:
            if i == month:
                a += 1
    if a == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(day, possible_birthdays):
    count=0
    for i in possible_birthdays:
        if i[1]==day:
            count+=1
    if count>1:
        check=False
    else:
        check=True
    return check

def unique_month(month, possible_birthdays):
    count=0
    for i in possible_birthdays:
        if i[0]==month:
            count+=1
    if count>1:
        check=False
    else:
        check=True
    return check

def contains_unique_day(month, possible_birthdays):
    birthdays=()
    for i in possible_birthdays:
        if i[0]==month:
            birthdays+=(i,)
    for j in birthdays:
        if unique_day(j[1], possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    counter=0
    for i in possible_birthdays:
            if i[1]==day:
                counter=counter+1
    if counter<=1:
        return true
    else:
        return False
    return True

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(day, possible_birthdays):
    counter=0
    for i in possible_birthdays:
            if i[1]==day:
                counter=counter+1
    if counter<=1:
        return true
    else:
        return False
    return True

def unique_month(month, possible_birthdays):
    for i in possible_birthdays:
        if i[0]==month:
            counter=counter+1
    if counter<=1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(day, possible_birthdays):
    counter=0
    for i in possible_birthdays:
            if i[1]==day:
                counter=counter+1
    if counter<=1:
        return true
    else:
        return False
    return True

def unique_month(month, possible_birthdays):
    counter=0
    for i in possible_birthdays:
        if i[0]==month:
            counter=counter+1
    if counter<=1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(date, possible_birthdays):
    counter=0
    for date in possible_birthdays:
        if date[1]==day:
            counter+=1
        else:
            counter=counter
    if counter==1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    counter=0
    for date in possible_birthdays:
        if date[0]==month:
            counter+=1
        else:
            counter=counter
    if counter==1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    date=()
    for mon in possible_birthdays:
        if month ==mon[0]:
            date+=(mon,)
        else:
            date=date
    days=()
    for day in date:
        days+=(day[1],)
    y=()
    for x in days:
        if unique_day(x, possible_birthdays)==True:
            y+=(x,)
        else:
            y=y
    if y==():
        return False
    else:
        return True


def count_dates(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count

def unique_day(date, possible_birthdays):
    if count_dates(date, possible_birthdays) == 1:
        return True
    else:
        return False

def count_months(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[0] == month:
            count += 1
    return count

def unique_month(month, possible_birthdays):
    if count_months(month, possible_birthdays) == 1:
        return True
    else:
        return False

def days(month, possible_birthdays):
    days_in_month = ()
    for i in possible_birthdays:
        if i[0] == month:
            days_in_month += (i[1],)
    return days_in_month

def contains_unique_day(month, possible_birthdays):
    for x in days(month, possible_birthdays):
        if unique_day(x, possible_birthdays) == True:
            return True
        else:
            return False


def count_dates(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count

def unique_day(date, possible_birthdays):
    if count_dates(date, possible_birthdays) == 1:
        return True
    else:
        return False

def count_months(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[0] == month:
            count += 1
    return count

def unique_month(month, possible_birthdays):
    if count_months(month, possible_birthdays) == 1:
        return True
    else:
        return False

def days(month, possible_birthdays):
    days_in_month = ()
    for i in possible_birthdays:
        if i[0] == month:
            days_in_month += (i[1],)
    return days_in_month

def contains_unique_day(month, possible_birthdays):
    for x in range(days(month, possible_birthdays)):
        if unique_day(x, possible_birthdays):
            return True
        else:
            return False