def get_frequency(iterable):
    f = {}
    for i in iterable:
        if i not in f:
            f[i] = 1
        else:
            f[i] += 1
    return f

def swap_unique_keys_values(d):
    swapped_d = {}
    frequency = get_frequency(list(d.values()))
    for k, v in list(d.items()):
        if frequency[v] != 1:
            continue
        swapped_d[v] = k
    return swapped_d


def swap_unique_keys_values(d):
    keys = list(d.keys())
    values = list(d.values())
    newd = {}
    for i in range(len(keys)):
        if values.count(values[i]) == 1:
            newd[values[i]] = keys[i]
    return newd


def weird_case(some_str):
    sen = ''
    i = True
    for letter in some_str:
        if i:
            sen += letter.upper()
        else:
            sen += letter.lower()
        if letter != ' ':
            i = not i
    return sen


def remove_zeros(nums):
    gway = []
    i = 0
    while i < len(nums):
        if int(nums[i]) != 0:
            gway.append(nums[i])
        i = i + 1
    nums = gway
    return nums

Take a list of numbers and removes the zeros from it.

assert remove_zeros([])==None and remove_zeros([])==None and remove_zeros([5202, -24344, -6528])==None and remove_zeros([5202, -24344, -6528])==None


def get_price(age):
    kids = '5'
    oap = '7'
    normal = '10'
    if age <= 16:
        return kids
    elif age >= 60:
        return oap
    else:
        return normal


def merge_lists(l1, l2):
    l3 = []
    for token in range(0, len(l1), 2):
        l3.append(l1[token])
    for i in range(0, len(l2), 2):
        l3.append(l2[i])
    return l3

Take two lists l1 and l2 and return a third list which contains every second element of l1 and l2.


def swap_keys_values(d):
    a = {}
    for k, v in list(d.items()):
        a[v] = k
    return a

Swap the keys of a dictionary with its values.


def swap_unique_keys_values(d):
    a = {}
    dups = {}
    for k, v in list(d.items()):
        if v not in dups:
            if v in a:
                del a[v]
                dups[v] = True
            else:
                a[v] = k
    return a


def swap_keys_values(d):
    nd = {v: k for k, v in list(d.items())}
    return nd


def swap_keys_values(d):
    new_d = {}
    for k, v in list(d.items()):
        new_d[v] = k
    return new_d


def swap_unique_keys_values(d):
    new_d = {}
    for k, v in list(d.items()):
        if v not in new_d:
            new_d[v] = k
        else:
            del new_d[v]
    return new_d


def swap_keys_values(old_dict):
    dict = {v: k for k, v in list(old_dict.items())}
    return new_dict


def swap_keys_values(my_dict):
    new_dict = {v: k for k, v in list(my_dict.items())}
    return new_dict


def get_price(age):
    if age <= 16:
        return 5
    if age >= 60:
        return 7
    else:
        return 10


def merge_lists(l1, l2):
    l3 = []
    i = 0
    while i < len(l1):
        l3.append(l1[i])[2]
        i = i + 1
    i = 0
    while i < len(l2):
        l3.append(l2[i])[2]
        i = i + 1
    return l3


def merge_lists(l1, l2):
    l3 = []
    i = 0
    while i < len(l1):
        l3.append(l1[i])
        i = i + 1
    i = 0
    while i < len(l2):
        l3.append(l2[i])
        i = i + 1
    return l3


def merge_lists(l1, l2):
    l3 = []
    i = 0
    while i < len(l1):
        l3.append(l1[i])
        i = i + 1
    i = 0
    while i < len(l2):
        l3.append(l2[i])
        i = i + 1
    return l3[::2]


def merge_lists(l1, l2):
    l3 = []
    i = 0
    while i < len(l1):
        l3.append(l1[i]).split(',')
        i = i + 1
    i = 0
    while i < len(l2):
        l3.append(l2[i])
        i = i + 1
    return l3[::2]


def merge_lists(l1, l2):
    l3 = []
    i = 0
    while i < len(l1):
        l3.append(l1[i]).split
        i = i + 1
    i = 0
    while i < len(l2):
        l3.append(l2[i])
        i = i + 1
    return l3[::2].split(',')


def swap_keys_values(d):
    return {v: k for k, v in list(a.items())}


def swap_keys_values(d):
    return {v: k for k, v in list(d.items())}


def swap_unique_keys_values(d):
    wards = {}
    for k, v in list(d.items()):
        if {k, v} not in wards:
            wards[k] = v
    return {v: k for k, v in list(d.items())}


def swap_unique_keys_values(d):
    wards = {}
    for k, v in list(d.items()):
        if v not in wards:
            wards[k] = v
    return {v: k for k, v in list(d.items())}


def swap_unique_keys_values(d):
    wards = {}
    for k, v in list(d.items()):
        if v not in wards:
            wards[k] = v
        elif v in wards:
            del d[v]
    return {v: k for k, v in list(d.items())}


def swap_unique_keys_values(d):
    wards = {}
    for k, v in list(d.items()):
        if v not in wards:
            wards[k] = v
        elif v in wards:
            del d[k]
    return {v: k for k, v in list(d.items())}


def swap_unique_keys_values(d):
    wards = {}
    for k, v in list(d.items()):
        if v not in wards:
            wards[k] = v
        elif v in wards:
            d.pop(k, v)
    return {v: k for k, v in list(d.items())}


def swap_unique_keys_values(d):
    wards = {}
    for k, v in list(d.items()):
        if v in wards:
            d.pop(k, v)
        if v not in wards:
            wards[k] = v
    return {v: k for k, v in list(d.items())}


def swap_unique_keys_values(d):
    wards = {}
    for k, v in list(d.items()):
        if v in wards:
            d.pop(k, v)
            d.pop(k, v)
        if v not in wards:
            wards[k] = v
    return {v: k for k, v in list(d.items())}


def swap_unique_keys_values(d):
    wards = {}
    for k, v in list(d.items()):
        if v in wards:
            d.pop(k, None)
        if v not in wards:
            wards[k] = v
    return {v: k for k, v in list(d.items())}


def swap_unique_keys_values(d):
    wards = {}
    for k, v in list(d.items()):
        if v in wards:
            del d[k, v]
        if v not in wards:
            wards[k] = v
    return {v: k for k, v in list(d.items())}


def swap_unique_keys_values(d):
    wards = {}
    for k, v in list(d.items()):
        if v in wards:
            del wards[k, v]
        if v not in wards:
            wards[k] = v
    return {v: k for k, v in list(d.items())}


def swap_unique_keys_values(d):
    wards = {}
    for k, v in list(d.items()):
        if v in wards:
            wards.pop([k])
        if v not in wards:
            wards[k] = v
    return {v: k for k, v in list(d.items())}


def swap_unique_keys_values(d):
    wards = {}
    for k, v in list(d.items()):
        if v in wards:
            bad[k] = v
        elif v not in wards:
            wards[k] = v
    return {v: k for k, v in list(d.items())}


def swap_unique_keys_values(d):
    wards = {}
    for k, v in list(d.items()):
        if v in wards:
            bad[k] = v
        else:
            wards[k] = v
    return {v: k for k, v in list(d.items())}


def swap_unique_keys_values(d):
    wards = {}
    bad = {}
    end = {}
    for k, v in list(d.items()):
        if v in wards:
            bad[k] = v
        elif v not in wards:
            wards[k] = v
    for wards in bad:
        if wards not in bad:
            end.update(wards)
    return {v: k for k, v in list(d.items())}


def swap_unique_keys_values(d):
    wards = {}
    bad = {}
    end = {}
    for k, v in list(d.items()):
        if v in wards:
            bad[k] = v
        elif v not in wards:
            wards[k] = v
    for wards in bad:
        if wards not in bad:
            end.update(wards)
    return {v: k for k, v in list(wards.items())}


def swap_unique_keys_values(d):
    wards = {}
    bad = {}
    end = {}
    for k, v in list(d.items()):
        if v in wards:
            bad[k] = v
        elif v not in wards:
            wards[k] = v
    for k, v in list(wards.items()):
        if v not in bad:
            end[k] = v
    return {v: k for k, v in list(end.items())}


def swap_unique_keys_values(d):
    wards = {}
    bad = {}
    end = {}
    for k, v in list(d.items()):
        if v in wards:
            bad[k] = v
        elif v not in wards:
            wards[k] = v
    for k, v in list(wards.items()):
        if v not in bad:
            end[k] = v
    return bad


def swap_unique_keys_values(d):
    wards = {}
    bad = {}
    end = {}
    for k, v in list(d.items()):
        if v not in wards:
            wards[k] = v
        elif v in wards:
            bad[k] = v
    for k, v in list(wards.items()):
        if v not in bad:
            end[k] = v
    return {v: k for k, v in list(end.items())}


def swap_unique_keys_values(d):
    wards = {}
    bad = {}
    end = {}
    for k, v in list(d.items()):
        if v not in wards:
            wards[k] = v
        elif v in wards:
            bad[k] = v
    for k, v in list(wards.items()):
        if v not in bad:
            end[k] = v
    return {v: k for k, v in list(wards.items())}


def swap_unique_keys_values(d):
    wards = {}
    bad = {}
    end = {}
    for k, v in list(d.items()):
        if v not in wards:
            wards[k] = v
        elif v in wards:
            del wards[k]
    return {v: k for k, v in list(wards.items())}


def swap_unique_keys_values(d):
    wards = {}
    bad = {}
    end = {}
    for k, v in list(d.items()):
        if v in wards:
            del wards[k]
        elif v not in wards:
            wards[k] = v
    return {v: k for k, v in list(wards.items())}


def swap_unique_keys_values(d):
    wards = {}
    bad = {}
    end = {}
    for k, v in list(d.items()):
        if v in wards:
            del wards[k, v]
        elif v not in wards:
            wards[k] = v
    return {v: k for k, v in list(wards.items())}


def swap_unique_keys_values(d):
    wards = {}
    bad = {}
    end = {}
    for k, v in list(d.items()):
        if v in wards:
            del wards[v]
        elif v not in wards:
            wards[k] = v
    return {v: k for k, v in list(wards.items())}


def swap_unique_keys_values(d):
    new_dict = {}
    values_once = set(d.values())
    unique_values = []
    for n in values_once:
        if list(d.values()).count(n) == 1:
            unique_values.append(n)
    for k, v in list(d.items()):
        if v in unique_values:
            new_dict[v] = k
    return new_dict


def swap_unique_keys_values(d):
    wards = {}
    bad = {}
    end = {}
    for k, v in list(d.items()):
        if v in wards:
            bad[k] = v
        elif v not in wards:
            wards[k] = v
    for k, v in list(wards.items()):
        if v in bad:
            del wards[v]
        elif v not in bad:
            end[k] = v
    return {v: k for k, v in list(end.items())}


def swap_keys_values(my_dict):
    new = {}
    for k, v in list(my_dict.items()):
        new[v] = k
    return new


def swap_keys_values(d):
    d_2 = []
    for entry in list(d.items()):
        u = entry[::-1]
        for k, v in u:
            d_2[k] = v
    return d_2


def swap_keys_values(d):
    d_2 = []
    for entry in list(d.items()):
        u = entry[::-1]
        for k, v in u.split(','):
            d_2[k] = v
    return d_2


def swap_keys_values(d):
    a = []
    for entry in list(d.items()):
        u = entry[::-1]
        a.append(u)
    return a


def swap_unique_keys_values(my_dict):
    new = {}
    seen = []
    unseen = []
    for k, v in list(my_dict.items()):
        if v in unseen:
            seen.append(v)
        else:
            unseen.append(v)
    for k in my_dict:
        if my_dict[k] not in seen and unseen:
            new[my_dict[k]] = k
    return new


def swap_keys_values(a):
    for entry in a:
        u = entry[::-1]
        a.append(u)
    return a


def swap_keys_values(d):
    a = []
    for entry in d:
        u = entry[::-1]
        a.append(u)
    return a


def swap_unique_keys_values(my_dict):
    seen = []
    unseen = []
    for key in list(my_dict.keys()):
        value = my_dict[key]
        if value in unseen:
            seen.append(value)
        else:
            unseen.append(value)
    new_dict = {v: k for k, v in list(my_dict.items()) if v not in seen}
    return new_dict


def swap_keys_values(d):
    return {v: k for k, v in list(d.items())}


def swap_unique_keys_values(d):
    new_dict = {}
    for k in d:
        v = d.has(k)
        if v in new_dict:
            del new_dict[v]
        else:
            new_dict[v] = k
    return new_dict


def swap_unique_keys_values(d):
    new_dict = {}
    for k in d:
        v = d.get(k)
        if v in new_dict:
            del new_dict[v]
        else:
            new_dict[v] = k
    return new_dict


def swap_unique_keys_values(d):
    count = {}
    for v in [v for k, v in list(d.items())]:
        if v not in count:
            count[v] = 1
        else:
            count[v] += 1
    multiples = [k for k, v in list(count.items()) if v > 1]
    new_d = {}
    for k, v in list(d.items()):
        if v not in multiples:
            new_d[v] = k
    return new_d


def swap_unique_keys_values(d):
    dic = {}
    a = []
    b = []
    for key in d:
        value = d[key]
        if value not in a:
            a.append(value)
        else:
            b.append(value)
    for key in d:
        value = d[key]
        if value not in b:
            dic[value] = key
            a.append(value)
    return dic


def swap_keys_values(d):
    d1 = {}
    items = list(d.items())
    for item in items:
        d1[item[1]] = item[0]
    return d1


def swap_keys_values(d):
    a = []
    d_2 = {}
    for entry in list(d.items()):
        swap = entry[::-1]
        a.append(swap)
    for k, v in a:
        d_2[k] = v
    return d_2
    main()


def swap_keys_values(d):
    a = []
    d_2 = {}
    for entry in list(d.items()):
        swap = entry[::-1]
        a.append(swap)
    for k, v in a:
        d_2[k] = v
    return d_2


def swap_unique_keys_values(d):
    d1 = {}
    items = list(d.items())
    for item in items:
        if item[1] not in d1:
            d1[item[1]] = item[0]
        else:
            d1.pop(item[1])
    return d1


def swap_keys_values(d):
    nd = {}
    for i, v in list(d.items()):
        nd[v] = i
    return nd


def swap_unique_keys_values(d):
    a = []
    d_2 = {}
    for entry in list(d.items()):
        swap = entry[::-1]
        a.append(swap)
    for k, v in a:
        d_2[k] = v
    return d_2


def swap_unique_keys_values(d):
    seen = []
    unseen = []
    for v in list(d.keys()):
        va = d[v]
        if va in unseen:
            seen.append(va)
        else:
            unseen.append(va)
        out = {v: k for k, v in list(d.items()) if v in unseen}
    return out


def swap_unique_keys_values(d):
    seen = []
    unseen = []
    for v in list(d.keys()):
        va = d[v]
        if va in unseen:
            seen.append(va)
        else:
            unseen.append(va)
        out = {v: k for k, v in list(d.items()) if v not in seen}
    return out


def swap_unique_keys_values(d):
    nd = {}
    for i, v in list(d.items()):
        if v not in nd:
            nd[v] = i
        elif v in nd:
            del nd[v]
    return nd


def swap_keys_values(d):
    d2 = {}
    ds = sorted(d.items, reverse=True)
    for k, v in ds:
        d2[v] = k
    return d2


def swap_keys_values(d):
    for key in d:
        key = tmp
        key = d[key]
        d[key] = tmp
    return d


def swap_keys_values(d):
    tmp = ''
    for key in d:
        key = tmp
        key = d[key]
        d[key] = tmp
    return d


def swap_keys_values(d):
    tmp = ''
    for key in d:
        key = key.split()
        tmp = key[0]
        key[0] = key[1]
        key[1] = tmp
    return d


def swap_keys_values(d):
    for key in d:
        key = key.split()
        tmp = key[0]
        key[0] = key[1]
        key[1] = tmp
    return tmp


def swap_keys_values(d):
    for key in d:
        key = key.split()
    return key


def swap_keys_values(d):
    dic = {}
    for key in d:
        value = d[key]
        dic[value] = key
    return dic


def swap_keys_values(d):
    d2 = {}
    ds = sorted(list(d.items()), reverse=True)
    print(ds)
    for k, v in ds:
        if v not in d2:
            d2[v] = k
    return d2


def swap_keys_values(d):
    d2 = {}
    ds = sorted(list(d.items()), reverse=True)
    for k, v in ds:
        if v not in d2:
            d2[v] = k
    return d2


def swap_unique_keys_values(d):
    d2 = {}
    d3 = {}
    ds = sorted(list(d.items()), reverse=True)
    for k, v in ds:
        if v not in d2:
            d2[v] = k
        else:
            d2[v] = 'N'
    ds2 = sorted(list(d2.items()), reverse=True)
    for k, v in ds2:
        if v != 'N':
            d3[k] = v
    return d3


def swap_unique_keys_values(d):
    return {[(b, a) for a, b in list(d.items()) if list(d.values()).count(b
        ) == 1]}


def swap_unique_keys_values(d):
    return {(b, a) for a, b in list(d.items()) if list(d.values()).count(b) ==
        1}


def swap_unique_keys_values(d):
    d2 = {}
    d3 = {}
    ds = sorted(list(d.items()), reverse=True)
    print(ds)
    for k, v in ds:
        if v not in d2:
            d2[v] = k
        else:
            d2[v] = 'X'
    print(d2)
    ds2 = sorted(list(d2.items()), reverse=True)
    print(ds2)
    for k, v in ds2:
        if v != 'X':
            d3[k] = v
    return d3


def swap_unique_keys_values(d):
    d2 = {}
    d3 = {}
    ds = sorted(list(d.items()), reverse=True)
    for k, v in ds:
        if v not in d2:
            d2[v] = k
        else:
            d2[v] = 'X'
    ds2 = sorted(list(d2.items()), reverse=True)
    for k, v in ds2:
        if v != 'X':
            d3[k] = v
    return d3


def swap_keys_values(d):
    new_d = {}
    for key in d:
        new_d[d[key]] = key
    return new_d


def swap_keys_values(dic):
    keys = list(dic.keys())
    values = list(dic.values())
    d = {}
    i = 0
    for v in values:
        d[keys[i]] = v[i]
        i = i + 1
    return d


def swap_keys_values(dic):
    keys = list(dic.keys())
    values = list(dic.values())
    d = {}
    i = 0
    for v in values:
        d[v[i]] = keys[i]
        i = i + 1


def swap_keys_values(dic):
    keys = list(dic.keys())
    values = list(dic.values())
    d = {}
    values = []
    keys = []
    for v in list(dic.values()):
        values.append(str(v))
    for k in list(dic.keys()):
        keys.append(k)
    i = 0
    while i < len(values):
        d[values[i]] = keys[i]
        i = i + 1
    return d


def swap_keys_values(dic):
    keys = list(dic.keys())
    values = list(dic.values())
    d = {}
    values = []
    keys = []
    for v in list(dic.values()):
        values.append(v)
    for k in list(dic.keys()):
        keys.append(k)
    i = 0
    while i < len(values):
        d[values[i]] = keys[i]
        i = i + 1
    return sorted(d)


def swap_keys_values(dic):
    keys = list(dic.keys())
    values = list(dic.values())
    d = {}
    values = []
    keys = []
    for v in list(dic.values()):
        values.append(str(v))
    for k in list(dic.keys()):
        keys.append(k)
    i = 0
    while i < len(values):
        d[values[i]] = keys[i]
        i = i + 1
    return sorted(d)


def swap_keys_values(dic):
    keys = list(dic.keys())
    values = list(dic.values())
    d = {}
    values = []
    keys = []
    for v in list(dic.values()):
        values.append(v)
    for k in list(dic.keys()):
        keys.append(k)
    i = 0
    while i < len(values):
        d[values[i]] = keys[i]
        i = i + 1
    return d


def swap_keys_values(d):
    print({v: k for k, v in list(d.items())})


def swap_unique_keys_values(dic):
    keys = list(dic.keys())
    values = list(dic.values())
    d = {}
    values = []
    keys = []
    for v in list(dic.values()):
        values.append(v)
    for k in list(dic.keys()):
        keys.append(k)
    i = 0
    while i < len(values):
        if values[i] not in d:
            d[values[i]] = keys[i]
        i = i + 1
    return d


def swap_unique_keys_values(dic):
    keys = list(dic.keys())
    values = list(dic.values())
    d = {}
    values = []
    keys = []
    for v in list(dic.values()):
        values.append(v)
    for k in list(dic.keys()):
        keys.append(k)
    i = 0
    while i < len(values):
        if values[i] not in d:
            d[values[i]] = keys[i]
        elif values[i] in d:
            del d[values[i]]
        i = i + 1
    return d


def swap_keys_values(d):
    d = {v: k for k, v in list(d.items())}
    print(list(d.items()))


def swap_keys_values(d):
    d = {v: k for k, v in list(d.items())}
    list(d.items())


def swap_keys_values(d):
    new = {v: k for k, v in list(d.items())}


def swap_keys_values(d):
    new = {v: k for k, v in list(d.items())}
    return new


def swap_unique_keys_values(d):
    values = [d[k] for k in d]
    new = {v: k for k, v in list(d.items()) if values.count(v) == 1}
    return new


def swap_keys_values(x):
    d = {v: k for k, v in list(d.items())}
    return x


def swap_keys_values(x):
    d = {v: k for k, v in list(a.items())}
    return x


def swap_keys_values(x):
    d = {v: k for k, v in list(x.items())}
    return x


def swap_keys_values(x):
    d = dict((v, k) for k, v in list(x.items()))
    return x


def swap_keys_values(x):
    d = dict((k, v) for v, k in list(x.items()))
    return x


def swap_keys_values(x):
    for key, v in list(x.items()):
        d[v] = key
    return d


def swap_keys_values(x):
    d = {}
    for key, v in list(x.items()):
        d[v] = key
    return d


def swap_keys_values(x):
    d = {v: k for k, v in list(x.items())}
    return d


def swap_unique_keys_values(d):
    d2 = {}
    d3 = {}
    sortd = sorted(list(d.items()), reverse=True)
    return sortd


def swap_keys_values(d):
    dic = {}
    for key in d:
        d[key] = value
        d[value] = d[key]
    return dic


def swap_keys_values(d):
    dic = {}
    for key in d:
        value = d[key]
        dic[value] = d[key]
    return dic


def swap_keys_values(d):
    dic = {}
    for key in d:
        value = d[key]
        dic[value] = key
    return dic


def swap_unique_keys_values(d):
    unique = {}
    new_d = {}
    for key in d:
        if d[key] not in unique:
            unique[d[key]] = 0
        unique[d[key]] = unique[d[key]] + 1
    for key in d:
        if unique[d[key]] == 1:
            new_d[d[key]] = key
    return new_d


def swap_unique_keys_values(x):
    sorx = sorted(d.items, reverse=True)
    x1 = {}
    x2 = {}
    for keys, values in sorx:
        if v not in x1:
            x1[values] = keys
        else:
            x1[v] = 'N'
    sorx2 = sorted(list(x1.items()), revers=True)
    for keys, values in sorx2:
        if v != sorx2:
            x2[keys] = values
    return x2


def swap_unique_keys_values(x):
    sorx = sorted(x.items, reverse=True)
    x1 = {}
    x2 = {}
    for keys, values in sorx:
        if v not in x1:
            x1[values] = keys
        else:
            x1[v] = 'N'
    sorx2 = sorted(list(x1.items()), revers=True)
    for keys, values in sorx2:
        if v != sorx2:
            x2[keys] = values
    return x2


def swap_unique_keys_values(x):
    x1 = {}
    x2 = {}
    sorx = sorted(x.items, reverse=True)
    for keys, values in sorx:
        if v not in x1:
            x1[values] = keys
        else:
            x1[v] = 'N'
    sorx2 = sorted(list(x1.items()), revers=True)
    for keys, values in sorx2:
        if v != sorx2:
            x2[keys] = values
    return x2


def swap_unique_keys_values(x):
    x1 = {}
    x2 = {}
    sorx = sorted(list(x.items()), reverse=True)
    for keys, values in sorx:
        if v not in x1:
            x1[values] = keys
        else:
            x1[v] = 'N'
    sorx2 = sorted(list(x1.items()), revers=True)
    for keys, values in sorx2:
        if v != sorx2:
            x2[keys] = values
    return x2


def swap_unique_keys_values(x):
    x1 = {}
    x2 = {}
    sorx = sorted(list(x.items()), reverse=True)
    for keys, values in sorx:
        if values not in x1:
            x1[values] = keys
        else:
            x1[v] = 'N'
    sorx2 = sorted(list(x1.items()), revers=True)
    for keys, values in sorx2:
        if values != sorx2:
            x2[keys] = values
    return x2


def swap_unique_keys_values(x):
    x1 = {}
    x2 = {}
    sorx = sorted(list(x.items()), reverse=True)
    for keys, values in sorx:
        if values not in x1:
            x1[values] = keys
        else:
            x1[values] = 'N'
    sorx2 = sorted(list(x1.items()), revers=True)
    for keys, values in sorx2:
        if values != sorx2:
            x2[keys] = values
    return x2


def swap_unique_keys_values(x):
    x1 = {}
    x2 = {}
    sorx = sorted(list(x.items()), reverse=True)
    for keys, values in sorx:
        if values not in x1:
            x1[values] = keys
        else:
            x1[values] = 'N'
    sorx2 = sorted(list(x1.items()), reverse=True)
    for keys, values in sorx2:
        if values != sorx2:
            x2[keys] = values
    return x2


def swap_unique_keys_values(d):
    q = {}
    a = []
    b = []
    for key in d:
        value = d[key]
        if value not in a:
            a.append(value)
        else:
            b.append(value)
    for key in d:
        value = d[key]
        if value not in b:
            q[value] = key
            a.append(value)
    return q


def swap_unique_keys_values(x):
    x1 = {}
    x2 = {}
    sorx = sorted(list(d.items()), reverse=True)
    for keys, values in sorx:
        if values not in x1:
            x1[values] = keys
        else:
            x1[values] = 'N'
    sorx2 = sorted(list(x1.items()), reverse=True)
    for keys, values in sorx2:
        if values != 'N':
            x2[keys] = values
    return x2


def swap_unique_keys_values(x):
    x1 = {}
    x2 = {}
    sorx = sorted(list(x.items()), reverse=True)
    for keys, values in sorx:
        if values not in x1:
            x1[values] = keys
        else:
            x1[values] = 'N'
    sorx2 = sorted(list(x1.items()), reverse=True)
    for keys, values in sorx2:
        if values != 'N':
            x2[keys] = values
    return x2


def swap_keys_values(d):
    d = {}
    for k, v in list(d.items()):
        d[v] = k
    return d


def swap_keys_values(d):
    new_d = {val: key for key, val in list(d.items())}
    return new_d


def swap_keys_values(d):
    nd = {}
    for k, v in list(d.items()):
        nd[v] = k
    return nd


def swap_unique_keys_values(d):
    nd = {}
    to_delete = []
    for k, v in list(d.items()):
        if v in nd:
            to_delete.append(v)
        else:
            nd[v] = k
    for k in to_delete:
        del nd[k]
    return nd


def swap_unique_keys_values(d):
    counter = {}
    for v in list(d.values()):
        counter[v] = counter.get(v, 0) + 1
    unique = {k: v for k, v in list(d.items()) if counter[v] == 1}
    new_d = {val: key for key, val in list(unique.items())}
    return new_d


def swap_unique_keys_values(d):
    d2 = {}
    d3 = {}
    ds = sorted(list(d.items()), reverse=True)
    for k, v in ds:
        if v not in d2:
            d2[v] = k
        else:
            d2[v] = 'N'
    ds2 = sorted(list(d2.items()), reverse=True)
    for k, v in ds2:
        if v != 'N':
            d3[k] = v
    return d3


def swap_keys_values(d):
    d2 = {}
    for k, v in list(d.items()):
        d2[v] = k
    return d2


def swap_unique_keys_values(d):
    d2 = {}
    for k, v in list(d.items()):
        if v not in list(d2.values()):
            d2[k] = v
    d3 = {}
    for k, v in list(d2.items()):
        d3[v] = k
    return d3


def swap_unique_keys_values(d):
    d2 = {}
    for k, v in list(d.items()):
        if v not in list(d2.values()):
            d2[k] = v
    print(d2)
    d3 = {}
    for k, v in list(d2.items()):
        d3[v] = k
    return d3


def swap_unique_keys_values(d):
    d2 = {}
    for k, v in list(d.items()):
        if v not in list(d2.values()):
            d2[k] = v
        else:
            del d2[k]
    print(d2)
    d3 = {}
    for k, v in list(d2.items()):
        d3[v] = k
    return d3


def swap_unique_keys_values(d):
    d2 = {}
    for k, v in list(d.items()):
        if list(d.values()).count(v) == 1:
            d2[k] = v
    print(d2)
    d3 = {}
    for k, v in list(d2.items()):
        d3[v] = k
    return d3


def swap_unique_keys_values(d):
    d2 = {}
    for k, v in list(d.items()):
        if v not in list(d2.values()):
            d2[k] = v
    d3 = {}
    for k, v in list(d2.items()):
        if v not in list(d.values()):
            d3[v] = k
    return d3


def swap_unique_keys_values(d):
    d2 = {}
    d3 = {}
    for k, v in list(d.items()):
        if v not in d2:
            d2[v] = k
        else:
            d2[v] = 'X'
    print(d2)


def swap_unique_keys_values(d):
    d2 = {}
    d3 = {}
    for k, v in list(d.items()):
        if v not in d2:
            d2[v] = k
        else:
            d2[v] = 'X'
    for k, v in list(d2.items()):
        if v != 'X':
            d3[k] = v
    return d3


def swap_keys_values(d):
    swappedDict = {}
    for i in d:
        swappedDict[d[i]] = i
    return swappedDict


def swap_unique_keys_values(d):
    swappedDict = {}
    for i in d:
        if d[i] in swappedDict:
            del swappedDict[d[i]]
        else:
            swappedDict[d[i]] = i
    return swappedDict


def swap_keys_values(d):
    new_dict = {}
    for key, value in d:
        return d


def swap_keys_values(d):
    new_dict = {}
    for key, value in list(d.items()):
        return d


def swap_keys_values(d):
    new_dict = {}
    for key, value in list(d.items()):
        new_dict[d[value]] = d[key]
    return new_dict


def swap_keys_values(d):
    new_dict = {}
    for key, value in list(d.items()):
        new_dict[value] = d[key]
    return new_dict


def swap_keys_values(d):
    new_dict = {}
    for key, value in list(d.items()):
        new_dict[value] = key
    return new_dict


def swap_unique_keys_values(d):
    new_dict = {}
    keys = []
    values = []
    for key, value in list(d.items()):
        keys.append(value)
        values.append(key)
    return keys, values


def swap_keys_values(d):
    return {v: k for k, v in list(d.items())}


def swap_unique_keys_values(d):
    values = list(d.values())
    return {v: k for k, v in list(d.items()) if values.count(v) == 1}


def swap_keys_values(a):
    newdict = {}
    for l, m in list(a.items()):
        newdict[m] = l
    return newdict


def swap_unique_keys_values(a):
    newdict = {}
    for l, m in list(a.items()):
        if m not in newdict:
            newdict[m] = l
        else:
            del newdict[m]
    return newdict


def swap_unique_keys_values(d):
    a = {}
    b = {}
    c = sorted(list(d.items()), reverse=True)
    for k, v in c:
        if v not in b:
            b[v] = k
        else:
            b[v] = 'A'
    e = sorted(list(a.items()), reverse=True)
    for k, v in e:
        if v != 'A':
            b = v
    return b


def swap_unique_keys_values(d):
    a2 = {}
    a3 = {}
    ar = sorted(list(d.items()), reverse=True)
    for k, v in ar:
        if v not in a2:
            a2[v] = k
        else:
            a2[v] = 'N'
    ar2 = sorted(list(a2.items()), reverse=True)
    for k, v in ar2:
        if v != 'N':
            a3[k] = v
    return a3


def swap_keys_values(d):
    a2 = {}
    a3 = {}
    ar = sorted(list(d.items()), reverse=True)
    for k, v in ar:
        a2[v] = k
    ar2 = sorted(list(a2.items()), reverse=True)
    for k, v in ar2:
        a3[k] = v
    return a3


def swap_keys_values(d):
    return {d[key]: key for key in d}


def swap_unique_keys_values(d):
    new_dict = {}
    for k in d:
        v = d.get(k)
        if v in new_dict:
            del new_dict[v]
        else:
            new_dict[v] = k
    return new_dict


def swap_unique_keys_values(d):
    return dict([(v, k) for k, v in list(d.items()) if list(d.values()).
        count(v) == 1])


def swap_unique_keys_values(d):
    d2 = {}
    d3 = {}
    ds = sorted(list(d.items()), reverse=True)
    for k, v in ds:
        if v not in d2:
            d2[k] = v
        else:
            d2[v] = 'N'
    d2 = sorted(list(d2.items()), reverse=True)
    for k, v in ds2:
        if v != 'N':
            d3[k] = v
    return d3


def swap_unique_keys_values(d):
    d2 = {}
    d3 = {}
    ds = sorted(list(d.items()), reverse=True)
    for k, v in ds:
        if v not in d2:
            d2[k] = v
        else:
            d2[v] = 'N'
    ds2 = sorted(list(d2.items()), reverse=True)
    for k, v in ds2:
        if v != 'N':
            d3[k] = v
    return d3


def swap_unique_keys_values(d):
    nd = {}
    for k, v in list(d.items()):
        if not v in nd:
            nd[v] = k
        else:
            del nd[v]
    return nd


def swap_unique_keys_values(d):
    d2 = {}
    d3 = {}
    ds = sorted(list(d.items()), reverse=True)
    for k, v in ds:
        if v not in d2:
            d2[k] = v
        else:
            d2[v] = 'N'
    ds2 = sorted(list(d2.items()), reverse=True)
    for k, v in ds2:
        if v != 'N':
            d3[k] = v
    return d2


def swap_unique_keys_values(d):
    d2 = {}
    d3 = {}
    ds = sorted(list(d.items()), reverse=True)
    for k, v in ds:
        if v in d2:
            d2[v] = 'N'
        else:
            d2[v] = k
    ds2 = sorted(list(d2.items()), reverse=True)
    for k, v in ds2:
        if v != 'N':
            d3[k] = v
    return d2


def swap_unique_keys_values(d):
    d2 = {}
    d3 = {}
    ds = sorted(list(d.items()), reverse=True)
    for k, v in ds:
        if v in d2:
            d2[v] = 'N'
        else:
            d2[v] = k
    ds2 = sorted(list(d2.items()), reverse=True)
    for k, v in ds2:
        if v != 'N':
            d3[k] = v
    return d3


def swap_keys_values(d):
    new_dict = {v: k for k, v in list(d.items())}
    return new_dict


def swap_keys_values(s):
    dic = {}
    for key, value in s.item():
        dic[value] = key
    return dic


def swap_keys_values(s):
    new_dict = {}
    for key, value in list(s.items()):
        new_dict[value] = key
    return new_dictict


def swap_keys_values(s):
    new_dict = {}
    for key, value in list(s.items()):
        new_dict[value] = key
    return new_dict


def swap_unique_keys_values(d):
    d2 = {}
    d3 = []
    ds = sorted(list(d.items()), reverse=True)
    for k, v in ds:
        if v not in d2:
            d2[v] = kd
        else:
            d2[v] = 'N'
        ds2 = sorted(list(d2.items()), reverse=True)
        for k, v in ds2:
            if v != 'N':
                d3[k] = v
        return d3


def swap_unique_keys_values(d):
    d2 = {}
    d3 = []
    ds = sorted(list(d.items()), reverse=True)
    for k, v in ds:
        if v not in d2:
            d2[v] = k
        else:
            d2[v] = 'N'
        ds2 = sorted(list(d2.items()), reverse=True)
        for k, v in ds2:
            if v != 'N':
                d3[k] = v
        return d3


def swap_unique_keys_values(d):
    d2 = {}
    d3 = {}
    ds = sorted(list(d.items()), reverse=True)
    for k, v in ds:
        if v not in d2:
            d2[v] = k
        else:
            d2[v] = 'N'
        ds2 = sorted(list(d2.items()), reverse=True)
        for k, v in ds2:
            if v != 'N':
                d3[k] = v
        return d3


def swap_unique_keys_values(s):
    new_dict = {}
    for key, value in list(s.items()):
        if s[key] not in new_dict:
            new_dict[value] = key
    return new_dict


def swap_unique_keys_values(s):
    new_dict = {}
    for key, value in list(s.items()):
        if s[key] not in s:
            new_dict[value] = key
    for key, value in new_dict:
        if new_dict[key] in s:
            del new_dict[key]
    return new_dict


def swap_keys_values(dictionary):
    new_dictionary = {}
    for key in dictionary:
        new_dictionary[dictionary[key]] = key
    return new_dictionary


def swap_unique_keys_values(dictionary):
    values = []
    new_dict = {}
    for key in dictionary:
        values.append(dictionary[key])
    for key, value in list(dictionary.items()):
        if values.count(value) == 1:
            new_dict[value] = key
    return new_dict


def swap_unique_keys_values(s):
    new_dict = {}
    for key, value in list(s.items()):
        if s.count(s[key]) == 1:
            new_dict[value] = key
    return new_dict


def swap_keys_values(d):
    return {v: k for k, v in list(d.items())}


def swap_unique_keys_values(s):
    new_dict = {}
    c = Counter(list(s.values()))
    l = [k for k, v in list(s.items()) if c[v] < 2]
    for key, value in list(s.items()):
        if s[key] in l:
            new_dict[value] = key
    return new_dict


def swap_unique_keys_values(s):
    new_dict = {}
    c = Counter(list(s.values()))
    l = [k for k, v in list(s.items()) if c[v] < 2]
    for key, value in list(s.items()):
        if s[key] not in l:
            new_dict[value] = key
    return new_dict


def swap_unique_keys_values(s):
    new_dict = {}
    c = Counter(list(s.values()))
    l = [k for k, v in list(s.items()) if c[v] == 1]
    for key, value in list(s.items()):
        if s[key] in l:
            new_dict[value] = key
    return new_dict


def swap_unique_keys_values(s):
    new_dict = {}
    c = Counter(list(s.values()))
    l = [k for k, v in list(s.items()) if c[v] == 1]
    print(l)
    for key, value in list(s.items()):
        if s[key] in l:
            new_dict[value] = key
    return new_dict


def swap_unique_keys_values(s):
    new_dict = {}
    c = Counter(list(s.values()))
    l = [k for k, v in list(s.items()) if c[v] == 1]
    print(l)
    for key, value in list(s.items()):
        if key in l:
            new_dict[value] = key
    return new_dict


def swap_unique_keys_values(s):
    new_dict = {}
    c = Counter(list(s.values()))
    l = [k for k, v in list(s.items()) if c[v] == 1]
    for key, value in list(s.items()):
        if key in l:
            new_dict[value] = key
    return new_dict


def swap_unique_keys_values(d):
    e = {}
    for left, right in d:
        if right not in e:
            e[left] = right
    return {v: k for k, v in list(e.items())}


def swap_unique_keys_values(d):
    e = {}
    for s in d:
        if d[s] not in e:
            e[s] = d[s]
    return {v: k for k, v in list(e.items())}


def swap_unique_keys_values(d):
    e = {}
    for s in d:
        if d[s] and s not in e:
            e[s] = d[s]
    return {v: k for k, v in list(e.items())}


def swap_unique_keys_values(d):
    e = {}
    for s in d:
        if d[s] and s not in e:
            e[s] = d[s]
        print(d[s])
    return {v: k for k, v in list(e.items())}


def swap_unique_keys_values(d):
    e = {}
    for s in d:
        if d[s] not in e:
            e[s] = d[s]
        elif d[s] in e:
            del s
    return {v: k for k, v in list(e.items())}


def swap_unique_keys_values(d):
    e = {}
    for s in d:
        if d[s] not in e:
            e[s] = d[s]
        elif d[s] in e:
            del s
    print(e)
    return {v: k for k, v in list(e.items())}


def swap_unique_keys_values(d):
    e = {}
    for s in d:
        if d[s] not in e:
            e[s] = d[s]
        elif d[s] in e:
            del d[s]
    print(e)
    return {v: k for k, v in list(e.items())}


def swap_unique_keys_values(d):
    e = {}
    for s in d:
        if d[s] not in e:
            e[s] = d[s]
        elif d[s] in e:
            e.remove(s)
    print(e)
    return {v: k for k, v in list(e.items())}


def swap_unique_keys_values(d):
    e = {}
    for s in d:
        if d[s] in d:
            d.remove(s)
    print(d)
    return {v: k for k, v in list(d.items())}


def swap_unique_keys_values(d):
    e = {}
    h = {}
    for k, v in d:
        if v in e:
            e[k] = v
        else:
            e[k] = 'n'
    for k, v in e:
        if v != 'n':
            h[k] = v
    return {v: k for k, v in list(d.items())}


def swap_keys_values(d):
    d_swap = {}
    for x in d:
        d_swap[d[x]] = x
    return d_swap


def swap_unique_keys_values(d):
    d_swap = {}
    for x in d:
        if d[x] not in d_swap:
            d_swap[d[x]] = x
    return d_swap


def swap_unique_keys_values(d):
    d_swap = {}
    d_tmp = {}
    for x in d:
        d_swap[d[x]] = x
    return d_swap


def swap_unique_keys_values(d):
    d_swap = {}
    for x in d:
        d_swap[d[x]] = x
        if d[x] in d_swap:
            del d_swap[d[x]]
    return d_swap


def swap_unique_keys_values(d):
    d_swap = {}
    for x in d:
        if d[x] in d_swap:
            del d_swap[d[x]]
        else:
            d_swap[d[x]] = x
    return d_swap


def swap_keys_values(d):
    new = {}
    for k, v in list(d.items()):
        new[v] = k
    return d


def swap_keys_values(d):
    new = {}
    for k, v in list(d.items()):
        new[v] = k
    return new


def swap_unique_keys_values(my_dict):
    dic = {}
    for key, value in list(my_dict.items()):
        if value in dic:
            del dic[value]
        else:
            dic[value] = key
    return dic


def swap_unique_keys_values(d):
    return {(b, a) for a, b in list(d.items()) if list(d.values()).count(b) ==
        1}


def swap_unique_keys_values(d):
    return {[(b, a) for a, b in list(d.items()) if list(d.values()).count(b
        ) == 1]}


def swap_unique_keys_values():
    d2 = {}
    d3 = {}
    ds = sorted(list(d.items()), reverse=True)
    for k, v in ds:
        if v not in d2:
            d2[v] = k
        else:
            d2[v] = 'N'
    ds2 = sorted(list(d2.items()), reverse=True)
    for k, v in ds2:
        if v != 'N':
            d3[k] = v
    return d3


def swap_unique_keys_values(d):
    d2 = {}
    d3 = {}
    ds = sorted(list(d.items()), reverse=True)
    for k, v in ds:
        if v not in d2:
            d2[v] = k
        else:
            d2[v] = 'N'
    ds2 = sorted(list(d2.items()), reverse=True)
    for k, v in ds2:
        if v != 'N':
            d3[k] = v
    return d3


def swap_keys_values(d):
    dic = {}
    for k, v in list(d.items()):
        dic[v] = k
    return dic


def swap_unique_keys_values(d):
    dic = {}
    for k, v in list(d.items()):
        if v not in dic:
            dic[v] = k
        else:
            del dic[v]
    return dic


def swap_keys_values(dic):
    keys = list(dic.keys())
    vals = list(dic.values())
    newdic = {}
    i = 0
    for val in vals:
        newdic[val] = keys[i]
        i += 1
    return newdic


def swap_unique_keys_values(dic):
    keys = list(dic.keys())
    vals = list(dic.values())
    newdic = {}
    i = 0
    for val in vals:
        if vals.count(val) == 1:
            newdic[val] = keys[i]
        i += 1
    return newdic


def swap_keys_values(d):
    d2 = {}
    for k, v in list(d.items()):
        d2[v] = k
    return d2


def swap_keys_values(dic):
    return {val: key for key, val in list(dic.items())}


def swap_unique_keys_values(dic):
    new = {}
    new = {val: key for key, val in list(dic.items())}
    return new


def swap_unique_keys_values(d):
    lst = []
    for k in list(d.keys()):
        v = d[k]
        lst.append(v)
    new_d = {v: k for k, v in list(d.items()) if lst.count(v, 0, len(lst)) == 1
        }
    return new_d


def swap_unique_keys_values(d):
    lst = []
    for k in list(d.keys()):
        v = d[k]
        lst.append(v)
    new_d = {v: k for k, v in list(d.items()) if lst.count(v) == 1}
    return new_d


def swap_unique_keys_values(d):
    a = [v for v in list(d.values())]
    a = [v for v in a if a.count(v) == 1]
    return {v: k for k, v in list(d.items()) if v in a}


def swap_keys_values(d):
    keys = []
    vals = []
    new_d = {}
    for k, v in list(d.items()):
        keys.append(v)
        vals.append(k)
    y = 0
    for x in keys:
        new_d[x] = vals[y]
        y = y + 1
    return new_d


def swap_keys_values(d):
    new_dict = {v: k for k, v in list(d.items())}
    return new_dict


def remove_zeros(nums):
    gway = []
    i = 0
    while i < len(nums):
        if int(nums[i]) == 0:
            del nums[i]
        if int(nums[i]) == 0:
            del nums[i]
        i = i + 1
    return nums


def get_price(age):
    kids = '5'
    oap = '7'
    normal = '10'
    if age <= 16:
        return kids
    elif age >= 60:
        return oap
    else:
        return normal


def weird_case(some_str):
    sen = ''
    i = True
    for letter in some_str:
        if i:
            sen += letter.upper()
        else:
            sen += letter.lower()
        if letter != ' ':
            i = not i
    return sen


def merge_lists(l1, l2):
    l3 = []
    for token in range(0, len(l1), 2):
        l3.append(l1[token])
    for i in range(0, len(l2), 2):
        l3.append(l2[i])
    return l3


def swap_unique_keys_values(d):
    keys = []
    new_d = {}
    old_vals = list(d.values())
    unique_vals = [v for v in old_vals if old_vals.count(v) < 2]
    for k, v in list(d.items()):
        if v in unique_vals:
            keys.append(k)
    new_keys = unique_vals
    new_vals = keys
    y = 0
    for x in new_keys:
        new_d[x] = new_vals[y]
        y = y + 1
    return new_d


def swap_keys_values(d):
    new_d = {}
    for k, v in list(d.items()):
        new_d[v] = k
    return new_d


def swap_unique_keys_values(d):
    new_d = {}
    for k, v in list(d.items()):
        if v not in new_d:
            new_d[v] = k
    return new_d


def swap_keys_values(d):
    new_dict = {}
    for k, v in list(d.items()):
        new_dict[v] = k
    return new_dict


def swap_unique_keys_values(d):
    keys = list(d.keys())
    values = list(d.values())
    new_dict = {}
    for i in range(len(keys)):
        if values.count(values[i]) == 1:
            new_dict[values[i]] = keys[i]
    return new_dict


def swap_keys_values(d):
    inv = {v: k for k, v in list(d.items())}
    return inv


def swap_unique_keys_values(d):
    new_d = {}
    seen = []
    for v in list(d.values()):
        if v not in seen:
            seen.append(v)
        elif v in seen:
            seen.remove(v)
    for k, v in list(d.items()):
        if v in seen:
            new_d[v] = k
    return new_d


def swap_unique_keys_values(d):
    inv = {v: k for k, v in list(d.items())}
    return inv


def swap_unique_keys_values(d):
    d = dict(set(d))
    inv = {v: k for k, v in list(d.items())}
    return inv


def get_price(age):
    age = int(age)
    if age <= 16:
        return '5'
    elif age >= 60:
        return '7'
    else:
        return '10'


def remove_zeros(list):
    i = 0
    while i < len(list):
        if list[i] == 0:
            list.remove(list[i])
        i += 1


def merge_lists(l1, l2):
    end_list = []
    i = 0
    while i < len(l1):
        end_list.append(l1[i])
        i += 2
    i = 0
    while i < len(l2):
        end_list.append(l2[i])
        i += 2
    return end_list


def weird_case(some_str):
    some_str = some_str.lower()
    sent = list(some_str)
    i = 0
    while i < len(sent):
        if sent[i].isalpha() and i % 1 == 0:
            sent[i] = sent[i].upper()
            i += 1
        i += 1
    return ''.join(sent)


def weird_case(some_str):
    some_str = some_str.lower()
    sent = list(some_str)
    i = 0
    while i < len(sent):
        if sent[i].isalpha() and i % 2 == 0:
            sent[i] = sent[i].upper()
            i += 1
        i += 1
    return ''.join(sent)


def weird_case(some_str):
    some_str = some_str.lower()
    sent = list(some_str)
    i = 0
    while i < len(sent):
        if sent[i].isalpha() and i % 1 == 0:
            sent[i] = sent[i].upper()
            i += 2
        i += 2
    return ''.join(sent)


def weird_case(some_str):
    some_str = some_str.lower()
    sent = list(some_str)
    i = 0
    while i < len(sent):
        if sent[i].isalpha() and i % 2 == 0:
            sent[i] = sent[i].upper()
            i += 2
        i += 2
    return ''.join(sent)


def get_price(age):
    print('What is your age?')
    age = eval(input())
    if int(age) < 16:
        print('you pay 5 euro')
    elif int(age) > 60:
        print('you pay 7 euro')
    else:
        print('you pay 10 euro')


def get_price(age):
    age = eval(input())
    if int(age) < 16:
        print('you pay 5 euro')
    elif int(age) > 60:
        print('you pay 7 euro')
    else:
        print('you pay 10 euro')


def get_price(age):
    age = eval(input())
    if int(age) < 16:
        print('5')
    elif int(age) > 60:
        print('7')
    else:
        print('10')


def get_price(age):
    age = eval(input())
    i = 0
    while i < len(age):
        if int(age) < 16:
            print('5')
        elif int(age) > 60:
            print('7')
        else:
            print('10')
        i = 1 + i


def get_price(age):
    if int(age) < 16:
        print('5')
    elif int(age) > 60:
        print('7')
    else:
        print('10')
    i = 1 + i


def get_price(age):
    if int(age) < 16:
        print('5')
    elif int(age) > 60:
        print('7')
    else:
        print('10')


def get_price(age):
    if int(age) < 16:
        print('5')
    elif int(age) > 60:
        print('7')
    else:
        print('10'.rstrip('\n'))


def get_price(age):
    if int(age) < 16:
        return '5'
    elif int(age) > 60:
        return '7'
    else:
        return '10'


def merge_lists(l1, l2):
    i = 0
    while i < len(l2):
        l1.append(l2[i])
        i = i + 1
    i = 0
    while i < len(l1):
        if i % 2 == 1 and i != 0:
            l1.remove(l1[i])
        i = i + 1
    return l1


def weird_case(some_str):
    import sys
    upper_list = ()
    some_str = sys.stdin.readline()
    letters = some_str.strip('\n').split(' ')
    i = 0
    while i < len(letters):
        if i % 2 == 1 and i != 0:
            letters[i].upper()
        i = 1 + i
    upper_list.append(letters)
    return upper_list


def weird_case(some_str):
    import sys
    upper_str = ()
    some_str = sys.stdin.readline()
    letters = some_str.strip('\n').split(' ')
    i = 0
    while i < len(letters):
        if i % 2 == 1 and i != 0:
            letters[i] = letters[i].upper()
        i = 1 + i
    upper_str.append(letters)
    return upper_list


def weird_case(some_str):
    A = ' '
    a = []
    line = some_str.strip('\n').split(A)
    i = 0
    while i < len(line):
        word = line[i]
        x = 0
        while x < len(word):
            a.append(word[x])
            x = x + 1
        a.append(A)
        i = i + 1
    del a[len(a) - 1]
    x = -1
    i = 0
    while i < len(a):
        if a[i] != A:
            x = x + 1
        if x == 0 or x % 2 == 0:
            a[i] = str(a[i].upper())
        i = i + 1
    return A.join(a)


def weird_case(some_str):
    A = ' '
    a = []
    line = some_str.strip('\n').split(A)
    i = 0
    while i < len(line):
        word = line[i]
        x = 0
        while x < len(word):
            a.append(word[x])
            x = x + 1
        a.append(A)
        i = i + 1
    del a[len(a) - 1]
    x = -1
    i = 0
    while i < len(a):
        if a[i] != A:
            x = x + 1
        if x == 0 or x % 2 == 0:
            a[i] = str(a[i].upper())
        i = i + 1
    return ''.join(a)


def remove_zeros(list):
    i = 0
    while i < len[a]:
        if int(a[i]) == 0:
            a.remove(a[i])
            i = i + 1
        i = i + 1


def remove_zeros(list):
    a = []
    i = 0
    while i < len[a]:
        if int(a[i]) == 0:
            a.remove(a[i])
            i = i + 1
        i = i + 1


def remove_zeros(list):
    b = []
    i = 0
    while i < len[a]:
        if int(a[i]) == 0:
            a.remove(a[i])
            i = i + 1
        i = i + 1


def remove_zeros(a):
    i = 0
    while i < len[a]:
        if int(a[i]) == 0:
            a.remove(a[i])
            i = i + 1
        i = i + 1


def remove_zeros(list):
    i = 0
    while i < len[a]:
        if int(a[i]) == 0:
            a.remove(a[i])
            i = i - 1
        i = i + 1


def remove_zeros(list):
    i = 0
    while i < len(a):
        if int(a[i]) == 0:
            a.remove(a[i])
            i = i - 1
        i = i + 1


def remove_zeros(list):
    b = []
    i = 0
    while i < len(a):
        if int(a[i]) == 0:
            a.remove(a[i])
            i = i - 1
        i = i + 1


def remove_zeros(list):
    a = []
    i = 0
    while i < len(a):
        if int(a[i]) == 0:
            a.remove(a[i])
            i = i - 1
        i = i + 1


def remove_zeros(a):
    b = []
    i = 0
    while i < len(a):
        if int(a[i]) == 0:
            a.remove(a[i])
            i = i - 1
        i = i + 1


def merge_lists(l1, l2):
    l3 = []
    i = 0
    while i < len(l1):
        l3.append(l1[i])
        i = i + 1
    i = 0
    while i < len(l2):
        l3.append(l2[i])
        i = i + 1
    return l3


def get_price(age):
    if age <= 16:
        return 5
    if age >= 60:
        return 7
    else:
        return 10


def merge_lists(l1, l2):
    l3 = []
    i = 0
    while i < len(l1):
        l3.append(l1[i][::2]).split(',')
        i = i + 1
    i = 0
    while i < len(l2):
        l3.append(l2[i][::2]).split(',')
        i = i + 1
    return l3


def merge_lists(l1, l2):
    l3 = []
    i = 0
    while i < len(l1):
        l3.append(l1[i])[::2]
        i = i + 1
    i = 0
    while i < len(l2):
        l3.append(l2[i])[::2]
        i = i + 1
    return l3


def merge_lists(l1, l2):
    l3 = []
    i = 0
    while i < len(l1):
        l3.append(l1[i])
        i = i + 1
    i = 0
    while i < len(l2):
        l3.append(l2[i])
        i = i + 1
    return l3[::2]


def merge_lists(l1, l2):
    l3 = []
    i = 0
    while i < len(l1):
        l3.append(l1[i])
        i = i + 1
    i = 0
    while i < len(l2):
        l3.append(l2[i]).split(',')
        i = i + 1
    return l3[::2]


def merge_lists(l1, l2):
    l3 = []
    i = 0
    while i < len(l1):
        l3.append(l1[i])
        i = i + 1
    i = 0
    while i < len(l2):
        l3.append(l2[i]).split
        i = i + 1
    return l3[::2].split(',')


def merge_lists(l1, l2):
    l3 = []
    i = 0
    while i < len(l1):
        l3.append(l1[i])
        i = i + 1
    i = 0
    while i < len(l2):
        l3.append(l2[i])
        i = i + 1
    return l3[::2].split(',')


def merge_lists(l1, l2):
    l3 = []
    i = 0
    while i < len(l1):
        l3.append(l1[i]).split()
        i = i + 1
    i = 0
    while i < len(l2):
        l3.append(l2[i]).split()
        i = i + 1
    return l3[::2]


def merge_lists(l1, l2):
    l3 = [].split(',')
    i = 0
    while i < len(l1):
        l3.append(l1[i])
        i = i + 1
    i = 0
    while i < len(l2):
        l3.append(l2[i])
        i = i + 1
    return l3[::2]


def merge_lists(l1, l2):
    l3 = []
    i = 0
    while i < len(l1):
        l3 = l3.split(',')
        l3.append(l1[i])
        i = i + 1
    i = 0
    while i < len(l2):
        l3.append(l2[i])
        i = i + 1
    return l3[::2]


def merge_lists(l1, l2):
    l3 = []
    my_list = l3.split(',')
    i = 0
    while i < len(l1):
        l3.append(l1[i])
        i = i + 1
    i = 0
    while i < len(l2):
        l3.append(l2[i])
        i = i + 1
    return my_list


def get_price(age):
    if age <= 16:
        return '5'
    if age > 60:
        return '7'
    else:
        return '10'


def remove_zeros(list):
    i = 0
    while i < len(list):
        if 0 in list:
            list.remove(0)
        i = i + 1


def merge_lists(l1, l2):
    i = 0
    mergedlist = []
    while i < len(l1):
        mergedlist.append(l1[i])
        i = i + 2
    j = 0
    while i < len(l2):
        mergedlist.append(l2[j])
        j = j + 2
    return mergedlist


def weird_case(some_str):
    ret = ''
    i = True
    for char in some_str:
        if i:
            ret += char.upper()
        else:
            ret += char.lower()
        if char != ' ':
            i = not i
    return ret


def merge_lists(l1, l2):
    i = 0
    mergedlist = []
    while i < len(l1):
        mergedlist.append(l1[i])
        i = i + 2
    j = 0
    while j < len(l2):
        mergedlist.append(l2[j])
        j = j + 2
    return mergedlist


def merge_lists(l1, l2):
    l3 = []
    i = 0
    while i < len(l1):
        l3.append(l1[i])
        i = i + 1
    i = 0
    while i < len(l2):
        l3.append(l2[i])
        i = i + 1
    return l3[::2].rstrip()


def get_price(age):
    if age <= 16:
        return 5
    if age >= 60:
        return 7
    else:
        return 10


def swap_keys_values(d):
    inv_map = {a: b for b, a in list(d.items())}


def swap_keys_values(d):
    inv_map = {a: b for b, a in list(d.items())}
    return inv_map


def swap_unique_keys_values(d):
    inv_map = {a: b for b, a in list(d.items())}
    return inv_map


def swap_unique_keys_values(d):
    new = {}
    for key, value in list(d.items()):
        if value not in new:
            new[key] = value
    inverse = {a: b for b, a in list(new.items())}
    return inverse


def swap_unique_keys_values(d):
    seen = []
    new = {}
    for key, value in list(d.items()):
        if value not in seen:
            value.append(seen)
            new[key] = value
    inverse = {a: b for b, a in list(new.items())}
    return inverse


def swap_unique_keys_values(d):
    seen = []
    new = {}
    for key, value in list(d.items()):
        if value not in seen:
            seen.append(value)
            new[key] = value
    inverse = {a: b for b, a in list(new.items())}
    return inverse


def swap_unique_keys_values(d):
    new = {}
    for key, value in list(d.items()):
        if value not in list(new.values()):
            new[key] = value
    inverse = {a: b for b, a in list(new.items())}
    return inverse


def swap_keys_values(dic):
    a, b, c = [], [], {}
    for file in dic:
        a.append(file)
    for letter in a:
        c[dic[letter]] = letter
    return c


def swap_unique_keys_values(dic):
    a, b, c = [], [], {}
    for file in dic:
        a.append([file, dic[file]])
    for letter in a:
        if letter[1] in c:
            del c[letter[1]]
        else:
            c[letter[1]] = letter[0]
    return c


def swap_keys_values(d):
    swp_d = {}
    for lines in d:
        swp_d[d[lines]] = lines
    return swp_d


def swap_unique_keys_values(d):
    new = {}
    for key, value in list(d.items()):
        if value not in list(new.values()):
            print(value)
            new[key] = value
    inverse = {a: b for b, a in list(new.items())}
    return inverse


def swap_unique_keys_values(d):
    new = {}
    for key, value in list(d.items()):
        if value not in list(new.values()):
            new[key] = value
        if value in list(new.values()):
            del d[key]
    inverse = {a: b for b, a in list(new.items())}
    return inverse


def swap_unique_keys_values(d):
    new = {}
    for key, value in list(d.items()):
        if value not in list(new.values()):
            new[key] = value
        else:
            del new[key]
    inverse = {a: b for b, a in list(new.items())}
    return inverse


def swap_unique_keys_values(d):
    new = {}
    for key, value in list(d.items()):
        if value in list(new.values()):
            del new[key]
        elif value not in list(new.values()):
            new[key] = value
    inverse = {a: b for b, a in list(new.items())}
    return inverse


def swap_unique_keys_values(d):
    new = {}
    for key, value in list(d.items()):
        if value in list(new.values()):
            del new[key, value]
        elif value not in list(new.values()):
            new[key] = value
    inverse = {a: b for b, a in list(new.items())}
    return inverse


def swap_unique_keys_values(d):
    new = {}
    for key, value in list(d.items()):
        if value not in list(d.values()):
            new[key] = value
    inverse = {a: b for b, a in list(new.items())}
    return inverse


def swap_unique_keys_values(d):
    new = {}
    for key, value in list(d.items()):
        d.pop(key, value)
        if value not in list(d.values()):
            new[key] = value
    inverse = {a: b for b, a in list(new.items())}
    return inverse


def swap_unique_keys_values(d):
    output = {}
    new = d
    for key, value in list(new.items()):
        new.pop(key, value)
        if value not in list(new.values()):
            output[key] = value
    inverse = {a: b for b, a in list(output.items())}
    return inverse


def swap_unique_keys_values(d):
    new = {}
    for key, value in list(d.items()):
        if value not in list(d.values()):
            new[key] = value
    for key, value in list(new.items()):
        del d[key, value]
    output = {}
    for key, value in list(new.items()):
        if value not in list(d.values()):
            output[key] = value
    inverse = {a: b for b, a in list(output.items())}
    return inverse


def swap_unique_keys_values(d):
    new = {}
    for key, value in list(d.items()):
        if value not in list(d.values()):
            new[key] = value
    print((d, new))
    for key, value in list(new.items()):
        del d[key, value]
    print((d, new))
    output = {}
    for key, value in list(new.items()):
        if value not in list(d.values()):
            output[key] = value
    inverse = {a: b for b, a in list(output.items())}
    return inverse


def swap_unique_keys_values(d):
    new = {}
    for key, value in list(d.items()):
        if value not in list(new.values()):
            new[key] = value
    print((d, new))
    for key, value in list(new.items()):
        del d[key, value]
    print((d, new))
    output = {}
    for key, value in list(new.items()):
        if value not in list(d.values()):
            output[key] = value
    inverse = {a: b for b, a in list(output.items())}
    return inverse


def swap_unique_keys_values(d):
    new = {}
    for key, value in list(d.items()):
        if value not in list(new.values()):
            new[key] = value
    print((d, new))
    for key, value in list(new.items()):
        d.pop(key, value)
    print((d, new))
    output = {}
    for key, value in list(new.items()):
        if value not in list(d.values()):
            output[key] = value
    inverse = {a: b for b, a in list(output.items())}
    return inverse


def swap_unique_keys_values(d):
    new = {}
    for key, value in list(d.items()):
        if value not in list(new.values()):
            new[key] = value
    for key, value in list(new.items()):
        d.pop(key, value)
    output = {}
    for key, value in list(new.items()):
        if value not in list(d.values()):
            output[key] = value
    inverse = {a: b for b, a in list(output.items())}
    return inverse


def swap_unique_keys_values(d):
    swp_d = {}
    nums = []
    final_nums = []
    dic = {}
    for lines in d:
        nums.append(str(d[lines]))
        swp_d[d[lines]] = lines
    for lines in nums:
        if nums.count(lines) == 1:
            final_nums.append(int(lines))
    for words in final_nums:
        dic[words] = swp_d[words]
    return dic


def swap_keys_values():
    oldkeys = []
    oldvalues = []
    swappeddict = {}
    for key in dictionary:
        oldkeys.append(list(dictionary.keys()))
        oldvalues.append(list(dictionary.values()))
    for e in oldkeys:
        swappeddict[oldvlaues] = oldkeys
    return swappeddict


def swap_keys_values(dictionary):
    oldkeys = []
    oldvalues = []
    swappeddict = {}
    for key in dictionary:
        oldkeys.append(list(dictionary.keys()))
        oldvalues.append(list(dictionary.values()))
    for e in oldkeys:
        swappeddict[oldvlaues] = oldkeys
    return swappeddict


def swap_keys_values(dictionary):
    oldkeys = []
    oldvalues = []
    swappeddict = {}
    for key in dictionary:
        oldkeys.append(list(dictionary.keys()))
        oldvalues.append(list(dictionary.values()))
    for e in oldkeys:
        swappeddict[oldvalues] = oldkeys
    return swappeddict


def swap_keys_values(dictionary):
    oldkeys = []
    oldvalues = []
    swappeddict = {}
    for key in dictionary:
        oldkeys.append(list(dictionary.keys()))
        oldvalues.append(list(dictionary.values()))
    i = 0
    while i < len(oldkeys):
        swappeddict[oldvalues[i]] = oldkeys[i]
        i = i + 1
    return swappeddict


def swap_keys_values(d):
    new_d = {}
    for k, v in list(d.items()):
        new_d[v] = k
    return new_d


def swap_unique_keys_values(d):
    new_d = {}
    for k, v in list(d.items()):
        if list(d.values()).count(v) == 1:
            new_d[v] = k
    return new_d


Test if two circles overlap.


def append2list(l1, l2=None):
    if l2 == None:
        l2 = []
    for i in l1:
        l2.append(i)
    return l2

Appends elements of a list l1 at the end of the list l2. If l2 not supplied default to empty list.


def swap_keys_values(d):
    inv = {v: k for k, v in list(d.items())}
    return inv


def swap_unique_keys_values(d):
    d = dict(set(d))
    inv = {v: k for k, v in list(d.items())}
    return inv


def swap_keys_values(d):
    return {d[key]: key for key in d}


def swap_unique_keys_values(d):
    return dict([(v, k) for k, v in list(d.items()) if list(d.values()).
        count(v) == 1])


def swap_keys_values(dic):
    a, b, c = [], [], {}
    for file in dic:
        a.append(file)
    for letter in a:
        c[dic[letter]] = letter
    return c


def swap_unique_keys_values(dic):
    a, b, c = [], [], {}
    for file in dic:
        a.append([file, dic[file]])
    for letter in a:
        if letter[1] in c:
            del c[letter[1]]
        else:
            c[letter[1]] = letter[0]
    return c


def swap_keys_values(s):
    dictionary = {}
    for i in s:
        dictionary[s[i]] = i
        return d


def swap_keys_values(s):
    dictionary = {}
    for i in s:
        dictionary[s[i]] = i
        return dictionary


def swap_keys_values(d):
    dictionary = {}
    for key in d:
        dictionary[d[key]] = key
        return dictionary


def swap_keys_values(d):
    dictionary = {}
    for key in d:
        dictionary[d[key]] = key
    return dictionary


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if not d[key] in unique:
            unique.append(key)
        dictionary[d[unique]] = key
    return dictionary


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if not d[key] in unique:
            unique.append(key)
        dictionary[d[unique[key]]] = key
    return dictionary


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if not d[key] in unique:
            unique.append(d[key])
        dictionary[d[unique]] = key
    return dictionary


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if not d[key] in unique:
            unique.append(d[key])
    for i in unique:
        dictionary[unique[i]] = key
    return dictionary


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if not d[key] in unique:
            unique.append(d[key])
        for i in unique:
            dictionary[d[i]] = key
    return dictionary


def swap_keys_values(d):
    new_d = {}
    for k, v in list(d.items()):
        new_d[v] = k
    return new_d


def swap_unique_keys_values(d):
    new_d = {}
    for k, v in list(d.items()):
        if v not in new_d:
            new_d[v] = k
        else:
            del new_d[v]
    return new_d


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if not d[key] in unique:
            unique.append(d[key])
        for i in unique:
            dictionary[i] = key
    return dictionary


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if not d[key] in unique:
            unique.append(key)
        for i in unique:
            dictionary[i] = key
    return dictionary


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if not d[key] in unique:
            unique.append(d[key])
        for i in unique:
            dictionary[i[unique]] = key
    return dictionary


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if not d[key] in unique:
            unique.append(d[key])
        for i in unique:
            dictionary[unique[i]] = key
    return dictionary


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if not d[key] in unique:
            unique.append(d[key])
        for i in unique:
            dictionary[unique[0]] = key
    return dictionary


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if d[key] in unique:
            unique.append(d[key])
        for i in unique:
            dictionary[unique[0]] = key
    return dictionary


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if not d[key] in unique:
            unique.append(d[key])
        for i in unique:
            dictionary[unique[1]] = key
    return dictionary


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if not d[key] in unique:
            unique.append(d[key])
        for i in unique:
            dictionary[i[0]] = key
    return dictionary


def swap_unique_keys_values(d):
    d = set(d)
    inv = {v: k for k, v in list(d.items())}
    return inv


def swap_unique_keys_values(d):
    d = set(d)
    inv = {v: k for k, v in d}
    return inv


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if not d[key] in unique:
            unique.append(d[key])
    for keys in d:
        if keys in unique:
            dictionary[d[key]] = key
    return dictionary


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if not key in unique:
            unique.append(d[key])
    for keys in d:
        if keys in unique:
            dictionary[d[key]] = key
    return dictionary


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if d[key] in unique:
            unique.append(d[key])
    for keys in d:
        if keys in unique:
            dictionary[d[key]] = key
    return dictionary


def swap_unique_keys_values(d):
    d = list(set(d))
    inv = {v: k for k, v in list(d.items())}
    return inv


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if key not in unique:
            unique.append(d[key])
    for keys in d:
        if keys in unique:
            dictionary[d[key]] = key
    return dictionary


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if not key in unique:
            unique.append(d[key])
    for keys in d:
        if keys[0] in unique:
            dictionary[d[key]] = key
    return dictionary


def swap_unique_keys_values(d):
    d = list(set(d))
    inv = {v: k for k, v in list(d.items())}
    return d


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if not key in unique:
            unique.append(d[key])
    for keys in d:
        if keys[1] in unique:
            dictionary[d[key]] = key
    return dictionary


def swap_unique_keys_values(d):
    d = list(set(d))
    return d


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if not key in unique:
            unique.append(d[key])
    for keys in unique:
        if keys in unique:
            dictionary[d[key]] = key
    return dictionary


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if not key in unique:
            unique.append(d[key])
    for keys in unique:
        dictionary[d[keys]] = key
    return dictionary


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if not key in unique:
            unique.append(d[key])
    for keys in unique:
        dictionary[d[key]] = keys
    return dictionary


def swap_unique_keys_values(d):
    d = list(set(d))
    d = {k: v for k, v in d}
    inv = {v: k for k, v in list(d.items())}
    return d


def swap_unique_keys_values(d):
    d = set(d)
    d = {k: v for k, v in d}
    inv = {v: k for k, v in list(d.items())}
    return d


def swap_unique_keys_values(d):
    inv = {v: k for k, v in list(d.items())}
    return inv


def swap_unique_keys_values(d):
    inv = {v: k for k, v in list(d.items())}
    d = []
    for k in list(inv.keys()):
        d.append(k)
    for k in d:
        if d.count(k) > 1:
            del inv[k]
    return inv


def append2list(l1, l2=None):
    if l2 is None:
        l2 = []
    for i in l1:
        l2.append(i)
    return l2


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if not key in unique:
            unique.append(d[key])
    for key in unique:
        dictionary[d[key]] = keys
    return dictionary


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if not key in unique:
            unique.append(d[key])
    for key in unique:
        dictionary[d[key]] = key
    return dictionary


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if not key in unique:
            unique.append(key)
    for keys in unique:
        dictionary[d[keys]] = keys
    return dictionary


Test if two circles overlap.


def swap_unique_keys_values(d):
    inv = {v: k for k, v in list(d.items())}
    d = []
    for k in list(inv.keys()):
        d.append(k)
    for k in d:
        if d.count(k) > 1:
            del inv[k]
            del inv[k]
    return inv


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    for key in d:
        if key in unique:
            unique.append(key)
    for keys in unique:
        dictionary[d[keys]] = keys
    return dictionary


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    not_unique = []
    for key in d:
        if not key in unique:
            unique.append(key)
        else:
            not unique.append(key)
    for keys in unique:
        dictionary[d[keys]] = keys
    return dictionary


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    not_unique = []
    for key in d:
        if not key in unique:
            unique.append(key)
        else:
            not unique.append(key)
    for keys in unique:
        if not keys in unique:
            dictionary[d[keys]] = keys
    return dictionary


def swap_unique_keys_values(d):
    inv = {v: k for k, v in list(d.items())}
    for k in list(inv.keys()):
        if list(inv.keys()).count(inv[k]) > 1:
            del inv[k]
    return inv


def append2list(l1, l2=[]):
    for i in l1:
        l2.append(i)
    return l2


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    not_unique = []
    value = []
    for key in d:
        if not key in unique:
            unique.append(key)
        else:
            not_unique.append(key)
    for i in unique:
        if not not_unique in unique:
            value.append(i)
    for keys in value:
        dictionary[d[keys]] = keys
    return dictionary


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    not_unique = []
    value = []
    for key in d:
        if not key in unique:
            unique.append(d[key])
        else:
            not_unique.append(d[key])
    for i in unique:
        if not not_unique in unique:
            value.append(i)
    for keys in value:
        dictionary[d[keys]] = keys
    return dictionary


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    not_unique = []
    value = []
    for key in d:
        if not key in unique:
            unique.append(key)
        else:
            not_unique.append(key)
    for i in unique:
        if not_unique in unique:
            value.append(i)
    for keys in value:
        dictionary[d[keys]] = keys
    return dictionary


def swap_unique_keys_values(d):
    for k in list(inv.keys()):
        if list(d.values()).count(d[k]) > 1:
            del d[k]
    inv = {v: k for k, v in list(d.items())}
    return inv


def swap_unique_keys_values(d):
    for k in list(d.keys()):
        if list(d.values()).count(d[k]) > 1:
            del d[k]
    inv = {v: k for k, v in list(d.items())}
    return inv


def append2list(l1, l2=None):
    if l2 == None:
        l2 = []
    for i in l1:
        l2.append(i)
    return l2


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    not_unique = []
    value = []
    for key in d:
        if not key in unique:
            unique.append(key)
        else:
            not_unique.append(key)
    for i in unique:
        if not unique in not_unique:
            value.append(i)
    for keys in value:
        dictionary[d[keys]] = keys
    return dictionary


def append2list(l1, l2=[]):
    if len(l2) > 1:
        l2 = []
    for i in l1:
        l2.append(i)
    return l2


def append2list(l1, l2=None):
    if l2 == None:
        l2 == []
    for i in l1:
        l2.append(i)
    return l2


def append2list(l1, l2=None):
    if l2 is None:
        l2 = []
    for i in l1:
        l2.append(i)
    return l2


def append2list(l1, l2=None):
    for i in l1:
        if l2 == None:
            l2 = []
        l2.append(i)
    return l2


def append2list(l1, l2=0):
    if l2 == 0:
        l2 = []
    for i in l1:
        l2.append(i)
    return l2


def append2list(l1, l2=None):
    if l2 is None:
        l2 = []
    for word in l1:
        l2.append(word)
    return l2


def append2list(l1, l2=[]):
    if not l2 is None:
        l2 = []
    for i in l1:
        l2.append(i)
    return l2


Test if two circles overlap.


def append2list(l1, l2=[]):
    l2 = []
    for i in l1:
        l2.append(i)
    return l2


def overlap(x1=0, y1=1, r1=0, x2=0, y2=0, r2=0):
    distance = maths.sqrt(x2 - x1 ^ 2 + (y2 - y1) ^ 2)
    return distance < r1 + r2

Test if two circles overlap.


def append2list(l1, s=''):
    l2 = []
    for i in l1:
        l2.append(i)
    if s:
        l2.append(s)
    return l2


def append2list(l1, s=None):
    l2 = []
    for i in l1:
        l2.append(i)
    if s:
        l2.append(s)
    return l2


def append2list(l1, l2=[]):
    for i in l1:
        l2.append(i)
    return l2


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    not_unique = []
    value = []
    for key in d:
        if not key in unique:
            unique.append(key)
        else:
            not_unique.append(key)
    for i in unique:
        unique.pop(not_unique)
    for keys in value:
        dictionary[d[keys]] = keys
    return dictionary


def swap_unique_keys_values(d):
    dictionary = {}
    unique = []
    not_unique = []
    value = []
    for key in d:
        if not key in unique:
            unique.append(key)
        else:
            not_unique.append(key)
    for i in unique:
        unique.pop(i)
    for keys in value:
        dictionary[d[keys]] = keys
    return dictionary


def overlap(x1=0, y1=1, r1=1, x2=0, y2=0, r2=1):
    distance = math.sqrt(x2 - x1 ^ 2 + (y2 - y1) ^ 2)
    return distance < r1 + r2

Test if two circles overlap.


def append2list(l1, l2=None):
    for i in l1:
        if not l2:
            l2 = []
        l2.append(i)
    return l2


def append2list(l1, l2=None):
    if l2 == None:
        l2 = []
    for i in l1:
        l2.append(i)
    return l2


def overlap(x1=0, y1=1, r1=1, x2=0, y2=0, r2=1):
    distance = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
    return distance < r1 + r2

Test if two circles overlap.


def overlap(x1=0, y1=0, r1=0, x2=0, y2=0, r2=0):
    distance = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
    return distance < r1 + r2

Test if two circles overlap.


def overlap(x1=0, y1=0, r1=1, x2=0, y2=0, r2=1):
    from math import sqrt
    distance = sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
    if distance >= r1 + r2:
        return False
    else:
        return True

Test if two circles overlap.


def overlap(x1=0, y1=0, r1=1, x2=0, y2=0, r2=1):
    distance = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
    return distance < r1 + r2

Test if two circles overlap.


def append2list(l1, l2=None):
    if l2 is None:
        l2 = []
    for i in l1:
        l2.append(i)
    return l2


def overlap(x1=0, y1=0, r1=1, x2=0, y2=0, r2=1):
    radiuses = r1 + r2
    distance = sqrt((x2 + x1) ** 2 + (y2 + y1) ** 2)
    if distance <= radiuses:
        print(True)
    else:
        print(False)

Test if two circles overlap.


Test if two circles overlap.


def overlap(x1=0, y1=0, r1=1, x2=0, y2=0, r2=1):
    A = 'True'
    r = x2 - x1
    f = y2 - y1
    rf = (r ** 2 + f ** 2) ** 0.5
    if r == 0 and f == 0:
        return A
    elif r1 + r2 > rf:
        return A
    else:
        return 'False'

Test if two circles overlap.


def overlap(x1=0, y1=0, r1=1, x2=0, y2=0, r2=1):
    radiuses = r1 + r2
    distance = sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
    if distance < radiuses:
        return True
    else:
        return False

Test if two circles overlap.


def overlap(x1=0, y1=0, r1=1, x2=0, y2=0, r2=1):
    dis = sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
    if dis <= r1 + r2:
        return True
    return False

Test if two circles overlap.


def append2list(l1, l2=None):
    if l2 is None:
        l2 = []
    l2.append(l1)
    return l2


def overlap(x1=0, y1=0, r1=1, x2=0, y2=0, r2=1):
    dis = sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
    if dis < r1 + r2:
        return True
    return False

Test if two circles overlap.


def append2list(l1, l2=[]):
    if len(l2) == 0:
        l2 = []
    for i in l1:
        l2.append(i)
    return l2


def fixer(l2):
    if l2 == None:
        return []
    else:
        return l2

def append2list(l1, l2=None):
    l2 = fixer(l2)
    for i in l1:
        l2.append(i)
    return l2


def overlap(x1=0, y1=0, r1=1, x2=0, y2=0, r2=1):
    c1c2 = sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
    if c1c2 < r1 + r2:
        return True
    else:
        return False

Test if two circles overlap.


def overlap(x1=0, y1=0, r1=1, x2=0, y2=0, r2=1):
    if (r1 > r2) > x2 - x1 + (y2 - y1):
        return True
    else:
        return False

Test if two circles overlap.


def swap_unique_keys_values(d):
    dic = {}
    values = []
    notunique = []
    for key in d:
        if d[key] in values:
            notunique.append(d[key])
        else:
            values.append(d[key])
    for key in d:
        if not d[key] in notunique:
            dic[d[key]] = key
    return dic


def overlap(x1=0, y1=0, r1=1, x2=0, y2=0, r2=1):
    if (r1 > r2) > x2 - x1 + (y2 - y1):
        return False
    else:
        return True

Test if two circles overlap.


def append2list(l1, l2=None):
    if l2 == None:
        l2 = []
    for i in l1:
        l2.append(i)
    return l2


def overlap(x1=0, y1=0, r1=1, x2=0, y2=0, r2=1):
    if (r1 > r2) >= x2 - x1 + (y2 - y1):
        return False
    else:
        return True

Test if two circles overlap.


def overlap(x1=0, y1=0, r1=1, x2=0, y2=0, r2=1):
    if r1 + r2 > x2 - x1 + (y2 - y1):
        return False
    else:
        return True

Test if two circles overlap.


def overlap(x1, y1, r1, x2, y2, r2):
    distance = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 1 // 2
    return distance < r1 + r2

Test if two circles overlap.


def append2list(l1, l2=[]):
    for i in l1:
        l2.append(i)
    return l2


Test if two circles overlap.


def append2list(l1, l2=None):
    if l2 == None:
        l2 = []
        for i in l1:
            l2.append(i)
    return l2


def overlap(x1=0, y1=0, r1=1, x2=0, y2=0, r2=1):
    boolean_intersects = math.hypot(x2 - x1, y2 - y1) < r1 + r2
    return boolean_intersects

Test if two circles overlap.


def overlap(x1=0, y1=0, r1=0, x2=0, y2=0, r2=1):
    intersect = math.hypot(x1 - x2, y1 - y2) < r1 + r2
    return intersect

Test if two circles overlap.


def append2list(l1, l2=None):
    if l2 is None:
        l2 = []
    for i in l1:
        l2.append(i)
    return l2


def append2list(l1, l2=[]):
    l2 = []
    for i in l1:
        l2.append(i)
    return l2


def overlap(x1=0, y1=0, r1=1, x2=0, y2=0, r2=1):
    distance = math.floor(math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2))
    return r1 + r2 > distance

Test if two circles overlap.


def append2list(l1, l2=[]):
    for i in l1:
        l2.append(i)
    return l2
    l2 = []


def overlap(x1=0, y1=0, r1=1, x2=0, y2=0, r2=1):
    distance = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
    if int(distance) < r1 + r2:
        return True
    else:
        return False

Test if two circles overlap.


def overlap(x1, y1, r1, x2, y2, r2):
    distance = (x2 - x1) ** 2 + (y2 - y1) ** 2
    radius = r1 + r2
    return radius < distance

Test if two circles overlap.


def overlap(x1=0, y1=0, r1=1, x2=0, y2=0, r2=1):
    distance = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
    radius = r1 + r2
    return distance < radius

Test if two circles overlap.


def append2list(l1, l2=[]):
    if l2 is none:
        l2 = []
    for i in l1:
        l2.append(i)
    return l2


def overlap(x1=0, y1=0, r1=0, x2=0, y2=0, r2=0):
    distance = (x2 - x1) ** 2 + (y2 - y1) ** 2
    radius = r1 + r2
    return radius < distance

Test if two circles overlap.


def overlap(x1=0, y1=0, r1=0, x2=0, y2=0, r2=0):
    distance = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5
    radius = r1 + r2
    return radius < distance

Test if two circles overlap.


def overlap(xo=0, yo=0, ro=1, xt=0, yt=0, rt=1):
    run = int(xo) - int(xt)
    print(run)
    rise = int(yo) - int(yt)
    print(rise)
    distance = (run ** 2 + rise ** 2) ** 0.5
    print(distance)
    return distance < ro + rt

Test if two circles overlap.


def overlap(xo=0, yo=0, ro=1, xt=0, yt=0, rt=1):
    run = int(xo) - int(xt)
    rise = int(yo) - int(yt)
    distance = (run ** 2 + rise ** 2) ** 0.5
    return distance < ro + rt

Test if two circles overlap.


def overlap(x1=0, y1=0, r1=1, x2=0, y2=0, r2=1):
    distance = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5
    radius = r1 + r2
    return radius > distance

Test if two circles overlap.


Test if two circles overlap.


def append2list(l1, l2=None):
    if l2 == None:
        l2 = []
    for i in l1:
        l2.append(i)
    return l2


def overlap(xo=0, yo=0, ro=1, xt=0, yt=0, rt=1):
    run = int(xt) - int(xo)
    rise = int(yt) - int(yo)
    distance = (run ** 2 + rise ** 2) ** 0.5
    return distance < ro + rt

Test if two circles overlap.


def overlap(x1=0, y1=0, r1=1, x2=0, y2=0, r2=1):
    try:
        return ((int(x2) - int(x1)) ** 2 + (int(y2) - int(y1)) ** 2
            ) ** -1 < int(r1) + int(r2)
    except ZeroDivisionError:
        return True

Test if two circles overlap.


def overlap(x1=0, y1=0, r1=1, x2=0, y2=0, r2=1):
    run = int(x1) - int(x2)
    rise = int(y1) - int(y2)
    distance = (run ** 2 + rise ** 2) ** 0.5
    return distance < r1 + r2

Test if two circles overlap.


def append2list(l1, l2=None):
    if l2 is None:
        l2 = []
    for i in l1:
        l2.append(i)
    return l2


def overlap(x1=0, y1=0, r1=1, x2=0, y2=0, r2=1):
    try:
        return ((int(x2) - int(x1)) ** 2 + (int(y2) - int(y1)) ** 2
            ) ** -1 > int(r1) + int(r2)
    except ZeroDivisionError:
        return True

Test if two circles overlap.


def overlap(x1=0, y1=0, r1=1, x2=0, y2=0, r2=1):
    try:
        return ((int(x2) - int(x1)) ** 2 + (int(y2) - int(y1)) ** 2) ** -1
    except ZeroDivisionError:
        return True

Test if two circles overlap.


def overlap(x1=0, y1=0, r1=1, x2=0, y2=0, r2=1):
    try:
        return ((int(x2) - int(x1)) ** 2 + (int(y2) - int(y1)) ** 2) ** (1 / 2
            ) < int(r1) + int(r2)
    except ZeroDivisionError:
        return True

Test if two circles overlap.


def overlap(x1, y1, r1, x2, y2, r2):
    if (x1 - x2) ** 2 + (y1 - y2) ** 2 < (r1 + r2) ** 2:
        print(True)
    else:
        print(False)

Test if two circles overlap.


def overlap(x1, y1, r1, x2, y2, r2):
    if (x1 - x2) ** 2 + (y1 - y2) ** 2 < (r1 + r2) ** 2:
        return True
    else:
        return False

Test if two circles overlap.


def swap_keys_values(d):
    new_dict = {}
    for k, v in list(d.items()):
        new_dict[v] = k
    return new_dict


def swap_unique_keys_values(d):
    keys = list(d.keys())
    values = list(d.values())
    new_dict = {}
    for i in range(len(keys)):
        if values.count(values[i]) == 1:
            new_dict[values[i]] = keys[i]
    return new_dict


def append2list(l1, l2=None):
    if l2 in None:
        l2 = []
    for i in l1:
        l2.append(i)
    return l2


def append2list(l1, l2=None):
    if not l2:
        l2 = []
    for i in l1:
        l2.append(i)
    return l2


def append2list(l1, l2):
    for i in l1:
        l2.append(i)
    return l2


def overlap(x1=0, y1=0, r1=1, x2=0, y2=0, r2=1):
    distance_between_centers = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
    sum_of_radii = r2 + r1
    if sum_of_radii > distance_between_centers:
        return True
    else:
        return False

Test if two circles overlap.


Test if two circles overlap.


def swap_keys_values(d):
    new_dic = {}
    for k, v in list(d.items()):
        new_dic[v] = k
    return new_dic


def swap_unique_keys_values(d):
    new_dic = {}
    for k, v in list(d.items()):
        if d[k] not in new_dic:
            new_dic[v] = k
    return new_dic


def swap_unique_keys_values(d):
    new_dic = {}
    keys2swap = [d[key] for key in d]
    for k, v in list(d.items()):
        if keys2swap.count(v) == 1:
            new_dic[v] = k
    return new_dic


def swap_unique_keys_values():
    dic1 = {}
    dic2 = {}
    dicsort = sorted(list(d.items()), reverse=True)
    for k, v in dicsort:
        if v not in dic1:
            dic1[v] = k
        else:
            dic1[v] = 'N'
    dicsort2 = sorted(list(dic1.items()), reverse=True)
    for k, v in dicsort2:
        if v != 'N':
            dic2[k] = v
    return dic2


def swap_unique_keys_values(d):
    dic1 = {}
    dic2 = {}
    dicsort = sorted(list(d.items()), reverse=True)
    for k, v in dicsort:
        if v not in dic1:
            dic1[v] = k
        else:
            dic1[v] = 'N'
    dicsort2 = sorted(list(dic1.items()), reverse=True)
    for k, v in dicsort2:
        if v != 'N':
            dic2[k] = v
    return dic2


def append2list(l1, l2=None):
    if l2 == None:
        l2 = []
    for i in l1:
        l2.append(i)
    return l2


def swap_keys_values(d):
    new_dict = {v: k for k, v in list(d.items())}
    return new_dict


def swap_unique_keys_values(d):
    e = {}
    h = {}
    for k, v in sorted(list(d.items()), reverse=True):
        if v in e:
            e[k] = v
        else:
            e[k] = 'n'
    for k, v in sorted(list(e.items()), reverse=True):
        if v != 'n':
            h[k] = v
    return {v: k for k, v in list(d.items())}


def swap_unique_keys_values(d):
    e = {}
    h = {}
    for k, v in sorted(list(d.items()), reverse=True):
        if v not in e:
            e[v] = k
        else:
            e[v] = 'n'
    for k, v in sorted(list(e.items()), reverse=True):
        if v != 'n':
            h[k] = v
    return h


def swap_keys_values(d):
    new = {}
    for k, v in list(d.items()):
        new[v] = k
    return new


def swap_unique_keys_values(d):
    new = {}
    keys = [k for k in list(d.keys())]
    values = [v for v in list(d.values())]
    for k, v in list(d.items()):
        if values.count(v) == 1:
            new[v] = k
    return new


def swap_keys_values(dictionary):
    oldkeys = []
    oldvalues = []
    swappeddict = {}
    for key in list(dictionary.keys()):
        oldkeys.append(key)
    for value in list(dictionary.values()):
        oldvalues.append(value)
    i = 0
    while i < len(oldkeys):
        swappeddict[oldvalues[i]] = oldkeys[i]
        i = i + 1
    return swappeddict


def swap_keys_values(d):
    dictionary = {}
    for key in d:
        dictionary[d[key]] = key
    return dictionary


def swap_unique_keys_values(d):
    dic = {}
    values = []
    notunique = []
    for key in d:
        if d[key] in values:
            notunique.append(d[key])
        else:
            values.append(d[key])
    for key in d:
        if not d[key] in notunique:
            dic[d[key]] = key
    return dic


def swap_unique_keys_values(dictionary):
    oldkeys = []
    oldvalues = []
    invalid = []
    swappeddict = {}
    for value in list(dictionary.values()):
        if value not in oldvalues:
            oldvalues.append(value)
        else:
            oldvalues.pop(value)
            invalid.append(value)
    for key in list(dictionary.keys()):
        if key.value() not in invalid:
            oldkeys.append(key)
    i = 0
    while i < len(oldkeys):
        swappeddict[oldvalues[i]] = oldkeys[i]
        i = i + 1
    return swappeddict


def swap_unique_keys_values(dictionary):
    oldkeys = []
    oldvalues = []
    invalid = []
    swappeddict = {}
    for value in list(dictionary.values()):
        if value not in oldvalues:
            oldvalues.append(value)
        else:
            invalid.append(value)
        if value in oldvalues:
            oldvalues.pop(value)
    for key in list(dictionary.keys()):
        if key.value() not in invalid:
            oldkeys.append(key)
    i = 0
    while i < len(oldkeys):
        swappeddict[oldvalues[i]] = oldkeys[i]
        i = i + 1
    return swappeddict


def append2list(l1, l2=None):
    if l2 is None:
        l2 = []
    for i in l1:
        l2.append(i)
    return l2


def swap_unique_keys_values(d):
    if list(d.values()).count(d[k]) != 1 in list(d.keys()):
        del d[k]
    inv = {v: k for k, v in list(d.items())}
    return inv


def swap_keys_values(dictionary):
    new_dictionary = {}
    for key in dictionary:
        new_dictionary[dictionary[key]] = key
    return new_dictionary


def swap_unique_keys_values(dictionary):
    values = []
    new_dict = {}
    for key in dictionary:
        values.append(dictionary[key])
    for key, value in list(dictionary.items()):
        if values.count(value) == 1:
            new_dict[value] = key
    return new_dict


def swap_unique_keys_values(d):
    for k in list(d.values()):
        if list(d.values()).count(d[k]) != 1:
            del d[k]
    inv = {v: k for k, v in list(d.items())}
    return inv


def swap_unique_keys_values(d):
    v = list(d.values())
    for k in v:
        if v.count(d[k]) != 1:
            del d[k]
    inv = {v: k for k, v in list(d.items())}
    return inv


def swap_unique_keys_values(d):
    v = list(d.values())
    for k in v:
        if v.count(v[k]) != 1:
            del d[k]
    inv = {v: k for k, v in list(d.items())}
    return inv


def swap_unique_keys_values(d):
    inv = {v: k for k, v in list(d.items()) if v.count() == 1}
    return inv


def swap_unique_keys_values(d):
    vals = list(d.values())
    inv = {v: k for k, v in list(d.items()) if vals.count(v) == '1'}
    return inv


def swap_unique_keys_values(d):
    vals = list(d.values())
    inv = {v: k for k, v in list(d.items()) if vals.count(v) == 1}
    return inv


def swap_keys_values(d):
    newdict = {}
    keys = list(d.keys())
    values = list(d.values())
    i = 0
    while i < len(d.keys):
        newdict[keys[i]] = values[i]
        i = i + 1
    return newdict


def swap_keys_values(d):
    newdict = {}
    keys = list(d.keys())
    values = list(d.values())
    i = 0
    while i < len(d):
        newdict[keys[i]] = values[i]
        i = i + 1
    return newdict


Test if two circles overlap.


def swap_keys_values(d):
    new_dict = {}
    for k, v in list(d.items()):
        new_dict[v] = k
    return new_dict


def swap_unique_keys_values(d):
    new_dict = {}
    for k, v in list(d.items()):
        if v not in new_dict:
            new_dict = k
        else:
            del new_dict[v]
    return new_dict


def swap_keys_values(d):
    swap1 = {}
    swap2 = {}
    swapsorted = sorted(list(d.items()), reverse=True)
    for k, v in swapsorted:
        swap1[v] = k
    swapsorted2 = sorted(list(swap1.items()), reverse=True)
    for k, v in swapsorted2:
        swap2[k] = v
    return swap2


def swap_unique_keys_values(d):
    new_dict = {}
    for k, v in list(d.items()):
        if v not in new_dict:
            new_dict[v] = k
        else:
            del new_dict[v]
    return new_dict


def swap_unique_keys_values(d):
    swap1 = {}
    swap2 = {}
    swapsorted1 = sorted(list(d.items()), reverse=True)
    for k, v in swapsorted1:
        if v not in swap1:
            swap1[v] = k
        else:
            swap1[v] = 'N'
    swapsorted2 = sorted(list(swap1.items()), reverse=True)
    for k, v in ar2:
        if v != 'N':
            swap2[k] = v
    return swap2


def swap_unique_keys_values(d):
    swap1 = {}
    swap2 = {}
    swapsorted1 = sorted(list(d.items()), reverse=True)
    for k, v in swapsorted1:
        if v not in swap1:
            swap1[v] = k
        else:
            swap1[v] = 'N'
    swapsorted2 = sorted(list(swap1.items()), reverse=True)
    for k, v in swapsorted2:
        if v != 'N':
            swap2[k] = v
    return swap2


def swap_keys_values(d):
    new_d = {}
    mylist = list(d.items())
    i = 0
    while i < len(mylist):
        d_key = mylist[i][0]
        d_val = mylist[i][1]
        new_d[d_val] = d_key
        i += 1
    return new_d


def swap_keys_values(d):
    dic = {}
    for k, v in list(d.items()):
        dic[v] = k
    return dic


def swap_unique_keys_values(d):
    new_d = {}
    val_count = {}
    mylist = list(d.items())
    i = 0
    while i < len(mylist):
        d_key = mylist[i][0]
        d_val = mylist[i][1]
        if d_val not in val_count:
            val_count[d_val] = 1
            new_d[d_val] = d_key
        else:
            val_count[d_val] = 1
            del new_d[d_val]
        i += 1
    return new_d


def swap_keys_values(d):
    return {v: k for k, v in list(d.items())}


def swap_unique_keys_values(dictionary):
    oldkeys = []
    oldvalues = []
    swappeddict = {}
    for value in list(dictionary.values()):
        oldvalues.append(value)
    for key in list(dictionary.keys()):
        oldkeys.append(key)
    i = 0
    while i < len(oldkeys):
        swappeddict[oldvalues[i]] = oldkeys[i]
        i = i + 1
    for value in oldvalues:
        if oldvalues.count(value) == 2 and value in swappeddict:
            swappeddict.pop(value)
    return swappeddict


def swap_keys_values(d):
    dictionary = {}
    for key in d:
        dictionary[d[key]] = key
    return dictionary


def swap_unique_keys_values(d):
    dic = {}
    values = []
    notunique = []
    for key in d:
        if d[key] in values:
            notunique.append(d[key])
        else:
            values.append(d[key])
    for key in d:
        if not d[key] in notunique:
            dic[d[key]] = key
    return dic


def swap_keys_values(d):
    swappedDict = {}
    for i in d:
        swappedDict[d[i]] = i
    return swappedDict


def swap_unique_keys_values(d):
    swappedDict = {}
    for i in d:
        if d[i] in swappedDict:
            del swappedDict[d[i]]
        else:
            swappedDict[d[i]] = i
    return swappedDict


def swap_keys_values(n):
    dic = {}
    for key in n:
        dic[n[key]] = key
    return dic