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(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

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):
    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 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) == False:
            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
        elif unique_day(days(month, possible_birthdays)[-1], possible_birthdays):
            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(days(month, possible_birthday)[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(days(month, possible_birthday)[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 len(days(month, possible_birthdays)):
        if unique_day(days(month, possible_birthday)[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 len(days(month, possible_birthdays)):
        if unique_day(days(month, possible_birthdays)[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(days(month, possible_birthdays)[x], possible_birthdays):
            return True
        else:
            return False


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

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

def contains_unique_day(month, possible_birthdays):
    months = tuple(filter(lambda x: x[0] == month, possible_birthdays))
    result = tuple(filter(lambda y: unique_day(y[1], possible_birthdays), months))
    if len(result) == 1:
        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(days(month, possible_birthdays)[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):
    days_in_month = ()
    for i in possible_birthdays:
        if i[0] == month:
            days_in_month += (i[1],)
    for x in range(len(days(month, possible_birthdays))):
        if unique_day(days(month, possible_birthdays)[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):
    days_in_month = ()
    for i in possible_birthdays:
        if i[0] == month:
            days_in_month += (i[1],)
    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 contains_unique_day(month, possible_birthdays):
    days_in_month = ()
    for i in possible_birthdays:
        if i[0] == month:
            days_in_month += (i[1],)
    for i in days(month, possible_birthdays):
        if unique_day(i, 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):
    days_in_month = ()
    for i in possible_birthdays:
        if i[0] == month:
            days_in_month += (i[1],)
    for i in range(len(days(month, possible_birthdays))):
        if unique_day(i, 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):
    days_in_month = ()
    for i in possible_birthdays:
        if i[0] == month:
            days_in_month += (i[1],)
    for i in range(len(days(month, possible_birthdays))):
        if unique_day(days(month, possible_birthdays)[i], possible_birthdays):
            return True
        else:
            return False


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

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

def contains_unique_day(month, possible_birthdays):
    filtered = tuple(filter(lambda x: x[0] == month, possible_birthdays))
    tup1 = tuple(filter(lambda x: x[0] != month, possible_birthdays)) # Remaining dates
    tup2 = tuple(map(lambda x: x[1], tup1)) # Day of the remaining dates
    def unique(tup):
        output = ()
        for i in tup:
            if i not in output:
                output += (i,)
        return output
    dates = unique(tup2)

    for i in filtered:
        if i[1] not in dates:
            return True
    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):
    days_in_month = ()
    for i in possible_birthdays:
        if i[0] == month:
            days_in_month += (i[1],)
    for i in range(len(days_in_month)):
        if unique_day(days_in_month[i], 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):
    days_in_month = ()
    for i in possible_birthdays:
        if i[0] == month:
            days_in_month += (i[1],)
    for x in range(len(days_in_month)):
        if unique_day(days_in_month[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):
    days_in_month = ()
    for i in possible_birthdays:
        if i[0] == month:
            days_in_month += (i,)
    for x in range(len(days_in_month)):
        if unique_day(days_in_month[x][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):
    days_in_month = ()
    for i in possible_birthdays:
        if i[0] == month:
            days_in_month += (i,)
    for x in range(len(days_in_month)):
        if unique_day(days_in_month[x][1], 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 contains_unique_day(month, possible_birthdays):
    days_in_month = ()
    for i in possible_birthdays:
        if i[0] == month:
            days_in_month += (i,)
    for x in range(len(days_in_month)):
        if unique_day(days_in_month[x][1], possible_birthdays) == False:
            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):
    days_in_month = ()
    for i in possible_birthdays:
        if i[0] == month:
            days_in_month += (i,)
    for x in range(len(days_in_month)):
        if unique_day(days_in_month[x][1], possible_birthdays) == False:
            return True
        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 contains_unique_day(month, possible_birthdays):
    days_in_month = ()
    for i in possible_birthdays:
        if i[0] == month:
            days_in_month += (i,)
    for x in days_in_month:
        if unique_day(x[1], possible_birthdays) == False:
            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):
    days_in_month = ()
    for i in possible_birthdays:
        if i[0] == month:
            days_in_month += (i,)
    for x in days_in_month:
        if unique_day(x[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 days(month, possible_birthdays):
    days_in_month = ()
    for i in range(len(possible_birthdays)):
        if possible_birthdays[i][0] == month:
            days_in_month += (possible_birthdays[i],)
    return days_in_month

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


def unique_day(date, possible_birthdays):
    counter = 0
    for i in range(0,len(possible_birthdays)):
        if possible_birthdays[i][1] == date:
            counter = counter + 1
    if counter == 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):
    counter = 0
    for i in range(0,len(possible_birthdays)):
        if possible_birthdays[i][1] == date:
            counter = counter + 1
    if counter == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    counter = 0
    for i in range(0,len(possible_birthdays)):
        if possible_birthdays[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):
    i=0
    for birthday in possible_birthdays:
        if day == birthday[1]:
            i+=1
            if i == 2:
                return False
    return True

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

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


def unique_day(day, possible_birthdays):
    days = ()
    unique = ()
    for i in possible_birthdays:
        days += (i[1],)
    for i in days:
        if i == day:
            unique += (i,)
        else:
            continue
    if len(unique) == 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):
    x = 1
    for i in possible_birthdays:
        if day == i[1]:
            x = x + 1
        else:
            x = x
    if x > 2:
        return False
    else:
        return True

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

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


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

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

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


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

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

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


def unique_day(day, possible_birthdays):
    checker=True
    for k in possible_birthdays:
        if k[1]==day:
          checker=False
    return checker

def unique_month(day, possible_birthdays):
    checker=True
    for k in possible_birthdays:
        if k[0]==day:
          checker=False
    return checker

def contains_unique_day(month, possible_birthdays):
    return


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

def unique_month(day, possible_birthdays):
    checker=0
    for k in possible_birthdays:
        if k[0]==day:
          checker+=1
    return checker==1

def contains_unique_day(month, possible_birthdays):
    return


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

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

def contains_unique_day(month, possible_birthdays):
    uniquedays = ()
    daysinmonth = ()
    for i in possible_birthdays:
        if unique_day(i[1], possible_birthdays)== True:
            uniquedays += (i[1],)
    for i in possible_birthdays:
        if i[0] == month:
            daysinmonth += (i[1],)
    for each in uniquedays:
        if each in daysinmonth:
            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(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

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(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(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(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

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(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):
    counter = 0
    for i in possible_birthdays:
        if i[1] == date:
            counter += 1
        else:
            continue
    if counter == 1:
        return True
    else:
        return False

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

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


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

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


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

    if result == 1:
        return True

    else:
        return False

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

    if result == 1:
        return True

    else:
        return False

def contains_unique_day(month, possible_birthdays):
    return


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

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

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


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

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


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

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

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

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

def unique_day(day, possible_birthdays):
    a = map(lambda x : x[1], possible_birthdays)
    for i in  a:
        if i == day:
            b = filter(lambda x: x == i, a)
            if len(b) > 1:
                return False
            else:
                return True

def unique_month(month, possible_birthdays):
    a = map(lambda x : x[0], possible_birthdays)
    for i in  a:
        if i == month:
            b = filter(lambda x: x == i, a)
            if len(b) > 1:
                return False
            else:
                return True

def contains_unique_day(month, possible_birthdays):
    a = map(lambda x : x[0], possible_birthdays)
    b = map(lambda x : x[1], possible_birthdays)
    k = ()
    for i in range(len(a)):
        if month == a[i]:
                k += (b[i],)
    for f in range(len(k)):
        if len(filter(lambda x: x == k[f],b)) == 1:
            return True
    return False


def unique_day(day, possible_birthdays):
    count = 0
    for element in possible_birthdays:
        if element[1] == day:
            count += 1
    if count != 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):
    j = 0
    for i in possible_birthdays:
        if day == i[2]:
            j = j+1
        else:
            j = j
    if j == 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):
    j = 0
    for i in possible_birthdays:
        if day == i[1]:
            j = j+1
        else:
            j = j
    if j == 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):
    j = 0
    for i in possible_birthdays:
        if date == i[1]:
            j = j+1
        else:
            j = j
    if j == 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):
    j = 0
    for i in possible_birthdays:
        if date == i[1]:
            j = j+1
        else:
            j = j
    if j == 1:
        return True
    else:
        return False

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

def contains_unique_day(month, possible_birthdays):
    return


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

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

def contains_unique_day(month, possible_birthdays):
    dates=()
    for date in possible_birthdays:
        months,day=date
        if unique_day(day, possible_birthdays):
            dates+=(months,)
    return month in dates


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

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

def contains_unique_day(month, possible_birthdays):
    return


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

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

def contains_unique_day(month, possible_birthdays):
    return


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

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

def contains_unique_day(month, possible_birthdays):
    tup_month_1 = ()
    tup_month_2 = ()
    for i in possible_birthdays:
        if month == i[0]:
            tup_month_1 = tup_month_1 + (i,)
        else:
            tup_month_2 = tup_month_2 + (i[1],)
    for j in tup_month_1:
        day = j[1]
        if day in tup_month_2:
            continue
        elif day not in tup_month_2:
            return True
    else:
        return False


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

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

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


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

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


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):
    return

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(day, possible_birthdays):
    flat_possible_birthdays=enumerate_tree(possible_birthdays)
    if flat_possible_birthdays.count(day) == 1:
        return True
    else:
        return False

def enumerate_tree(tree):
    if tree == ():
        return ()
    elif is_leaf(tree):
        return (tree,)
    else:
        return enumerate_tree(tree[0])+enumerate_tree(tree[1:])
def is_leaf(item):
    return type(item) != tuple

def unique_month(month, possible_birthdays):
    flat_possible_birthdays=enumerate_tree(possible_birthdays)
    if flat_possible_birthdays.count(month) == 1:
        return True
    else:
        return False

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

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):
    return

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


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):
    return


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 = [possible_birthdays[i][1] for i in range(len(possible_birthdays))]
    if days.count(day) > 1:
        return False
    return True

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

def contains_unique_day(month, possible_birthdays):
    days_in_month = []
    for i in range(len(possible_birthdays)):
        curr_month = possible_birthdays[i][0]
        curr_day = possible_birthdays[i][1]
        if curr_month == month:
            days_in_month.append(curr_day)
    for day in days_in_month:
        if unique_day(day, possible_birthdays):
            return True
    return False


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

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

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


def unique_day(date, possible_birthdays):
    if day == 18 or 19:
       return True

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(date, possible_birthdays):
    if day == '18' or '19':
       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+=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):
    count = 0
    for i in possible_birthdays:
        if i[1] == day:
            count += 1
    if count > 1:
        return False
    return True

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

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


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


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

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


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

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

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


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

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

def contains_unique_day(month, possible_birthdays):
    return


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

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

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


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

def unique_month(month, possible_birthdays):
    x = 1
    for i in possible_birthdays:
        if month == i[0]:
            x = x + 1
        else:
            x = x
    if x > 2:
            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, )
    for a in x:
        if unique_day(a[1], possible_birthdays):
            return True
        else:
            return False


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

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

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


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

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

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


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

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

def contains_unique_day(month, possible_birthdays):
    daystoconsider = ()
    i = 0
    while i < len(possible_birthdays):
        if month == possible_birthdays[i][0]:
            daystoconsider += (possible_birthdays[i][1],)
        i += 1
    monthcontaininguniqueday = ()
    for a in range(len(possible_birthdays)):
        if possible_birthdays[a][1] in daystoconsider:
            monthcontaininguniqueday += (possible_birthdays[a][0],)
    for mth in range(len(monthcontaininguniqueday)):
        if monthcontaininguniqueday[mth] == month:
            return True
            break
        return False


def unique_day(day, possible_birthdays):
    value = 0
    for i in range(0, len(possible_birthdays)):
        if (day == possible_birthdays[i][1]):
            value += 1
    if (value > 1) or (value == 0):
        return False
    else:
        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 birthday in possible_birthdays:
        if birthday[1] == day:
            counter = counter + 1
    if counter <= 1:
        return True
    else:
        return False

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

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


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

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

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


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

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

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


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

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

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


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

def unique_month(month, possible_birthdays):
    """Your solution here"""
    count = 0
    for element in possible_birthdays:
        if month == element[0]:
            count += 1
    if count > 1:
        return False
    else:
        return True

def contains_unique_day(month, possible_birthdays):
    """Your solution here"""
    for date in possible_birthdays:
        if unique_day(date[1], possible_birthdays) and date[0] == month:
            return True
    else:
        return False


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

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

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(date, possible_birthdays):
    if date in possible_birthdays[1]:
        return False
    else:
        return True

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

def contains_unique_day(month, possible_birthdays):
    if x and y:
        return False
    else:
        return True


def unique_day(date, possible_birthdays):
    if date in possible_birthdays[1]:
        return False
    else:
        return True

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

def contains_unique_day(month, possible_birthdays):
    if not unique_day and not unique_month:
        return False
    else:
        return True


def unique_day(date, possible_birthdays):
    if int(date) in possible_birthdays:
        return False
    else:
        return True

def unique_month(month, possible_birthdays):
    if month in possible_birthdays:
        return False
    else:
        return True

def contains_unique_day(month, possible_birthdays):
    if not unique_day and not unique_month:
        return False
    else:
        return True


def unique_day(date, possible_birthdays):
    if int(date) in possible_birthdays[1]:
        return False
    else:
        return True

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

def contains_unique_day(month, possible_birthdays):
    if not unique_day and not unique_month:
        return False
    else:
        return True


def unique_day(date, possible_birthdays):
    if date in possible_birthdays[1:]:
        return False
    else:
        return True

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

def contains_unique_day(month, possible_birthdays):
    if not unique_day and not unique_month:
        return False
    else:
        return True


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


def unique_day(date, possible_birthdays):
    only_date = ()
    for i in possible_birthdays:
        if date in i:
            only_date = only_date + (i,)
    if len(only_date) == 1:
        return True
    else:
        return Flase

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

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(date, possible_birthdays):
    if day in possible_birthdays:
        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 i in range(len(possible_birthdays)):
        if day == possible_birthdays[i][1]:
            count += 1
    if count > 1:
        return False
    else:
        return True

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 False
    else:
        return True

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


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

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 False
    else:
        return True

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


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

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

def contains_unique_day(month, possible_birthdays):
    focus = ()
    unique_days = ()
    for i in possible_birthdays:
        if month == i[0]:
            focus += (i,)
    for j in focus:
        testday = j[1]
        if unique_day(testday, possible_birthdays) == True:
            unique_days += (testday,)
    for k in unique_days:
        for l in focus:
            if k == l[1]:
                break
            return True
    return False


def unique_day(date, possible_birthdays):
    a = ()
    for i in possible_birthdays:
        a += (i[1],)
    return a.count(date) == 1

def unique_month(month, possible_birthdays):
    a = ()
    for i in possible_birthdays:
        a += (i[1],)
    return a.count(month) == 1

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


def unique_day(day, possible_birthdays):
    counter=0
    for date in possible_birthdays:
        if date[1]==day:
            conter+=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[1]==month:
            conter+=1
        else:
            counter=counter
    if counter==1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    return


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

def unique_month(month, possible_birthdays):
    a = ()
    for i in possible_birthdays:
        a += (i[1],)
    return a.count(month) == 1

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


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

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


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

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

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(day, possible_birthdays):
    bdaylist = possible_birthdays
    count = 0
    while len(bdaylist) > 0:
        single = bdaylist[0]
        if single[1] == day:
            count = count + 1
        if count == 2:
            return False
            break
        bdaylist = bdaylist[1:]
    return True

def unique_month(month, possible_birthdays):
    bdaylist = possible_birthdays
    count = 0
    while len(bdaylist) > 0:
        single = bdaylist[0]
        if single[0] == month:
            count = count + 1
        if count == 2:
            return False
            break
        bdaylist = bdaylist[1:]
    return True

def contains_unique_day(month, possible_birthdays):
    month_list = ()
    bday_list = possible_birthdays
    while len(bday_list)>0:
        if bday_list[0][0]==month:
            month_list = month_list + (bday_list[0],)
        bday_list = bday_list[1:]

    while len(month_list)>0:
        if unique_day(month_list[0][1],possible_birthdays):
            return True
        month_list = month_list[1:]
    return False


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

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


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

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


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

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

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


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

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

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]:
            counter=counter+1
        else:
            continue
    if counter>1:
        return False
    else:
        return True

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


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

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

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if i[0] != month:
            continue
        elif 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]==date:
            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):
    if month=='June':
        return True
    elif month=='May':
        return True
    else:
        return False


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

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

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


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

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

def contains_unique_day(month, possible_birthdays):
    if not unique_day and not unique_month:
        return False
    else:
        return True


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

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

def contains_unique_day(month, possible_birthdays):
    if not unique_day and not unique_month:
        return False
    else:
        return True


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

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

def contains_unique_day(month, possible_birthdays):
    if not unique_day and not unique_month:
        return False
    else:
        return True


def unique_day(date, possible_birthdays):
    unique_day = ()
    days = ()
    for i in possible_birthdays:
        days += (i[1],)
    for i in days:
        if i == date:
            unique_day += (i,)
        else:
            continue

    if len(unique_day) == 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 date in birthday[(len(possible_birthdays))-1][1]:
        count += 1
        possible_birthday=possible_birthday[:(len(possible_birthdays))-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(date, possible_birthdays):
    count=0
    for i in possible_birthdays:
        if i[1]==date:
            count+=1
    if count!=1:           #if not can put count==1
        return False
    else:
        return True

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

def contains_unique_day(month, possible_birthdays):
    pass


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

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

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 == 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_date(i, possible_birthdays):
            return True
        else:
            return False


def unique_day(day, possible_birthdays):
    counter=0
    for date in possible_birthdays:
        if date[1]==day:
            conter+=1
        else:
            counter=counter
    if counter==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):
    counter=0
    for date in possible_birthdays:
        if date[1]==day:
            conter+=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[1]==month:
            conter+=1
        else:
            counter=counter
    if counter==1:
        return True
    else:
        return False

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 == 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_date(i, possible_birthdays):
            return True
        else:
            return false


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

def unique_month(month, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if month == i[0]:
            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):
    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):
    months = ()
    for i in possible_birthdays:
        if i[0] == month:
            months = months + (i,)
        else:
            continue
    for i in months:
        if unique_day(i[1], possible_birthdays) == True:
            return True
        else:
            return False


def unique_day(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if date == 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):
    months = ()
    for i in possible_birthdays:
        if i[0] == month:
            months = months + (i,)
        else:
            continue
    for i in months:
        if unique_day(i[1], possible_birthdays) == True:
            return True
        else:
            return False


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

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

def contains_unique_day(month, possible_birthdays):
    daystoconsider = ()
    i = 0
    while i < len(possible_birthdays):
        if month == possible_birthdays[i][0]:
            daystoconsider += (possible_birthdays[i][1],)
        i += 1
    monthcontaininguniqueday = ()
    for a in range(len(possible_birthdays)):
        if possible_birthdays[a][1] in daystoconsider:
            monthcontaininguniqueday += (possible_birthdays[a][0],)
    for mth in range(len(monthcontaininguniqueday)):
        if monthcontaininguniqueday[mth] == month:
            return True
            break
        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 False
    return True

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

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


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

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

def contains_unique_day(month, possible_birthdays):
    month_day = ()
    for j in possible_birthdays:
        if j == possible_birthdays[0]:
            month_day = month_day + (j,)
    for t in month_day:
        return unique_day(t[1], month_day)


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

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

def contains_unique_day(month, possible_birthdays):
    unique_days = ()
    month_birthdays = ()
    for day in range(0, 32):
        if unique_day(str(day), possible_birthdays) == True:
            unique_days = unique_days + (day,)
    for birthday in possible_birthdays:
        if birthday[0] == month:
            month_birthdays = month_birthdays + (birthday,)
    for dates in month_birthdays:
        if int(dates[1]) in unique_days:
            return True
    else:
        return False


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

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

def contains_unique_day(month, possible_birthdays):

    def month_tuple(month,possible_birthdays):
        new_tuple=()
        for dates in possible_birthdays:
            if month==dates[0]:
                new_tuple=new_tuple+(dates,)
            else:
                continue

        return new_tuple
    new_tuple=month_tuple(month,possible_birthdays)
    for dates2 in new_tuple:
        counter=0
        for dates in possible_birthdays:
            if dates2[1]==dates[1]:
                counter=counter+1
            else:
                continue
    if counter>1:
            return False
    else:
            return True


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):
    return


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):
    return


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):
    return


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(day, possible_birthdays):
    counter=0
    for date in possible_birthdays:
        if day in date:
            counter+=1
        if counter>1:
            return False
    return True

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

def contains_unique_day(month, possible_birthdays):
    dates=()
    for date in possible_birthdays:
        months,day=date
        if unique_day(day, possible_birthdays):
            return month==months


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

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

def contains_unique_day(month, possible_birthdays):
    dates=()
    for date in possible_birthdays:
        months,day=date
        if unique_day(day, possible_birthdays):
            return month==months