def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
            tmp = a[p]
            a[p] = a[i]
            a[i] = tmp
        i = i + 1
    return a


def reverse(a):
    i = 0
    while i < len(a) / 2:
        tmp = a[i]
        a[i] = a[len(a) - i - 1]
        a[len(a) - i - 1] = tmp
        i = i + 1

Reverse a list of elements by swapping its elements.


def smallest(a, i):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1

def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def selection_sort(a):
    i = 0
    while i < len(a):
        p = smallest(a, i)
        swap(a, i, j)
        i = i + 1

Sort a list by repeatedly move minimimum of remaining sublist to front.


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def reverse(a):
    i = 0
    j = -1
    while i < len(a):
        swap(a, i, j)
        i += 1
        j -= 1


def find_smallest_position(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return p

def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i, p)
        i = i + 1


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, a[i], a[len(a) - i - 1])
        i = i + 1


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    j = len(a) - 1
    while i < len(a) / 2:
        swap(a, i, j)
        i += 1
        j = j - 1


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def find_smallest_position(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return p

def selection_sort(a):
    i = 0
    while i < len(a):
        find_smallest_position(a, i)
        swap(a, i, j)
        i = i + 1


def smallest(a, i):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        i = i + 1

def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def selection_sort(a):
    i = 0
    while i < len(a):
        p = smallest(a, i)
        swap(a, i, j)
        i = i + 1


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = a[0]
    j = len(a) - 1
    while i < j:
        a = swap(a)
        i = i + 1
        j = j - 1


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - i - 1)
        i = i + 1


def swap(p, i):
    tmp = a[p]
    a[p] = a[i]
    a[i] = tmp
    return a

def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j += 1
        swap(p, i)
        i += 1
    return a


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - 1 - i)
        i = i + 1


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def reverse(a):
    i = 0
    j = len(a) - 1
    while i < len(a):
        swap(a, i, j)
        i += 1
        j -= 1


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def find_smallest_position(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return p

def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i, p)
        i = i + 1


def circumference(r):
    return 2 * pi * int(r)


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    j = len(a) - 1
    while i < len(a):
        swap(a, i, j)
        i = i + 1
        j = j - 1


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def reverse(a):
    i = 0
    j = len(a) - 1
    while i < len(a) / 2:
        swap(a, i, j)
        i += 1
        j -= 1


def circumference(r):
    return r * 2 * 3.141


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp
    return a

def reverse(a):
    while i < len(a) / 2:
        swap(a, i, j)
        i = i + 1
        j = j - 1
    return a


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - i - 1)
        i = i + 1


def swap(a, p, i):
    tmp = a[p]
    a[p] = a[i]
    a[i] = tmp
    return a

def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j += 1
        swap(a, p, i)
        i += 1
    return a


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    while i < len(a) / 2:
        swap(a, i, j)
        i = i + 1
        j = j - 1


def area(r):
    return pi * int(r) * int(r)


def double(n):
    d = n * 2
    return d


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        j = len(a) - i - 1
        swap(a, i, j)
        i = i + 1


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        i = i + 1


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def find_smallest_position(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return p

def selection_sort(a, i):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i, p)
        i = i + 1


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    j = len(a) - 1
    while i < j:
        swap(a)
        i = i + 1
        j = j - 1


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp
    return a

def reverse(a):
    while i < len(a) / 2:
        swap(a, i, j)
        i = i + 1
        j = j - 1
        return a


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - i - 1)
        i = i + 1


def circumference(r):
    return r * 2 * pi


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    j = len(a) - 1
    while i < j:
        swap(a, i, j)
        i = i + 1
        j = j - 1


def circumference(r):
    return 2 * pi * r


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def find_smallest_position(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return p

def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i, p)
        i = i + 1


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    j = len(a) - 1
    while i < len(a):
        swap(a, i, j)
        i = i + 1
        j = j + 1


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - i - 1)
        i += 1


def smallest(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1

def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def selection_sort(a):
    i = 0
    while i < len(a):
        p = smallest(a, i)
        swap(a, i, j)
        i = i + 1


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    j = len(a) - 1
    while i < len(a) / 2:
        swap(a, i, j)
        i = i + 1
        j = j - 1


def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i, p)
        i = i + 1


def smallest(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1

def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def selection_sort(a):
    i = 0
    while i < len(a):
        p = smallest(a, i)
        swap(a, i, p)
        i = i + 1


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp
    return a

def reverse(a):
    i = 0
    j = len(a) - 1
    while i < len(a) / 2:
        swap(a, i, j)
        i = i + 1
        j = j - 1
        return a


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    j = a[len(a) - 1]
    while i < len(a):
        swap(a, i, j)
        i = i + 1
        j = j - 1


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def reverse(a):
    i = 0
    j = -1
    while i < len(a / 2):
        swap(a, i, j)
        i += 1
        j -= 1


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def reverse(a):
    i = 0
    j = -1
    while i < len(a) / 2:
        swap(a, i, j)
        i += 1
        j -= 1


def swap(a, i, j):
    tmp = a[i]
    a[i] = [j]
    a[j] = tmp
    return a

def reverse(a):
    i = 0
    j = len(a)
    while i < len(a) / 2:
        swap(a, i, j)
        i = i + 1
        j = j - 1


def swap(a, p, i):
    tmp = a[p]
    a[p] = a[i]
    a[i] = tmp

def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        swap(a, p, i)
        i = i + 1
    return p


def swap(a, i, j):
    tmp = a[i]
    a[i] = [j]
    a[j] = tmp

def reverse(a):
    i = 0
    j = len(a)
    while i < len(a) / 2:
        swap(a, i, j)
        i = i + 1
        j = j - 1


def smallest(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1

def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def selection_sort(a):
    i = 0
    while i < len(a):
        j = smallest(a, i)
        swap(a, i, j)
        i = i + 1


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    j = len(a)
    while i < len(a) / 2:
        swap(a, i, j)
        i = i + 1
        j = j - 1


def selection_sort(a, j, k):
    while i < len(a):
        j = i
        k = i
        while k < len(a):
            if a[j] > a[k]:
                k = j
            k = k + 1
        swap(a, i, j)
        i = i + 1


def swap(a, p, i):
    tmp = a[p]
    a[p] = a[i]
    a[i] = tmp
    return a

def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        swap(a, p, i)
        i = i + 1
    return p


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def find_smallest_position(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
        return p

def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i.p)
        i = i + 1


def selection_sort(a):
    i = 0
    j = 0
    p = 0
    while i < len(a):
        j = i + 1
        p = i
        while j < len(a):
            if a[p] > a[j]:
                p = j
            j = j + 1
        tmp = a[i]
        a[i] = a[p]
        a[p] = tmp
        i = i + 1
    return a


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    x = 0
    y = len(a)
    z = len(a) / 2
    while x < y:
        swap(x, y)
        x = x + 1
        y = y - 1


def selection_sort(a):
    while i < len(a):
        j = i
        k = i
        while k < len(a):
            if a[j] > a[k]:
                k = j
            k = k + 1
        swap(a, i, j)
        i = i + 1


def smallest(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return p

def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def selection_sort(a):
    i = 0
    while i < len(a):
        p = smallest(a, i)
        swap(a, i, p)
        i = i + 1


def swap(a, p, i):
    tmp = a[p]
    a[p] = a[i]
    a[i] = tmp
    return a

def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        swap(a, p, i)
        i = i + 1
    return a


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def find_smallest_position(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
        return p

def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i, p)
        i = i + 1


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    j = len(a) - 1
    while i < len(a) / 2:
        swap(a, i, j)
        i = i + 1
        j = j - 1


def reverse(a):
    return a[len(a) - 1:i]


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    x = 0
    y = len(a)
    z = len(a) / 2
    while x < y:
        swap(a, x, y)
        x = x + 1
        y = y - 1


def selection_sort(a):
    j = 0
    while j < len(a):
        p = j
        i = j + 1
        while i < len(a):
            if a[i] < a[p]:
                p = i
            i = i + 1
        tmp = a[j]
        a[j] = a[p]
        a[p] = tmp
        j = j + 1


def selection_sort(a):
    i = 0
    p = 0
    j = 1
    while i < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
        i = i + 1


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - 1)


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def find_smallest_position(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return p

def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i, p)
        i = i + 1


def find_smallest(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j += 1
    return p

def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest(a, i)
        swap(a, i, p)
        i += 1


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def reverse(a):
    i = 0
    j = j - 1
    while i < len(a) / 2:
        swap(a, i, j)
        i = i + 1
        j = j - 1


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - 1)
        i += 1


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def find_smallest_position(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return p

def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i, p)
        i = i + 1


def selection_sort(a):
    i = 0
    p = 0
    j = len(a) - 1 - i
    while i < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
        i = i + 1


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a))
        i += 1


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def reverse(a):
    i = 0
    j = -1
    while i < len(a) / 2:
        swap(a, i, j)
        i = i + 1
        j = j - 1


def selection_sort(a):
    while i < len(a):
        j = i
        k = i
        while k < len(a):
            if a[j] > a[k]:
                k = j
            k = k + 1
        tmp = a[i]
        a[i] = a[j]
        a[j] = tmp
        i = i + 1


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - i - 1)
        i += 1


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        swap(a, i, p)
        i = i + 1


def selection_sort(a):
    import func_reverse
    i = 0
    while i < len(a):
        j = i
        while j < len(a):
            if a[j] < a[i]:
                swap(a, i, j)
        i = i + 1


def selection_sort(a):
    i = 0
    while i < len(a):
        p = 0
        j = 1
        if a[j] < a[p]:
            p = j
        j = j + 1
        i = i + 1


def selection_sort(a):
    p = 0
    j = 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1


def selection_sort(a):
    i = 0
    while i < len(a):
        p = 0
        j = 1
        if a[p] < a[j]:
            p = j
        j = j + 1
        i = i + 1


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        m = len(a) - i - 1
        swap(a, i, m)
        i = i + 1


def circumference(r):
    return 2 * 3.141 * r


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        i = i + 1


def circumference(r):
    return 2 * pi() * r


def selection_sort(a):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1


def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i, p)
        i = i + 1


def circumference(r):
    return r * 2 * pi


def circumference(r):
    return 2 * pi * r


def selection_sort(a):
    i = 0
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    j = len(a) - 1
    while i < j:
        swap(a, i, j)
        i += 1
        j -= 1


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        i = i + 1
        return a


def swap(a, i, j):
    tmp = a[p]
    a[p] = a[i]
    a[i] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - i - 1)
    i = i + 1


def selection_sort(a):
    while i < len(a):
        j = i
        k = i
        while k < len(a):
            if a[j] > a[k]:
                k = j
            k = k + 1
        tmp = a[i]
        a[i] = a[j]
        a[j] = tmp
        i = i + 1


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        print(a[i])
        i = i + 1


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - i - 1)
    i = i + 1


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        print(a)


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        i = i + 1
        print(a[i])
        return a


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = a[i]

def reverse(a):
    i = 0
    while i < len(a) / 2:
        a = swap(a, i, len(a) - i)
        i = i + 1


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        i = i + 1
    return a


def reverse(a):
    b = []
    i = 0
    while i < len(a):
        b.append(a[len(a) - 1 - i])
        i = i + 1
    return b


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    x = 0
    y = len(a)
    while x < len(a):
        swap(a, x, y)
        x = x + 1
        y = y - 1


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        i = i + 1


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp
    return a

def reverse(a):
    i = 0
    j = len(a) - 1
    while i < 2 % len(a):
        swap(a, i, j)
        j = j - 1
        i = i + 1
    return a


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = p + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        a_tmp = a[p]
        a[p] = a[i]
        a[i] = a_tmp
        i = i + 1
    z = 0
    while z < len(a):
        print(a[z])
        z = z + 1


def circumference(r):
    return 2 * PI * r


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - i - 1)
        i += 1


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    x = 0
    y = len(a)
    while x < len(a) / 2:
        swap(a, x, y)
        x = x + 1
        y = y - 1


def swap(a, i, j):
    tmp = a[i]
    a[j] = a[i]
    a[j] = tmp

def reverse(a):
    i = 0
    while i < len(a / 2):
        swap(a, i, len(a) - i - 1)
        i = i + 1


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = p + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        a_tmp = a[p]
        a[p] = a[i]
        a[i] = a_tmp
        i = i + 1
    return a


def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i, p)
        i = i + 1
        return a


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    x = 0
    y = len(a)
    while x < len(a) / 2:
        swap(a, x, y - 1)
        x = x + 1
        y = y - 1


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = a[i]

def reverse(a):
    i = 0
    while i < len(a) / 2:
        a = swap(a, i, len(a) - i)
        i = i + 1
    return a


def selection_sort(a):
    p = 0
    j = 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return a


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    while i < len(a / 2):
        swap(a, i, len(a) - i - 1)
    i = i + 1


def swap(a, i, j):
    tmp = a[i]
    a[j] = a[i]
    a[j] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - i - 1)
        i = i + 1


def selection_sort(a):
    i = 0
    while i < len(a):
        j = i
        k = i
        while k < len(a):
            if a[j] > a[k]:
                k = j
            k = k + 1
        tmp = a[i]
        a[i] = a[j]
        a[j] = tmp
        i = i + 1
    return a


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - i - 1)
        i = i + 1


def swap(a, i, j):
    if a != []:
        tmp = a[i]
        a[i] = a[j]
        a[j] = tmp
        return a
    else:
        return a

def reverse(a):
    i = 0
    j = len(a) - 1
    if a != []:
        while i < 2 % len(a):
            swap(a, i, j)
            j = j - 1
            i = i + 1
        return a
    else:
        return a


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        a = swap(a, i, len(a) - i)
        i = i + 1
    return a


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        i = i + 1
    return i


def selection_sort(a):
    p = 0
    j = 0
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return a


def circumference(r):
    return 2 * 3.141 * r


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def selection_sort(a):
    i = 0
    while i < len(a):
        j = i
        while j < len(a):
            if a[j] < a[i]:
                swap(a, i, j)
            j = j + 1
        i = i + 1


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j += 1
        tmp = a[i]
        a[i] = a[p]
        a[p] = tmp
        i += 1


def circumference(r):
    return 2 * pi * r


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
    return a


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        i = i + 1


def reverse(a):
    i = 0
    j = len(a) - 1
    while i < len(a) / 2:
        temp = a[j]
        a[j] = a[i]
        a[i] = temp
        i = i + 1
        j = j - 1


def selection_sort(a):
    n = input()
    a = []
    while n != 'end':
        a.append(int(n))
        n = input()
    i = 0
    while i < len(a):
        small = i
        j = small + 1
        while j < len(a):
            if a[j] < a[small]:
                small = j
            j += 1
        tmp = a[small]
        a[small] = a[i]
        a[i] = tmp
        i += 1
    i = 0
    while i < len(a):
        print(a[i])
        i += 1


def swap(a, i, p):
    tmp = a[p]
    a[p] = a[i]
    a[i] = tmp

def find_smallest_position(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return p

def selection_sort():
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i, p)
        i = i + 1


def selection_sort(a):
    while n != 'end':
        a.append(int(n))
        n = input()
    i = 0
    while i < len(a):
        small = i
        j = small + 1
        while j < len(a):
            if a[j] < a[small]:
                small = j
            j += 1
        tmp = a[small]
        a[small] = a[i]
        a[i] = tmp
        i += 1
    i = 0
    while i < len(a):
        print(a[i])
        i += 1


def swap(a, i, p):
    tmp = a[p]
    a[p] = a[i]
    a[i] = tmp

def find_smallest_position(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return p

def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i, p)
        i = i + 1


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def find_smallest_position(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return p

def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i, p)
        i = i + 1


def selection_sort(a):
    i = 0
    while i < len(a):
        small = i
        j = small + 1
        while j < len(a):
            if a[j] < a[small]:
                small = j
            j += 1
        tmp = a[small]
        a[small] = a[i]
        a[i] = tmp
        i += 1
    i = 0
    while i < len(a):
        print(a[i])
        i += 1


def selection_sort(a):
    p = 0
    j = 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
    j = j + 1
    return p


def selection_sort(a):
    p = 0
    j = 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
    j = j + 1
    return a


def selection_sort(a):
    a = a.sorted()


def reverse(a):
    i = 0
    while i < len(a) / 2:
        a[tmp] = a[i]
        a[i] = a[len(a) - i - 1]
        a[len(a) - i - 1] = a[tmp]
        i = i + 1


def selection_sort(a):
    i = 0
    while i < len(a):
        p = 0
        j = 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1


def selection_sort(a):
    i = 0
    while i < len(a):
        p = 0
        j = 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        i = i + 1


def selection_sort(a):
    i = 0
    while i < len(a):
        j = i + 1
        while j < len(a):
            if a[j] < a[i]:
                tmp = a[j]
                a[j] = a[i]
                a[i] = tmp
            j = j + 1
        i = i + 1
    return a


def reverse(a):
    i = 0
    while i < len(a):
        b.append(a[len(a) - 1 - i])
        i = i + 1
    return b


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - i)
        i = i + 1
    return a


def reverse(a):
    i = 0
    while i < len(a):
        a = a + a[len(a) - i - 1]
        i = i + 1
    return a


def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i, p)
        i = i + 1
        return a


def swap(a, i, j):
    a[tmp] = a[i]
    a[i] = a[j]
    a[j] = a[tmp]

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - i - 1)
        i = i + 1


def swap(a, i, j):
    a[tmp] = a[j]
    a[j] = a[i]
    a[i] = a[tmp]

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - i - 1)
        i = i + 1


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        i = i + 1


def reverse(a):
    i = 0
    t = []
    while i < len(a):
        t = t + a[len(a) - i - 1]
        i = i + 1
    return t


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[p] > a[j]:
                p = j
            j += 1
        tmp = a[i]
        a[i] = a[p]
        a[p] = tmp
        i += 1


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = atmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - i - 1)
        i = i + 1


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - i - 1)
        i = i + 1


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        i = i + 1
    return a


def swap(a, i, j):
    if a != []:
        tmp = a[i]
        a[i] = a[j]
        a[j] = tmp
        return a
    else:
        return a

def reverse(a):
    i = 0
    j = len(a) - 1
    if a != []:
        while i < 2 % len(a):
            swap(a, i, j)
            j = j - 1
            i = i + 1
        return a
    else:
        return a


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
            tmp = a[p]
            a[p] = a[i]
            a[i] = tmp
            i = i + 1
    return a


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp
    return a

def find_smallest_position(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return p

def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i, p)
        i = i + 1
    return a


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
            tmp = a[p]
            a[p] = a[i]
            a[i] = tmp
        i = i + 1
    return a


def selection_sort(a):
    a = a.sorted()


def selection_sort(a):
    i = 0
    while i < len(a):
        small = i
        j = small + 1
        while j < len(a):
            if a[j] < a[small]:
                small = j
            j += 1
        tmp = a[small]
        a[small] = a[i]
        a[i] = tmp
        i += 1
    i = 0
    while i < len(a):
        print(a[i])
        i += 1


def selection_sort(a):
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        smallest(a, j, p)
        swap(a, i, p)
        i += 1


def selection_sort(a):
    i = 0
    while i < len(a):
        small = i
        j = small + 1
        while j < len(a):
            if a[j] < a[small]:
                small = j
            j += 1
        tmp = a[small]
        a[small] = a[i]
        a[i] = tmp
        i += 1


def selection_sort(a):
    p = 0
    j = 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
        a[j] = tmp
        a[p] = a[j]
        tmp = a[p]
    return a


def selection_sort(a):
    i = 0
    j = 0
    p = 0
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp
    while i < len(a):
        p = i
        j = i + 1
        smallest(a, j, p)
        swap(a, i, p)
        i += 1


def swap(a, i, j):
    if a != []:
        tmp = a[i]
        a[i] = a[j]
        a[j] = tmp
        return a
    else:
        return a

def reverse(a):
    i = 0
    j = len(a) - 1
    if a != [] and len(a) > 2:
        while i < 2 % len(a):
            swap(a, i, j)
            j = j - 1
            i = i + 1
        return a
    elif len(a) <= 2 and len(a) > 0:
        swap(a, i, j)
        return a
    else:
        return a


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def find_smallest_position(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return p

def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i, p)
        i = i + 1


def selection_sort(a):
    p = 0
    j = 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
        a[i] = tmp
        a[p] = a[i]
        tmp = a[p]
        i = i + 1
    return a


def selection_sort(a):
    i = 0
    while i < len(a):
        p = 0
        j = 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        i = i + 1


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            i = i + 1
        tmp = a[i]
        a[i] = a[p]
        a[p] = tmp
        i = i + 1
    return a


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            i = i + 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        i = i + 1
    return a


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    while i < len(a):
        a = swap(a, i, len(a) - i)
        i = i + 1
    return a


def selection_sort(a):
    i = 0
    while i < len(a):
        smallest = 0
        j = 1
        while j < len(a):
            if a[j] < a[smallest]:
                smallest = j
            j = j + 1
        tmp = a[0]
        a[0] = a[smallest]
        a[smallest] = tmp
        i = i + 1


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        i = i + 1
    return a


def selection_sort(a):
    i = 0
    p = 0
    j = 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
        a[i] = tmp
        a[p] = a[i]
        tmp = a[p]
        i = i + 1
    return a


def swap(a, i, j):
    if a != []:
        tmp = a[i]
        a[i] = a[j]
        a[j] = tmp
        return a
    else:
        return a

def reverse(a):
    i = 0
    j = len(a) - 1
    if a != [] and len(a) > 2:
        while i < len(a) / 2:
            swap(a, i, j)
            j = j - 1
            i = i + 1
        return a
    elif len(a) <= 2 and len(a) > 0:
        swap(a, i, j)
        return a
    else:
        return a


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp
    return a

def find_smallest_position(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return p

def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i, p)
        i = i + 1
    return p


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i + 1
        j = p
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        i = i + 1


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp
    return a

def find_smallest_position(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return p

def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i, p)
        i = i + 1
    return a


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        i = i + 1


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        temp = a[p]
        a[p] = a[i]
        a[i] = temp
        i = i + 1


def selection_sort(a):
    p = 0
    j = 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
            a[j] = tmp
            a[p] = a[j]
            tmp = a[p]
        j = j + 1
        a[j] = tmp
        a[p] = a[j]
        tmp = a[p]
    return a


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    k = 0
    while k < len(a) / 2:
        a = swap(a, k, len(a) - i)
        k = k + 1
    return a


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    k = 0
    while k < len(a) / 2:
        a = swap(a, k, len(a) - k)
        k = k + 1
    return a


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    tmp = a[p]
    a[p] = a[i]
    a[i] = tmp
    i = i + 1


def circumference(r):
    return 3.141 * 2 * r


def circumference(r):
    return pi * 2 * r


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def smallest_position(a):
    smallest = 0
    j = 1
    while j < len(a):
        if a[j] < a[smallest]:
            smallest = j
            j = j + 1
    return smallest

def selection_sort(a):
    i = 0
    while i < len(a):
        p = smallest_position(a)
        swap(a, i, p)
        i = i + 1


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def smallest_position(a):
    smallest = 0
    j = 1
    while j < len(a):
        if a[j] < a[smallest]:
            smallest = j
        j = j + 1
    return smallest

def selection_sort(a):
    i = 0
    while i < len(a):
        p = smallest_position(a)
        swap(a, i, p)
        i = i + 1


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        a[i] = tmp
        a[p] = a[i]
        tmp = a[p]
        i = i + 1
    return a


def circumference(r):
    return pi * r * 2


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        tmp = a[i]
        a[i] = a[p]
        a[p] = tmp
        i = i + 1
    return a


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        i = i + 1
    return a


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def smallest_position(a):
    smallest = 0
    j = 1
    while j < len(a):
        if a[j] < a[smallest]:
            smallest = j
        j = j + 1
    return smallest

def selection_sort(a):
    i = 0
    while i < len(a):
        p = smallest_position(a[i:])
        swap(a, i, p)
        i = i + 1


def circumference(r):
    return 2 * 3.141 * r


def circumference(r):
    return 2 * pi * r


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def reverse(l):
    i = 0
    j = len(a) - 1
    while i < len(a) / 2:
        swap(a, i, j)
        i += 1
        j -= 1


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - i - 1)
        i = i + 1


def find_smallest_position(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return p

def swap(a, i, p):
    tmp = a[p]
    a[p] = a[i]
    a[i] = tmp

def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i, p)
        i = i + 1


def circumference(r):
    return 3.141 * r * 2


def double(x):
    y = x * 2
    return y


def swap(a, i, j):
    tmp = i
    i = j
    j = tmp
    return a

def reverse(a):
    while i < j:
        swap(a, i, j)
        i = i + 1
        j = j - 1


def swap(a, i, j):
    tmp = i
    i = j
    j = tmp

def reverse(a):
    while i < j:
        swap(a, i, j)
        i = i + 1
        j = j - 1


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def reverse(a):
    i = 0
    j = len(a) - 1
    while i < len(a) / 2:
        swap(a, i, j)
        i += 1
        j -= 1


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def lowest(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return p

def selection_sort(a):
    i = 0
    while i < len(a):
        p = lowest(a, i)
        swap(a, i, p)
        i += 1


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, -(i + 1))
        i += 1


def circumference(r):
    return 2 * 3.14 * r


def double(n):
    m = n * 2
    return m


def area(r):
    pi = 3.141
    a = pi * r * r
    return a


def circumference(r):
    pi = 3.141
    c = 2 * pi * r
    return c


def area(r):
    a = pi * r * r
    return a


def circumference(r):
    c = 2 * pi * r
    return c


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        a = swap(a, i, len(a) - 1)
        i = i + 1


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def reverse(a):
    list(reversed(swap(a)))


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - i - 1)
        i += 1


def swap(a, i, p):
    tmp = a[i]
    a[p] = a[i]
    a[i] = tmp

def find_smallest_position(a, i):
    p = i
    j = j + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return p

def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i, p)
        i = i + 1


def swap(a, i, p):
    tmp = a[p]
    a[p] = a[i]
    a[i] = tmp

def find_smallest_position(a, i):
    p = i
    j = j + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return p

def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i, p)
        i = i + 1


def swap(a, i, p):
    tmp = a[p]
    a[p] = a[i]
    a[i] = tmp

def find_smallest_position(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return p

def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i, p)
        i = i + 1


def circumference(r):
    return 2 * pi * r


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - 1)
        i = i + 1
    return a


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - i - 1)
        i = i + 1
    return a


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        j = len(a) - 1 - i
        swap(a, i, j)
        i = i + 1


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
    i = i + 1


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        i = i + 1


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def selection_sort(a):
    i = 0
    while i < len(a):
        j = i + 1
        while j < len(a):
            if a[j] < a[i]:
                swap(a, i, j)
            j = j + 1
        i = i + 1
    return a


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    j = len(a) - 1
    while i < len(a) / 2:
        swap(a, i, j)
        j = j - 1
        i = i + 1


def selection_sort(a):
    i = 0
    while i < len(a):
        smallest = i
        j = i
        while j < len(a):
            if a[smallest] > a[j]:
                smallest = j
            j = j + 1
        tmp = a[i]
        a[i] = a[smallest]
        a[smallest] = tmp
        i = i + 1


def reverse(a):
    a = a[::-1]
    return a


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp
    return a

def find_smallest_position(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return p

def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i, p)
        i = i + 1
    return a


def reverse(a):
    i = 0
    while i < len(a):
        b.append(a[len(a) - 1 - i])
        i = i + 1
    return b


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j += 1
        swap(a, p, i)
        i += 1


def reverse(a):
    b = a[::-1]
    return b


def reverse(a):
    a[::-1]
    return a


def reverse(a):
    for i in range(0, len(a) / 2):
        a[i], a[len(a) - 1 - i] = a[len(a) - 1 - i], a[i]
    print(a)


def reverse(a):
    for i in range(0, len(a) / 2):
        a[i], a[len(a) - 1 - i] = a[len(a) - 1 - i], a[i]


def reverse(a):
    i = 0
    while i < len(a):
        b.append(a[len(a) - 1 - i])
        i = i + 1
    a = b
    return a


def area(x):
    print(int(x) ** 2 * 3.141)


def circumference(x):
    print(int(x) * 2 * pi)


def area(x):
    print(int(x) ** 2 * pi)


def circumference(x):
    return int(x) * 2 * pi


def area(x):
    return int(x) ** 2 * pi


def circumference(x):
    return float(x) * 2 * pi


def area(x):
    return float(x) ** 2 * pi


def swap(a, i, j):
    temp = a[i]
    a[i] = a[j]
    a[j] = temp
    return a

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - 1 - i)
        i += 1
    return a


def circumference(r):
    return 2 * pi * r


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j += 1
        temp = a[i]
        a[i] = a[p]
        a[p] = temp
        i += 1
    return a


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        j = len(a) - 1 - i
        swap(a, i, j)
        i += 1
    return a


def circumference(r):
    return 2 * 3.141 * r


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def reverse(a):
    i = 0
    j = -1
    while i < len(a) / 2:
        swap(a, i, j)
        i += 1
        j -= 1


def reverse(a):
    b = a[::-1]
    return b


def reverse(a):
    print(a[::-1])
    return


def reverse(a):
    print(a[::-1])
    return a


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp
    return a

def reverse(a):
    i = 0
    j = len(a) - 1
    while i < j:
        swap(a, i, j)
        i = i + 1
        j = j - 1
    return a


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        i = i + 1
    return a


def circumference(r):
    return pi * r * 2


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - i - 1)
        i = i + 1


def find_smallest_position(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return p

def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, j)
        swap(a, i, p)
        i = i + 1


def find_smallest_position(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return p

def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i, p)
        i = i + 1


def selection_sort(a):
    i = 0
    while i < len(a):
        p = find_smallest_position(a, i)
        swap(a, i, p)
        i = i + 1


def union(a, b):
    c = []
    ab = a + b
    for i in ab:
        if not i in c:
            c.append(i)
    return c

Merge two lists into a single one.


def intersection(a, b):
    c = []
    for i in a:
        if i in b and not i in c:
            c.append(i)
        return c

Return the intersection between two lists.


Merge two lists into a single one.


def intersection(a, b):
    c = []
    for i in a:
        if i in b and not i in c:
            c.append(i)
    return c


def area(r):
    a = pi * r ** 2
    return a


def circumference(r):
    c = 2 * pi * r
    return c


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp
    return a

def reverse(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        swap(a, i, p)
        i = i + 1
    return a


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp
    return a

def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        swap(a, i, p)
        i = i + 1
    return a


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp
    return a

def reverse(a):
    i = 0
    if a != str():
        while i < len(a):
            p = i
            j = i + 1
            while j < len(a):
                if a[j] < a[p]:
                    p = j
                j = j + 1
            swap(a, i, p)
            i = i + 1
        return a
    if a == str():
        b = []
        i = 0
        while i < len(a):
            b.append(a[len(a) - i - 1])
            print(b)
            i = i + 1


def swap(a, i, j):
    a[i], a[j] = a[j], a[i]
    return a

def reverse(lst):
    i = len(lst) - 1
    for x in range(len(lst) / 2):
        swap(lst, x, i - x)
    return lst


def swap(a, i, j):
    a[i], a[j] = a[j], a[i]
    return a

def reverse(lst):
    i = 0
    while i < len(lst) / 2:
        swap(lst, i, len(lst) - 1 - i)
        i += 1
    return lst


def square_area(n):
    sq = n * n
    return sq


def circle_area(n):
    result = 3.14 * n ** 2
    return result


def square_area(n):
    result = n * n
    return sq


def rectangle_perimeter(n, m):
    result = 2 * (n + m)
    return result


def square_perimeter(n):
    result = 2 * (n + n)


def circle_circumference(n):
    result = 2 * 3.14 * n
    return result


def square_area(n):
    result = n * n
    return result


def square_perimeter(n):
    result = 2 * (n + n)
    return result


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def sort(a):
    i = 0
    while i < len(a):
        p = find_position_smallest
        swap(a, i, p)
        i = i + 1

Sort a list by repeatedly moving the minimimum of the remaining sublist to the front.

assert sort([0])==None and sort([0])==None and sort([])==None and sort([])==None and sort([' '])==None and sort([' '])==None and sort([70, 339305549])==None and sort([70, 339305549])==None


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

def sort(a):
    i = 0
    while i < len(a):
        p = find_position_smallest
        swap(a, i, p)
        i = i + 1
    return p


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

    def find_position_smallest(a, i):
        p = i
        while i < len(a):
            if a[i] < a[p]:
                p = i
            i = i + 1
        return p

        def sort(a):
            i = 0
            while i < len(a):
                p = find_position_smallest
                swap(a, i, p)
                i = i + 1

def sort(a):
    i = 0
    while i < len(a):
        p = find_position_smallest
        swap(a, i, p)
        i = i + 1


def bsearch(a, q):
    low = 0
    high = len(a)
    while low < high:
        mid = (low + high) / 2
        if a[mid] < q:
            low = mid + 1
        else:
            high = mid
    return low

Search for element q in the sorted array a.


def double(n):
    ans = n * 2
    return ans


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp
    return a[i], a[j]

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - i - 1)
        i = i + 1
    return a


def circumference(r):
    circ = 2 * 3.141 * r
    return circ


def area(r):
    ar = r ** 2 * 3.141
    return ar


def circumference(r):
    pi = 3.141
    circ = 2 * pi * r
    return circ


def area(r):
    pi = 3.141
    ar = r ** 2 * pi
    return ar


def area(r):
    ar = r ** 2 * pi
    return ar


def circumference(r):
    circ = 2 * pi * r
    return circ


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        i = i + 1


def circumference(r):
    return 2 * pi * r


def reverse(a):
    a.reverse()
    return a


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp
    return a

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - i - 1)
        i += 1
    return a


def selection_sort(a):
    i = 0
    while i < len(a):
        j = i
        while j < len(a):
            if a[i] > a[j]:
                tmp = a[i]
                a[i] = a[j]
                a[j] = tmp
            j += 1
        i += 1
        return a


def selection_sort(a):
    i = 0
    while i < len(a):
        j = i
        while j < len(a):
            if a[i] > a[j]:
                tmp = a[i]
                a[i] = a[j]
                a[j] = tmp
            j += 1
        i += 1
    return a


def bsearch(a, q):
    low = 0
    high = len(a)
    while low < high:
        mid = (low + high) / 2
        assert low <= mid < high
        if a[mid] < q:
            low = mid + 1
            assert a[low - 1] < q
        else:
            high = mid
            assert q <= a[high]
    return low


def bsearch(a, q):
    low = 0
    high = len(a)
    while low < high:
        mid = len(a) / 2
        assert low <= mid < high
        if a[mid] < q:
            low = mid + 1
            assert a[low - 1] < q
        else:
            high = mid
            assert q < a[high]
        return low


def bsearch(a, q):
    low = 0
    high = len(a)
    while low < high:
        mid = len(a) / 2
        assert low <= mid < high
        if a[mid] < q:
            low = mid + 1
            assert a[low - 1] < q
        else:
            high = mid
            assert q < a[high + 1]
        return low


def bsearch(a, q):
    low = 0
    high = len(a)
    while low < high:
        mid = len(a) / 2
        assert low <= mid < high
        if a[mid] < q:
            low = mid + 1
            assert a[low - 1] < q
        else:
            high = mid
            assert q <= a[high]
        return low


def bsearch(a, q):
    low = 0
    high = len(a)
    while low < high:
        mid = (low + high) / 2
        assert low <= mid < high
        if a[mid] < q:
            low = mid + 1
            assert a[low - 1] < q
        else:
            high = mid
            assert q <= a[high]
        return low


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        i = i + 1
    return a


def bsearch(a, q):
    low = 0
    high = len(a)
    while low < high:
        mid = (low + high) / 2
        assert low <= mid < high
        if a[mid] < q:
            low = mid + 1
            assert a[low - 1] < q
        else:
            high = mid
            assert q < a[high]
        return low


def bsearch(a, q):
    low = 0
    high = len(a)
    while low < high:
        mid = (low + high) / 2
        assert low <= mid < high
        if a[mid] < q:
            low = mid + 1
            assert a[mid] <= q
        if q < a[mid]:
            high = mid
            assert a[q] < a[high]
        return low


def bsearch(a, q):
    low = 0
    high = len(a)
    while low < high:
        mid = (low + high) / 2
        assert low <= mid < high
        if a[mid] < q:
            low = mid + 1
            assert a[mid] <= q
        if q < a[mid]:
            high = mid
            assert q < a[high]
        return low


def bsearch(a, q):
    low = 0
    high = len(a)
    while low < high:
        mid = (low + high) / 2
        assert low <= mid < high
        if a[mid] < q:
            low = mid + 1
            assert a[mid] <= q
        if q < a[mid]:
            high = mid
            assert q < a[high]
    return low


def bsearch(a, q):
    low = 0
    high = len(a)
    while low < high:
        mid = (low + high) / 2
        assert low <= mid < high
        if q < mid:
            low = mid
            assert a[low - 1] < q
        else:
            high = mid
            assert q <= a[high]
    return low


def bsearch(a, q):
    low = 0
    high = len(a)
    while low < high:
        mid = (low + high) / 2
        assert low <= mid < high
        if q < mid:
            low = mid + 1
            assert a[low - 1] < q
        else:
            high = mid
            assert q <= a[high]
    return low


def bsearch(a, q):
    low = 0
    high = len(a)
    while low < high:
        mid = (low + high) / 2
        assert low <= mid < high
        if a[mid] < q:
            low = mid + 1
            assert a[low - 1] < q
        else:
            high = mid
            assert q <= high
    return low


def bsearch(a, q):
    low = 0
    high = len(a)
    while low < high:
        mid = (low + high) / 2
        assert low <= mid < high
        if q < a[mid]:
            low = mid
            assert a[low - 1] < q
        else:
            high = mid
            assert q < a[high]
    return low


def bsearch(a, q):
    low = 0
    high = len(a)
    while low < high:
        mid = (low + high) / 2
        assert low <= mid < high
        if q < a[mid]:
            low = mid + 1
            assert a[low - 1] < q
        else:
            high = mid
            assert q < a[high]
    return low


def bsearch(a, q):
    low = 0
    high = len(a)
    while low < high:
        mid = (low + high) / 2
        assert low <= mid < high
        if a[mid] < q:
            low = mid + 1
            assert a[low - 1] < q
        else:
            high = mid
            assert q < a[high]
    return low


def swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp
    return a

def reverse(a):
    i = 0
    while i < len(a) / 2:
        j = len(a) - i - 1
        swap(a, i, j)
        i = i + 1
    return a


def reverse(a):
    i = 0
    while i < len(a) / 2:
        j = len(a) - i - 1
        tmp = a[j]
        a[j] = a[i]
        a[i] = tmp
        i = i + 1
    return a


def bsearch(a, q):
    low = 0
    high = len(a)
    while low < high:
        mid = (low + high) / 2
        assert low <= mid < high
        if a[mid] < q:
            low = mid + 1
            assert a[low - 1] < q
        elif q < a[mid]:
            high = mid
            assert q <= a[high]
    return low


def bsearch(a, q):
    low = 0
    high = len(a)
    while low < high:
        mid = (low + high) / 2
        assert low <= mid < high
        if a[mid] < q:
            low = mid + 1
            assert a[low - 1] < q
        else:
            high = mid
            assert q <= a[high]
    return low


def swap(a, i, j):
    tmp = a[i]
    tmp1 = a[j]
    a[i] = tmp1
    a[j] = tmp

def reverse(a):
    i = 0
    j = len(a) - i - 1
    while i < len(a) / 2:
        swap(a, i, j)
        i = i + 1
    return a


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp
    return a[i], a[j]

def reverse(a):
    i = 0
    j = len(a) - i - 1
    while i < len(a) / 2:
        swap(a, i, j)
        i = i + 1
    return a


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp
    return a[i], a[j]

def reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - i - 1)
        i = i + 1
    return a


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        i = i + 1
    return a


def bsearch(a, q):
    low = 0
    high = len(a)
    while low < high:
        mid = (low + high) / 2
        assert low <= mid < high
        if a[mid] < q:
            low = mid + 1
            assert a[low - 1] < q
        if q < a[high]:
            high = mid
            assert q <= a[high]
    return low


def bsearch(a, q):
    low = 0
    high = len(a)
    while low < high:
        mid = (low + high) / 2
        assert low <= mid < high
        if a[mid] < q:
            low = mid + 1
            assert a[low - 1] < q
        if q < a[mid]:
            high = mid
            assert q <= a[high]
    return low


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

Swap the keys of a dictionary with its values.


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 weird_case(some_str):
    new_str = ''
    i = 0
    lc = 0
    while i < len(some_str):
        if some_str[i].isalpha():
            if lc % 2 == 0:
                new_str += some_str[i].upper()
            else:
                new_str += some_str[i].lower()
            lc += 1
        else:
            new_str += some_str[i]
        i = i + 1
    return new_str


def remove_zeros(list):
    while 0 in list:
        list.remove(0)

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 merge_lists(l1, l2):
    l3 = []
    i = 0
    while i < len(l1):
        l3.append(l1[i])
        i += 2
    i = 0
    while i < len(l2):
        l3.append(l2[i])
        i += 2
    return l3

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


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


def remove_zeros(list):
    for i in list:
        if i == 0:
            list.remove[i]


def merge_lists(l1, l2):
    l3 = l1 + l2
    return l3[0::2]


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


def weird_case(some_str):
    weird = []
    i = 0
    while i < len(some_str):
        if i % 2 == 0:
            weird.append(some_str[i].upper())
        else:
            weird.append(some_str[i])
        i += 1
    return ''.join(weird)


def merge_lists(l1, l2):
    return l1[0::2] + l2[0::2]


def remove_zeros(list):
    for i in list:
        if i == 0:
            list.remove[i]
    return list


def remove_zeros(list):
    while 0 in list:
        for i in list:
            if i == 0:
                list.remove(i)
    return list


def weird_case(some_str):
    weird = []
    i = True
    for char in some_str:
        weird += char.upper() if i else char
        if char != ' ':
            i = not i
    return ''.join(weird)


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


def weird_case(some_str):
    weird, i = [], True
    for char in some_str:
        weird += char.upper() if i else char
        if char != ' ':
            i = not i
    return ''.join(weird)


def weird_case(some_str):
    i = 0
    while i < len(some_str):
        if i % 2 == 0:
            some_str[i] = some_str[i].upper()
    return some_str


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


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


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


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


def weird_case(some_str):
    i = 0
    while i < len(some_str):
        if i % 2 == 0:
            some_str[i] = some_str[i].upper()
        i = i + 1
    return some_str


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


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


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


def get_price(age):
    if age < 17:
        return 'pay 5 euro'
    elif age > 60:
        return 'pay 7 euro'
    else:
        return 'pay 10 euro'


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


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


def merge_lists(l1, l2):
    l3 = l1[::2] + l2[::2]
    return l3


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


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


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


def merge_lists(l1l2):
    i = 0
    j = 0
    l3 = []
    while i < len(l1) / 2:
        l3.append(l1[i])
        l3.append(l2[i])
        i = i + 2
        j = j + 2


def merge_lists(l1l2):
    i = 0
    j = 0
    l3 = []
    while i < len(l1) / 2:
        l3.append(l1[i])
        l3.append(l2[i])
        i = i + 2
        j = j + 2
    print(l3)


def merge_lists(l1l2):
    i = 0
    j = 0
    l3 = []
    while i < len(l1) / 2:
        l3.append(l1[i])
        print(l3)


def merge_lists(l1l2):
    i = 0
    j = 0
    l3 = []
    while i < len(l1) / 2:
        l3.append(l1[i])
    print(l3)


def merge_lists(l1l2):
    i = 0
    j = 0
    l3 = []
    while i < len(l1) / 2:
        l3.append(i)
    print(l3)


def merge_lists(l1l2):
    i = 0
    l3 = []
    while i < len(l1) / 2:
        l3.append(i)
    print(l3)


def merge_lists(l1l2):
    i = 0
    l3 = []
    while i < len(l1):
        l3.append(i)
    print(l3)


def get_price(age):
    age = input('Please enter age:\n')
    if int(age) <= 16:
        return '5 euro'
    elif int(age) >= 60:
        return '7 euro'
    else:
        return '10 euro'


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


def merge_lists(l1l2):
    i = 0
    l3 = []
    while i < len(l1) / 2:
        if l1[i] in l1:
            l3.append(l1[i])


def remove_zeros(list):
    i = 0
    if list[i] == 0:
        del list[i]


def merge_lists(l1l2):
    return l1l2[::2]


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


def merge_lists(l1, l2):
    l3 = l1[::2] + l2[::2]
    return l3


def remove_zeros(list):
    i = 0
    if list[i] == 0:
        list.remove(list[i])


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


def merge_lists(l1l2):
    l3 = l1[::2] + l2[::2]
    return l3


def get_price(age):
    if int(age) <= 16:
        return 5
    elif int(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 = i + 1


def get_price(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 = i + 1


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


def merge_lists(l1, l2):
    i = 0
    l3 = []
    while i < len(l1) / 2:
        if l1[i] in l1:
            l3.append(l1[i])


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


def merge_lists(l1, l2):
    i = 0
    l3 = []
    while i < len(l1) / 2:
        if l1[i] in l1:
            l3.append(l1[i])
        i = i + 2
    print(l3)


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


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


def merge_lists(l1, l2):
    i = 0
    while i < len(l1):
        l1_1 = l1[i]
        i += 2
        j = 0
        while j < len(l2):
            l2_1 = l2[j]
            j += 2
            l3 = str(l1_1) + str(l2_1)
        return l3


def merge_lists(l1, l2):
    i = 0
    l3 = []
    while i < len(l1):
        if l1[i] in l1:
            l3.append(l1[i])
            i = i + 2
        elif l2[i] in l2:
            l3.append(l2[i])
            i = i + 2
    print(l3)


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


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


def merge_lists(l1, l2):
    i = 0
    while i < len(l1):
        l1_1 = l1[i]
        i += 2
        j = 0
        while j < len(l2):
            l2_1 = l2[j]
            j += 2
        return l3


def merge_lists(l1, l2):
    l3 = l1[::2] + l2[::2]
    return l3


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


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


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


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


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


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


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


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


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


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


def merge_lists(l1, l2):
    i = 0
    j = 0
    l3 = []
    while i < len(l1) and j < len(l2):
        if l1[i] in l1:
            l3.append(l1[i])
            i = i + 2
        elif l2[i] in l2:
            l3.append(l2[i])
            i = i + 2
    return l3


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


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


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


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


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


def merge_lists(l1, l2):
    i = 0
    j = 0
    l3 = []
    while i < len(l1) and j < len(l2):
        if l1[i] in l1:
            l3.append(l1[i])
            i = i + 2
        elif l2[j] in l2:
            l3.append(l2[j])
            j = j + 2
    return l3


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


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


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


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


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


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


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


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


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


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


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


def merge_lists(l1, l2):
    l3 = l1[::2] + l2[::2]
    return l3


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


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


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


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


def merge_lists(l1, l2):
    i = 0
    while i < len(l1):
        l1_1 = l1[i]
        i += 2
        j = 0
        while j < len(l2):
            l2_1 = l2[j]
            j += 2
            l3 = []
            l3.append(l1_1), '6', l3.append(l2_1)
        return l3


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


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


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


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


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


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


def weird_case(some_str):
    i = 0
    while i < len(some_str):
        if some_str[i].isalpha():
            some_str[i].upper()
        i = i + 2
    j = 1
    while j < len(some_str):
        if some_str[j].isalpha():
            some_str[j].lower()
        j = j + 2
    return some_str


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
    l3 = []
    while i < len(l1):
        l3.append(l1[i])
        i += 2
    j = 0
    while j < len(l2):
        l3.append(l2[i])
        j += 2
        return l3


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


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


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


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


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


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


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


def weird_case(some_str):
    i = 0
    string2 = ''
    while i < len(some_str):
        string2 = some_str[i].upper()
        i += 2
        return string2


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


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):
    l3 = []
    i = 0
    while i < len(l1):
        l3.append(l1[i])
        i = i + 2
    j = 0
    while j < len(l2):
        l3.append(l2[j])
        j = j + 2
    return l3


def weird_case(some_str):
    i = 0
    while i < len(some_str):
        some_str = some_str.split(' ')
        return some_str
        i += 2


def weird_case(some_str):
    i = 0
    string2 = ''
    while i < len(some_str):
        some_str = some_str.split()
        string2 = some_str[i].upper()
        i += 2
        return string2


def merge_lists(l1, l2):
    l3 = l1 + l2
    return l3


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


def weird_case(some_str):
    i = 0
    while i < len(some_str):
        some_str = some_str.split(' ')
        return some_str[i]
        i += 2


def weird_case(some_str):
    i = 0
    while i < len(some_str):
        some_str = some_str.split(' ')
        return some_str[i]
        i += 1


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


def weird_case(some_str):
    i = 0
    string2 = ''
    while i < len(some_str):
        some_str = some_str.split()
        string2 = str(some_str[i]).upper()
        i += 2
        return string2


def weird_case(some_str):
    i = 0
    string2 = ''
    while i < len(some_str):
        some_str = some_str.split()
        print(some_str)
        i += 2
        return string2


def merge_lists(l1, l2):
    l3 = list(set(l1 + l2))
    return l3


def weird_case(some_str):
    i = 0
    string2 = ''
    while i < len(some_str):
        some_str = str(some_str).split()
        print(some_str)
        i += 2
        return string2


def weird_case(some_str):
    i = 0
    while i < len(some_str):
        some_str = some_str.split(' ')
        new_str = some_str.splt()
        return new_str[i]
        i += 2


def weird_case(some_str):
    i = 0
    while i < len(some_str):
        some_str = some_str.split(' ')
        new_str = some_str.spIlt()
        return new_str[i]
        i += 2


def weird_case(some_str):
    i = 0
    while i < len(some_str):
        some_str = some_str.split(' ')
        new_str = some_str.spilt()
        return new_str[i]
        i += 2


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


def weird_case(some_str):
    i = 0
    while i < len(some_str):
        some_str = some_str.split(' ')
        new_str = some_str.split()
        return new_str[i]
        i += 2


def merge_lists(l1, l2):
    l3 == l1[::2] + l2[::2]
    return l3


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


def merge_lists(l1, l2):
    l3 = l1[0::2] + l2[0::2]
    return l3


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


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


def weird_case(some_str):
    i = 0
    while i < len(some_str):
        some_str = some_str.split()
        return new_str[i]
        i += 2


def weird_case(some_str):
    i = 0
    while i < len(some_str):
        some_str = some_str.split()
        return some_str[i]
        i += 2


def merge_lists(l1, l2):
    l3 = l1[::2] + l2[::2]
    return l3


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


def weird_case(some_str):
    i = 0
    while i < len(some_str):
        some_str = some_str.split()
        return some_str
        i += 2


def weird_case(some_str):
    new_str = some_str[0::2], isupper
    return new_str


def get_price(age):
    if age <= 16:
        price == 5.0
    elif age >= 60:
        price == 7.0
    else:
        price == 10
    print(str(price))


def weird_case(some_str):
    new_str = some_str[0::2], isupper()
    return new_str


def weird_case(some_str):
    new_str = some_str[0::2].isupper()
    return new_str


def get_price(age):
    if age <= 16:
        get_price == 5.0
    elif age >= 60:
        get_price == 7.0
    else:
        get_price == 10
    print(str(get_price))


def get_price(age):
    if age <= 16:
        get_price == 5.0
    elif age >= 60:
        get_price == 7.0
    else:
        get_price == 10
    print(get_price)


def weird_case(some_str):
    s2 = some_str[0::2].upper()
    return s2


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


def weird_case(some_str):
    i = 0
    while i < len(some_str):
        some_str = some_str[i].split(' ')
        return some_str
        i += 2


def weird_case(some_str):
    new_str = some_str[0::2].isalpha()
    return new_str


def merge_lists(l1, l2):
    l3 = l1[0::2] + l2[0::2]
    return l3


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


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


def weird_case(some_str):
    i = 0
    while i < len(some_str):
        some_str = some_str[i].split()
        return some_str
        i += 2


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


def weird_case(some_str):
    i = 0
    string2 = ''
    while i < len(some_str):
        some_str = some_str[i].split()
        print(some_str)
        i += 2
        return string2


def merge_lists(l1, l2):
    l3 = l1[::2] + l2[::2]
    return l3


def weird_case(some_str):
    return some_str.upper()[::2]


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


def weird_case(some_str):
    i = 0
    string2 = ''
    while i < len(some_str):
        some_str = some_str[i].split()
        string2 = some_str[i].upper()
        i += 2
        return string2


def weird_case(some_str):
    new_str = some_str[0::2].alpha()
    return new_str


def weird_case(some_str):
    i = 0
    while i < len(some_str):
        some_str = some_str[i].split()
        new_str = some_str[i].upper()
        return some_str
        i += 2


def weird_case(some_str):
    s1 = some_str[1::3].lower()
    s2 = some_str[0::2].upper()
    s3 = s1 + s2
    return s3


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


def weird_case(some_str):
    if some_str != ' ':
        return some_str.upper()[::2]


def weird_case(some_str):
    if some_str[i] != ' ':
        return some_str.upper()[::2]


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


def weird_case(some_str):
    i = 0
    new_str = ''
    while i < len(some_str):
        some_str = some_str[i].split()
        new_str = some_str[i].upper()
        i += 2
        return some_str


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


def get_price(age):
    if int(age) <= 16:
        return 5
    elif int(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 weird_case(some_str):
    new_str = ''
    i = 0
    while i < len(some_str):
        if some_str[i]:
            if i == 0 or i % 2 == 0:
                new_str = new_str + some_str[i].upper()
            else:
                new_str = new_str + some_str[i].lower()
        i = i + 1
    return new_str


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


def weird_case(some_str):
    i = 0
    new_str = ''
    while i < len(some_str):
        some_str = some_str[i].split()
        new_str = some_str[i].upper()
        i += 2
        return new_str


def get_price(age):
    if age <= 16:
        get_price == 5.0
    elif age >= 60:
        get_price == 7.0
    else:
        get_price == 10


def weird_case(some_str):
    new_str = ''
    i = 0
    while i < len(some_str):
        if i == 0 or i % 2 == 0:
            new_str = new_str + some_str[i].upper()
        i = i + 1
    return new_str


def weird_case(some_str):
    new_str = ''
    i = 0
    while i < len(some_str):
        if i == 0 or i % 2 == 0:
            new_str = new_str + some_str[i].upper()
        else:
            new_str = new_str + some_str[i].lower()
        i = i + 1
    return new_str


def weird_case(some_str):
    new_str = some_str[0::2].upper()
    return new_str


def merge_lists(l1, l2):
    l3 = l1[0::2] + l2[0::2]
    return l3


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


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


def merge_lists(l1, l2):
    l3 = l1[::2] + l2[::2]
    return l3


def weird_case(some_str):
    if some_str != ' ':
        return some_str.upper()[::2]


def weird_case(some_str):
    new_str = some_str[0::2]
    return new_str.upper()


def weird_case(some_str):
    new_str = ''
    i = 0
    while i < len(some_str):
        some_str1 = some_str.split()
        if i == 0 or i % 2 == 0:
            new_str = new_str + some_str1[i].upper()
        else:
            new_str = new_str + some_str1[i].lower()
        i = i + 1
    return new_str


def weird_case(some_str):
    new_str = some_str.upper()
    return new_str[0::2]


def weird_case(some_str):
    new_str = ''
    i = 0
    while i < len(some_str):
        if some_str.isalpha():
            if i == 0 or i % 2 == 0:
                new_str = new_str + some_str[i].upper()
            else:
                new_str = new_str + some_str[i].lower()
        i = i + 1
    return new_str


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


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


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


def weird_case(some_str):
    new_str = ''
    i = 0
    while i < len(some_str):
        some_str = some_str[i].split()
        if i == 0 or i % 2 == 0:
            new_str = new_str + some_str.upper()
        else:
            new_str = new_str + some_str.lower()
        i = i + 1
    return new_str


def weird_case(some_str):
    new_str = ''
    i = 0
    while i < len(some_str):
        some_str = some_str[i].split().upper()
        if i == 0 or i % 2 == 0:
            new_str = new_str + some_str.upper()
        else:
            new_str = new_str + some_str.lower()
        i = i + 1
    return new_str


def weird_case(some_str):
    new_str = ''
    i = 0
    while i < len(some_str):
        some_str = some_str[i].split().upper()
        if i == 0 or i % 2 == 0:
            new_str = new_str + some_str
        else:
            new_str = new_str + some_str
        i = i + 1
    return new_str


def weird_case(some_str):
    new_str = ''
    i = 0
    while i < len(some_str):
        some_str = some_str[i].split().upper()
        if i == 0 or i % 2 == 0:
            new_str = new_str + some_str.upper()
        else:
            new_str = new_str + some_str.lower()
        i = i + 1
    return some_str


def weird_case(some_str):
    new_str = ''
    i = 0
    while i < len(some_str):
        some_str = some_str[i].split()
        if i == 0 or i % 2 == 0:
            new_str = new_str + some_str.upper()
        else:
            new_str = new_str + some_str.lower()
        i = i + 1
    return some_str


def weird_case(some_str):
    new_str = ''
    i = 0
    while i < len(some_str):
        some_str = some_str[i].split()
        i = i + 1
    return some_str


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


def merge_lists(l1, l2):
    l3 = l1[0::2] + l2[0::2]
    return l3


def merge_lists(l1, l2):
    l3 = l1[::2] + l2[::2]
    return l3


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


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


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


def weird_case(some_str):
    s1 = some_str[1::3].lower()
    s2 = some_str[0::2].upper()
    s3 = s1 + s2
    return s3


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


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


def weird_case(some_str):
    new_str = ''
    i = 0
    while i < len(some_str):
        if i == 0 or i % 2 == 0:
            new_str = new_str + some_str.upper()
        else:
            new_str = new_str + some_str.lower()
        i = i + 1
    return some_str