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
    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):
    for date in possible_birthdays:
        months,day=date
        if unique_day(day, possible_birthdays):
            return months==month

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):
    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(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):
    for i in possible_birthdays:
        if i[0]==month:
            if unique_day(i[1],possible_birthdays):
                return True
    return False


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

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

def contains_unique_day(month, possible_birthdays):
    birthdays = ()
    for i in possible_birthdays:
        if month in i:
            birthdays += (i,)
    for i in birthdays:
        if not unique_day(i[1], possible_birthdays):
            result = False
        else:
            result = True
            break
    return result


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

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


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

def unique_month(month, possible_birthdays):
    result = 0
    for months in possible_birthdays:
        if months[0] == month:
            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):
    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):
    return

def contains_unique_day(month, possible_birthdays):
    return


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):
    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):
    return date in possible_birthdays

def unique_month(month, possible_birthdays):
    return month in possible_birthdays

def contains_unique_day(month, possible_birthdays):
   birthday = ()
   for i in range(len(possible_birthdays)):
    if possible_birthdays[i][0] == month:
       birthday += possible_birthdays[i]

    for j in range(len(birthday)):
        return unique_day(birthday[i][1], possible_birthdays)


def unique_day(day, possible_birthdays):
    b=()  # list of dates
    for birthday in possible_birthdays:
        b.append(birthday[1])
    if b.count(day)==1:
        return True

    return False

def unique_month(month, possible_birthdays):
    b=()
    for birthday in possible_birthdays:
        b.append(birthday[0])
    if b.count(month)==1:
        return True

def contains_unique_day(month, possible_birthdays):
    b=()
    for birthday in possible_birthdays:
        if month == birthday[0]:
            b.append(birthday[1])  #add date to b
    for day in b:
        if unique_day(day,possible_birthdays)==True:
            return True

    return False


def unique_day(day, possible_birthdays):
    b=[]  # list of dates
    for birthday in possible_birthdays:
        b.append(birthday[1])
    if b.count(day)==1:
        return True

    return False

def unique_month(month, possible_birthdays):
    b=[]
    for birthday in possible_birthdays:
        b.append(birthday[0])
    if b.count(month)==1:
        return True

def contains_unique_day(month, possible_birthdays):
    b=[]
    for birthday in possible_birthdays:
        if month == birthday[0]:
            b.append(birthday[1])  #add date to b
    for day in b:
        if unique_day(day,possible_birthdays)==True:
            return True

    return False


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

    flat_tree = enumerate_tree(possible_birthdays)
    if flat_tree.count(day) > 1:
        return False

    return True

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

    flat_tree = enumerate_tree(possible_birthdays)

    if flat_tree.count(month) >1:
        return False
    return True

def contains_unique_day(month, possible_birthdays):
    tuppy = ()
    for x in possible_birthdays:
        if unique_day(x[1], possible_birthdays):
            tuppy += (x, )

    for y in tuppy:
        if y[0] == month:
            return True
    return False


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


def unique_day(day, possible_birthdays):
    i = 0
    for days in possible_birthdays:
        if int(day) == int(days[1]):
            i += 1
        else:
            i = i
    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):
    i = 0
    for days in possible_birthdays:
        if int(day) == int(days[1]):
            i += 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(day, possible_birthdays):
    i = 0
    for days in possible_birthdays:
        if int(day) == int(days[1]):
            i += 1

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

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


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

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

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

def contains_unique_day(month, possible_birthdays):
    return


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

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

def contains_unique_day(month, possible_birthdays):
    month_tup = ()
    for i in possible_birthdays:
        if month in i:
            month_tup = month_tup + possible_birthdays[i]
    return unique_day(day, month_tup)


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

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

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


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


def unique_day(day, possible_birthdays):
    datetup = ()
    for item in possible_birthdays:
        if item[1] == day:
            datetup = datetup + (item[1],)
    if len(datetup) == 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):
    new_possible_birthdays=()
    for i in possible_birthdays[1]:
        if unique_day(date,possible_birthdays)==true:
            new_possible_birthdays+=(possible_birthdays[i],)
        new_month=()
        counter=0
        for n in possible_birthdays[0]:
            if month==possible_birthday[i][0]:
                counter+=1
            if counter==0:
                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:           #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):
    new_possible_birthdays=()
    for i in possible_birthdays[1]:
        if unique_day(date,possible_birthdays)==true:
            new_possible_birthdays=(possible_birthdays[i],)
        new_month=()
        counter=0
        for n in possible_birthdays[0]:
            if month==possible_birthday[i][0]:
                counter+=1
            if counter==0:
                return False
            else:
                return True


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

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

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


def statement1(birthday, possible_birthdays):
    x = unique_month(birthday[0],possible_birthdays)
    y = contains_unique_day(birthday[0], possible_birthdays)

    if x == False and y == False:
        return True

    else:
        return False

def statement2(birthday, possible_birthdays):
    z = unique_day(birthday[1],possible_birthdays)

    if z == True:
        return True

    else:
        return False

def statement3(birthday, possible_birthdays):
    q = unique_month(birthday[0],possible_birthdays)

    if q == True:
        return True

    else:
        return False


def statement1(birthday, possible_birthdays):
    x = unique_month(birthday[0],possible_birthdays)
    y = contains_unique_day(birthday[0], possible_birthdays)

    if x == False and y == False:
        return True

    return False

def statement2(birthday, possible_birthdays):
    z = unique_day(birthday[1],possible_birthdays)

    if z == True:
        return True

    return False

def statement3(birthday, possible_birthdays):
    q = unique_month(birthday[0],possible_birthdays)

    if q == True:
        return True

    return False


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

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


def statement1(birthday, possible_birthdays):
    A = unique_month(birthday[0],possible_birthdays)
    B = contains_unique_day(birthday[0], possible_birthdays)

    if A == False and B == False:
        return True

    return False

def statement2(birthday, possible_birthdays):
    C = unique_day(birthday[1],possible_birthdays)

    if C == True:
        return True

    return False

def statement3(birthday, possible_birthdays):
    D = unique_month(birthday[0],possible_birthdays)

    if D == True:
        return True

    return False


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

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

def contains_unique_day(month, possible_birthdays):
    return


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

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

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


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

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

def contains_unique_day(month, possible_birthdays):
    return


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

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

def contains_unique_day(month, possible_birthdays):
    counter = 0
    for birthdate in possible_birthdays:
        if month == birthdate[0]:
            tp = unique_day(birthdate[1], possible_birthdays)
            if tp == True:
                counter += 1
    if counter >= 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):
    count = 0
    for item in possible_birthdays:
        if day == item[1]:
            count +=1
        else:
            continue
    if count >=2:
        return False
    else:
        return True

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

def contains_unique_day(month, possible_birthdays):
    return


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):
    count = 0
    for item in possible_birthdays:
        if day == item[1]:
            count +=1
        else:
            continue
    if count >=2:
        return False
    else:
        return True

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

def contains_unique_day(month, possible_birthdays):
    return


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

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

def contains_unique_day(month, possible_birthdays):
    birthdays = ()
    for i in possible_birthdays:
        if month in i:
            birthdays += (i,)
    for i in birthdays:
        if not unique_day(i[1], possible_birthdays):
            result = False
        else:
            result = True
            break
    return result


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

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

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


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

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

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


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

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

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


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

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

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


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

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

def contains_unique_day(month, possible_birthdays):
    new_tup = ()
    edited_tup = ()
    for i in range (len(possible_birthdays)):
        if month == possible_birthdays [i][0]:
            new_tup = new_tup + ((possible_birthdays[i][0],possible_birthdays[i][1]),)

    for i in range (len(possible_birthdays)):
        if month != possible_birthdays [i][0]:
            edited_tup = edited_tup + ((possible_birthdays[i][0],possible_birthdays[i][1]),)
    #print(new_tup)
    #print(edited_tup)

    def checker (new_tup, edited_tup):
        result = False
        for j in range (len(new_tup)):
            inter_result = False
            for k in range (len(edited_tup)):
                bool_tup = (new_tup[j][1] == edited_tup[k][1])
                inter_result = inter_result or bool_tup
            result = result or inter_result
            result = not result
        return result
    return checker (new_tup, edited_tup)


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

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

def contains_unique_day(month, possible_birthdays):
    def generate_unique_days(possible_birthdays):
        generate = ()
        for i in range(14, 20):
            if unique_day(str(i), possible_birthdays):
                generate += (str(i),)
        return generate
    for i in possible_birthdays:
        if i[0] == month:
            if str(i[1]) in generate_unique_days(possible_birthdays):
                return True
    return False


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

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

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(day, possible_birthdays):

    tupleofdays = ()
    for i in possible_birthdays:
        tupleofdays += (i[1],)

    count = 0
    for i in tupleofdays:
        if day == i:
            count += 1

    return count == 1

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

    count = 0

    for i in tupleofmonths:
        if month == i:
            count += 1

    return count ==1

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

    return ans


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
    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+=(i,)
    for i in temp:
        if unique_day(i[1],possible_birthdays):
            return True
    return False


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

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


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

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

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

def contains_unique_day(month, possible_birthdays):
    return


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

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

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


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

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

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


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

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

def contains_unique_day(month, possible_birthdays):
    return


def unique_day(date, possible_birthdays):
    for i in range(len(possible_birthdays)):
        if date==possible_birthdays[i]:
            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 possible_birthdays:

        if day == i[1]:

            count+=1

        else:

            continue

    if count==1:

        return True

    else:

        return False

def unique_month(month, possible_birthdays):

    count=0

    for i in possible_birthdays:

        if month == i[0]:

            count+=1

        else:

            continue

    if count<=1:

        return True

    else:

        return False

def contains_unique_day(month, possible_birthdays):

    for i in possible_birthdays:

        if i[0]==month:

            if unique_day(i[1],possible_birthdays):

                return True

    return False


def unique_day(day, possible_birthdays):

    count=0

    for i in possible_birthdays:

        if day == i[1]:

            count+=1

        else:

            continue

    if count<=1:

        return True

    else:

        return False

def unique_month(month, possible_birthdays):

    count=0

    for i in possible_birthdays:

        if month == i[0]:

            count+=1

        else:

            continue

    if count==1:

        return True

    else:

        return False

def contains_unique_day(month, possible_birthdays):

    for i in possible_birthdays:

        if i[0]==month:

            if unique_day(i[1],possible_birthdays):

                return True

    return False


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

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


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

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


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

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


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

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

def contains_unique_day(month, possible_birthdays):
    new_tuple = ()
    for i in possible_birthdays:
        if i[0] == month:
            new_tuple += (i,)
    print(new_tuple)
    for i in range(0,len(new_tuple)):
        if unique_day(new_tuple[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 False
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(day, possible_birthdays):
    counter=0
    for date in possible_birthdays:
        if date[1]==day:
            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):
    all_days = ()
    repeat_days =()
    for date in possible_birthdays:
        if date[1] not in all_days:
            all_days += (date[1],)
        else:
            repeat_days += (date[1],)
    return day not in repeat_days

def unique_month(month, possible_birthdays):
    all_month = ()
    repeat_month =()
    for date in possible_birthdays:
        if date[0] not in all_month:
            all_month += (date[0],)
        else:
            repeat_month += (date[0],)
    return month not in repeat_month

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


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

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

def contains_unique_day(month, possible_birthdays):
	days_in_month = ()
	days_not_in_month = ()
	unique_days = ()
	for row in possible_birthdays:
		if row[0] == month:
			days_in_month = days_in_month + (row[1],)
		else:
			days_not_in_month = days_not_in_month + (row[1],)

	for row2 in days_in_month:
		if row2 in days_not_in_month:
			continue
		else:
			unique_days = unique_days + (row2,)
	if unique_days == ():
		return False
	else:
		return True


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

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

def contains_unique_day(month, possible_birthdays):
    new_tuple = ()
    for i in possible_birthdays:
        if i[0] == month:
            new_tuple += (i,)
        if len(new_tuple)>1:
            return False
        else:
            return unique_day(new_tupl[0][1], possible_birthdays)


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

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

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


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


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

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

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

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

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

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

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


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

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

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


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

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

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

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


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

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

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

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

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


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

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

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


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

    return True

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

    return True

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


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

    return True


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

    return True

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

    return True


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

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

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


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

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

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

    return False


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

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

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


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

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

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


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

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

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


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

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

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


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

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

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

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

def contains_unique_day(month, possible_birthdays):
    return


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

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

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

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

def contains_unique_day(month, possible_birthdays):
    return


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

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

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

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

def contains_unique_day(month, possible_birthdays):

    return


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

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

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

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

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

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


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

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

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

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

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


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

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

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

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

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


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

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

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

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

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


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

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

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

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

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


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

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

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

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

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


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

def unique_month(month, possible_birthdays):
    return

def contains_unique_day(month, possible_birthdays):
    return


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

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

def contains_unique_day(month, possible_birthdays):
    return


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

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

def contains_unique_day(month, possible_birthdays):
    return


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

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

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


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

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

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

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

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


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

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

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

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

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


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

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

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

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

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


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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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