def intersection(a, b):
    i = 0
    s = []
    while i < len(a) and i < len(b):
        if a[i] in b:
            s.append(a[i])
        i = i + 1
    n = 0
    prev = s[n]
    curr = s[n + 1]
    x = []
    while curr < len(s):
        if curr != prev:
            x.append(prev)
        n = n + 1
    return x


def intersection(a, b):
    int_seen = {}
    f = 0
    while f < len(a):
        if a[f] in b:
            int_seen[a[f]] = True
        f = f + 1
    return int_seen

Return the intersection between two lists.


def union(a, b):
    seen = {}
    i = 0
    while i < len(a):
        if a[i] not in seen:
            seen[a[i]] = True
        i = i + 1
    j = 0
    while j < len(b):
        if b[j] not in seen:
            seen[b[j]] = True
        j = j + 1
    return seen

Merge two lists into a single one.


Merge two lists into a single one.


def intersection(a, b):
    seen = {}
    i = 0
    while i < leb(a):
        if a[i] in b and not a[i] in seen:
            seen[a[i]] = True
        i = i + 1
    return seen


def union(a, b):
    seen = {}
    i = 0
    while i < len(a):
        seen[a[i]] = True
        i = i + 1
    j = 0
    while j < len(b):
        if not b[j] in seen:
            seen[b[j]] = True
        j = j + 1
    return seen

Merge two lists into a single one.


def intersection(a, b):
    seen = {}
    i = 0
    while i < len(a):
        if a[i] in b and not a[i] in seen:
            seen[a[i]] = True
        i = i + 1
    return seen


def union(a, b):
    seen = []
    i = 0
    while i < len(a):
        seen[a[i]] = True
        i = i + 1
    j = 0
    while j < len(b):
        if not b[j] in b:
            seen[b[j]] = True
        j = j + 1
    return seen

Merge two lists into a single one.


def intersection(a, b):
    int_seen = {}
    k = 0
    while k < len(a):
        if a[k] in b:
            int_seen[a[k]] = True
        k = k + 1
    return int_seen


def intersection(a, b):
    i = 0
    s = []
    while i < len(a) and i < len(b):
        if a[i] in b:
            s.append(a[i])
        i = i + 1
    n = 0
    prev = s[n]
    curr = s[n + 1]
    x = []
    while n - 1 < len(s):
        if curr != prev:
            x.append(prev)
        n = n + 1
    return x


def union(a, b):
    s = a + b
    return set(s)

Merge two lists into a single one.


def union(a, b):
    seen = []
    i = 0
    while i < len(a):
        seen[a[i]] = True
        i = i + 1
    j = 0
    while j < len(b):
        if not b[j] in seen:
            seen[b[j]] = True
        j = j + 1
    return seen

Merge two lists into a single one.


def union(a, b):
    i = 0
    seen = []
    while i < len(a):
        seen[a[i]] = True
        i = i + 1
    k = 0
    while k < len(b):
        if not b[k] in seen:
            seen[b[k]] = True
        k = k + 1
    return seen

Merge two lists into a single one.


def intersection(a, b):
    i = 0
    s = []
    while i < len(a) and i < len(b):
        if a[i] in b:
            s.append(a[i])
        i = i + 1
    return set(s)


def union(a, b):
    set = {}
    i = 0
    while i < len(a):
        set[a[i]] = True
        i = i + 1
    j = 0
    while j < len(b):
        if not b[j] in set:
            set[b[j]] = True
        j = j + 1
    return set

Merge two lists into a single one.


def intersection(a, b):
    set = {}
    i = 0
    while i < len(a):
        if a[i] in b and not a[i] in set:
            set[a[i]] = True
        i = i + 1
        return set


def intersection(a, b):
    seen = []
    i = 0
    while i < len(a):
        if a[i] in b and not a[i] in seen:
            seen[a[i]] = True
        i = i + 1
    return seen


def union(a, b):
    seen = []
    i = 0
    while i < len(a):
        seen[a[i]] = True
        i = i + 1
    k = 0
    while k < len(b):
        if not b[k] in seen:
            seen[b[k]] = True
        k = k + 1
    return seen

Merge two lists into a single one.


def union(a, b):
    seen = {}
    i = 0
    while i < len(a):
        seen[a[i]] = True
        i = i + 1
    k = 0
    while k < len(b):
        if not b[k] in seen:
            seen[b[k]] = True
        k = k + 1
    return seen

Merge two lists into a single one.


def intersection(a, b):
    d = a + b
    return d


def union(a, b):
    c = a, b
    return c

Merge two lists into a single one.


Merge two lists into a single one.


def union(a, b):
    c = a and b
    return c

Merge two lists into a single one.


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 a and i in b and not i in c:
            c.append(i)
    return c


def intersection(a, b):
    d = c - b
    return d


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


def union(a, b):
    i = 0
    while i < len(a):
        if a != b:
            print(a, b)

Merge two lists into a single one.


def intersection(a, b):
    c = []
    c = a + b
    seen = {}
    i = 0
    while i < len(c):
        if lines(c) in seen:
            sys.stdout.write(lines[c])
        i = i + 1


def union(a, b):
    c = []
    c = a - b
    seen = {}
    i = 0
    while i < len(c):
        if lines(c) not in seen:
            sys.stdout.write(lines[c])
        i = i + 1

Merge two lists into a single one.


def intersection(a, b):
    seen = {}
    i = 0
    while i < len(a):
        if a[i] in b and not a[i] in seen:
            seen[a[i]] = True
        i = i + 1
        return seen


def union(a, b):
    seen = {}
    i = 0
    while i < len(a):
        seen[a[i]] = True
        i = i + 1
    j = 0
    while j < len(b):
        if not b[j] in seen:
            seen[b[j]] = True
        j = j + 1
    return seen

Merge two lists into a single one.


def union(x, y):
    answer = []
    check = {}
    i = 0
    while i < len(x):
        if not x[i] in check:
            answer.append(x[i])
            check[x[i]] = True
        i = i + 1
    j = 0
    while i < len(y):
        if not y[j] in check:
            answer.append(y[j])
            check[y[j]] = True
        j = j + 1
    return check

Merge two lists into a single one.


def intersection():
    import sys
    d1 = {}
    i = 0
    while i != len(f1con):
        line = f1con[i].rstrip()
        d1[line] = True
        i = i + 1
    dups = []
    i = 0
    while i != len(f2con):
        line = f2con[i].rstrip()
        if line in list(d1.keys()):
            dups.append(line)
        i = i + 1
    dups = sorted(list(set(dups)))
    return dups


def union(f1con, f2con):
    import sys
    d1 = {}
    i = 0
    while i != len(f1con):
        line = f1con[i].rstrip()
        d1[line] = True
        i = i + 1
    dups = []
    i = 0
    while i != len(f2con):
        line = f2con[i].rstrip()
        if line in list(d1.keys()):
            dups.append(line)
        i = i + 1
    dups = sorted(list(set(dups)))
    return dups

Merge two lists into a single one.


def union(x, y):
    answer = []
    check = {}
    i = 0
    while i < len(x):
        answer.append(x[i])
        check[x[i]] = True
        i = i + 1
    j = 0
    while i < len(y):
        if not y[j] in check:
            answer.append(y[j])
            check[y[j]] = True
        j = j + 1
    return answer

Merge two lists into a single one.


def union(x, y):
    answer = []
    check = {}
    i = 0
    while i < len(x):
        if not x[i] in check:
            answer.append(x[i])
            check[x[i]] = True
        i = i + 1
    j = 0
    while j < len(y):
        if not y[j] in check:
            answer.append(y[j])
            check[y[j]] = True
        j = j + 1
    return answer

Merge two lists into a single one.


def intersection():
    d1 = {}
    i = 0
    while i != len(f1con):
        line = f1con[i].rstrip()
        d1[line] = True
        i = i + 1
    dups = []
    i = 0
    while i != len(f2con):
        line = f2con[i].rstrip()
        if line in list(d1.keys()):
            dups.append(line)
        i = i + 1
    dups = sorted(list(set(dups)))
    return dups


def union(f1con, f2con):
    union = []
    i = 0
    while i != len(f1con):
        union.append(f1con[i])
        i = i + 1
    i = 0
    while i != len(f1con):
        union.append(f1con[i])
        i = i + 1
    union = sorted(list(set(union)))
    return union

Merge two lists into a single one.


Merge two lists into a single one.


def intersection(f1con, f2con):
    d1 = {}
    i = 0
    while i != len(f1con):
        line = f1con[i].rstrip()
        d1[line] = True
        i = i + 1
    dups = []
    i = 0
    while i != len(f2con):
        line = f2con[i].rstrip()
        if line in list(d1.keys()):
            dups.append(line)
        i = i + 1
    dups = sorted(list(set(dups)))
    return dups


def union(a, b):
    seen = {}
    i = 0
    while i < len(a):
        seen[a[i]] = True
        i = i + 1
    k = 0
    while k < len(b):
        if not b[k] in seen:
            seen[b[k]] = True
        k = k + 1
        return seen

Merge two lists into a single one.


def intersection(a, b):
    seen = {}
    i = 0
    while i < len(a):
        if a[i] in b and not a[i] in seen:
            seen[a[i]] = True
        i = i + 1
    return seen


def intersection(f1con, f2con):
    d1 = {}
    i = 0
    while i != len(f1con):
        line = f1con[i].rstrip()
        d1[line] = True
        i = i + 1
    dups = []
    i = 0
    while i != len(f2con):
        line = f2con[i]
        if line in list(d1.keys()):
            dups.append(line)
        i = i + 1
    dups = sorted(list(set(dups)))
    return dups


def intersection(f1con, f2con):
    d1 = {}
    i = 0
    while i != len(f1con):
        line = f1con[i]
        d1[line] = True
        i = i + 1
    dups = []
    i = 0
    while i != len(f2con):
        line = f2con[i]
        if line in list(d1.keys()):
            dups.append(line)
        i = i + 1
    dups = sorted(list(set(dups)))
    return dups


def union(f1con, f2con):
    d1 = {}
    union = []
    i = 0
    while i != len(f1con):
        line = f1con[i]
        d1[line] = True
        i = i + 1
    i = 0
    while i != len(f2con):
        line = f2con[i]
        if line in list(d1.keys()):
            union.append(line)
        i = i + 1
    union = sorted(list(set(union)))
    return union

Merge two lists into a single one.


def union(a, b):
    seen = {}
    i = 0
    while i < len(a):
        seen[a[i]] = True
        i = i + 1
    k = 0
    while k < len(b):
        if not b[k] in seen:
            seen[b[k]] = True
            k = k + 1
        return seen

Merge two lists into a single one.


def union(a, b):
    seen = {}
    i = 0
    while i < len(a):
        seen[a[i]] = True
        i = i + 1
    k = 0
    while k < len(b):
        if not b[k] in seen:
            seen[b[k]] = True
        k = k + 1
    return seen

Merge two lists into a single one.


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]
        i = i + 1
    return a

Iteratively reverse a list of elements.


def union(f1con, f2con):
    union = []
    i = 0
    while i != len(f1con):
        union.append(f1con[i])
        i = i + 1
    i = 0
    while i != len(f2con):
        union.append(f2con[i])
        i = i + 1
    union = sorted(list(set(union)))
    return union

Merge two lists into a single one.


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
    return a

Iteratively reverse a list of elements.


Iteratively reverse a list of elements.


def intersection(x, y):
    check = {}
    i = 0
    while i < len(x):
        if x[i] in y and not x[i] in check:
            check[x[i]] = True
        i = i + 1
    return check


def union(f1con, f2con):
    union = []
    i = 0
    while i != len(f1con):
        union.append(f1con[i])
        i = i + 1
    i = 0
    while i != len(f2con):
        union.append(f2con[i])
        i = i + 1
    union = sorted(list(dict(union)))
    return union

Merge two lists into a single one.


def intersection(f1con, f2con):
    d1 = {}
    i = 0
    while i != len(f1con):
        line = f1con[i]
        d1[line] = True
        i = i + 1
    dups = []
    i = 0
    while i != len(f2con):
        line = f2con[i]
        if line in list(d1.keys()):
            dups.append(line)
        i = i + 1
    dups = sorted(list(dict(dups)))
    return dups


def union(a, b):
    i = 0
    while i < len(a):
        if a != b:
            c = a, b
            return c
            i = i + 1

Merge two lists into a single one.


def union(a, b):
    i = 0
    while i < len(a):
        if a != b:
            c = (a, b) - (a + b)
            return c
            i = i + 1

Merge two lists into a single one.


def union(a, b):
    seen = {}
    i = 0
    while i < len(a):
        seen[a[i]] = True
        i = i + 1
    j = 0
    while j < len(b):
        if not b[j] in seen:
            seen[b[j]] = True
        j = j + 1
    return seen

Merge two lists into a single one.


Merge two lists into a single one.


def union(f1con, f2con):
    union = []
    i = 0
    while i != len(f1con):
        union.append(f1con[i])
        i = i + 1
    i = 0
    while i != len(f2con):
        union.append(f2con[i])
        i = i + 1
    unionorg = {}
    i = 0
    while i != len(union):
        unionorg[union] = True
        i = i + 1
    for union in sorted(unionorg):
        if unionorg[union]:
            print(union)
    return union

Merge two lists into a single one.


def intersection(f1con, f2con):
    d1 = {}
    i = 0
    while i != len(f1con):
        line = f1con[i]
        d1[line] = True
        i = i + 1
    dups = []
    i = 0
    while i != len(f2con):
        line = f2con[i]
        if line in list(d1.keys()):
            dups.append(line)
        i = i + 1
    return dups


def union(a, b):
    i = 0
    c = []
    while i < len(a):
        if a != b:
            c = a, b
            return c
            i = i + 1

Merge two lists into a single one.


def union(f1con, f2con):
    union = []
    i = 0
    while i != len(f1con):
        union.append(f1con[i])
        i = i + 1
    i = 0
    while i != len(f2con):
        union.append(f2con[i])
        i = i + 1
    unionorg = {}
    i = 0
    while i != len(union):
        unionorg[union] = True
        i = i + 1
    dups = sorted(list(set(dups)))
    return '/n', unionorg

Merge two lists into a single one.


def union(f1con, f2con):
    union = []
    i = 0
    while i != len(f1con):
        union.append(f1con[i])
        i = i + 1
    i = 0
    while i != len(f2con):
        union.append(f2con[i])
        i = i + 1
    unionorg = {}
    i = 0
    while i != len(union):
        unionorg[union[i]] = True
        i = i + 1
    dups = sorted(list(set(dups)))
    return '/n', unionorg

Merge two lists into a single one.


def union(a, b):
    seen = {}
    c = []
    i = 0
    while i < len(a) and i < len(b):
        if a[i] or b[i] not in seen:
            seen[a[i]] = True
            seen[b[i]] = True
        i = i + 1
    for number in seen:
        c.append(number)
    return c

Merge two lists into a single one.


def union(f1con, f2con):
    union = []
    i = 0
    while i != len(f1con):
        union.append(f1con[i])
        i = i + 1
    i = 0
    while i != len(f2con):
        union.append(f2con[i])
        i = i + 1
    unionorg = {}
    i = 0
    while i != len(union):
        unionorg[union[i]] = True
        i = i + 1
    return '/n', unionorg

Merge two lists into a single one.


def union(f1con, f2con):
    union = []
    i = 0
    while i != len(f1con):
        union.append(f1con[i])
        i = i + 1
    i = 0
    while i != len(f2con):
        union.append(f2con[i])
        i = i + 1
    unionorg = {}
    i = 0
    while i != len(union):
        unionorg[union[i]] = True
        i = i + 1
    pureunion = []
    for union in sorted(unionorg):
        if unionorg[union]:
            pureunion.append(union)
    return pureunion

Merge two lists into a single one.


def union(a, b):
    i = 0
    while i < len(a):
        if a != b:
            a.append(c)
            i = i + 1
    return c

Merge two lists into a single one.


def union(a, b):
    union = []
    i = 0
    while i < len(a) and i < len(b):
        if a[i] or b[i] not in seen:
            seen[a[i]] = True
            seen[b[i]] = True
        for number in seen:
            union.append(number)
    return union

Merge two lists into a single one.


def intersection(f1con, f2con):
    d1 = {}
    i = 0
    while i != len(f1con):
        line = f1con[i]
        d1[line] = True
        i = i + 1
    dups = []
    i = 0
    while i != len(f2con):
        line = f2con[i]
        if line in list(d1.keys()):
            dups.append(line)
        i = i + 1
    dups = sorted(list(set(dups)))
    return dups


def union(a, b):
    i = 0
    c = []
    while i < len(a):
        if a != b:
            a.append(c)
            i = i + 1
    return c

Merge two lists into a single one.


def intersection(a, b):
    seen = {}
    i = 0
    while i < len(a):
        if a[i] in b and not a[i] in seen:
            seen[a[i]] = True
        i = i + 1
    return seen


def union(a, b):
    union = []
    i = 0
    while i < len(a) and i < len(b):
        if a[i] or b[i] not in seen:
            seen[a[i]] = True
            seen[b[i]] = True
        i = i + 1
    for number in seen:
        union.append(number)
    return union

Merge two lists into a single one.


def intersection(f1con, f2con):
    d1 = {}
    i = 0
    while i != len(f1con):
        line = f1con[i]
        d1[line] = True
        i = i + 1
    dups = []
    i = 0
    while i != len(f2con):
        line = f2con[i]
        if line in list(d1.keys()):
            dups.append(line)
        i = i + 1
    dupsorg = {}
    i = 0
    while i != len(dups):
        dupsorg[dups[i]] = True
        i = i + 1
    puredups = []
    for dups in sorted(dupsorg):
        if dupsorg[dups]:
            puredups.append(dups)
    return puredups
    return puredups


def intersection(a, b):
    seen = {}
    c = []
    i = 0
    while i < len(a):
        seen[a[i]] = True
        i = i + 1
    i = 0
    while i < len(b):
        if b[i] in seen:
            c.append(b[i])
        i = i + 1
    return c


Merge two lists into a single one.


def union(a, b):
    i = 0
    c = []
    while i < len(a):
        if a != b:
            a.append(c)
            return c
            i = i + 1

Merge two lists into a single one.


def union(a, b):
    a = a + b
    seen = {}
    c = []
    i = 0
    while i < len(a):
        if a[i] not in seen:
            seen[a[i]] = True
        i = i + 1
    for number in seen:
        c.append(number)
    return c

Merge two lists into a single one.


def union(a, b):
    c = a + b
    union = []
    i = 0
    while i < len(a) and i < len(b):
        if c[i] not in seen:
            seen[c[i]] = True
        i = i + 1
    for number in seen:
        union.append(number)
    return union

Merge two lists into a single one.


def union(a, b):
    c = a + b
    union = []
    i = 0
    while i < len(c):
        if c[i] not in seen:
            seen[c[i]] = True
        i = i + 1
    for number in seen:
        union.append(number)
    return union

Merge two lists into a single one.


def intersection(a, b):
    seen = {}
    c = []
    i = 0
    while i < len(a):
        seen[a[i]] = True
        i = i + 1
    i = 0
    while i < len(b):
        if b[i] in a:
            seen[b[i]] = True
        i = i + 1
    return c


def intersection(a, b):
    seen = {}
    appended = {}
    c = []
    i = 0
    while i < len(a):
        seen[a[i]] = True
        i = i + 1
    i = 0
    while i < len(b):
        if b[i] in seen and b[i] not in appended:
            c.append(b[i])
            appended[b[i]] = True
        i = i + 1
    return c


def union(a, b):
    c = set(a + b)
    return c

Merge two lists into a single one.


def intersection(a, b):
    c = []
    for item in a:
        if item in b:
            c.append(item)
    return set(c)


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

Merge two lists into a single one.


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


def union(a, b):
    union = a + b
    seen = {}
    c = []
    i = 0
    while i < len(a):
        if a[i] not in seen:
            seen[a[i]] = True
        i = i + 1
    for number in seen:
        c.append(number)
    return c

Merge two lists into a single one.


def intersection(a, b):
    seen = {}
    append = {}
    c = []
    i = 0
    while i < len(a):
        seen[a[i]] = True
    i = i + 1
    i = 0
    while i < len(b):
        if b[i] in seen and b[i] not in append:
            c.append(b[i])
            append[b[i]] = True
        i = i + 1
    return c


def intersection(a, b):
    seen = {}
    append = {}
    c = []
    i = 0
    while i < len(a):
        seen[a[i]] = True
        i = i + 1
    i = 0
    while i < len(b):
        if b[i] in seen and b[i] not in append:
            c.append(b[i])
            append[b[i]] = True
        i = i + 1
    return c


def union(a, b):
    a = a - b
    seen = {}
    c = []
    i = 0
    while i < len(a):
        if a[i] not in seen:
            seen[a[i]] = True
        i = i + 1
    for number in seen:
        c.append(number)
    return c

Merge two lists into a single one.


def union(a, b):
    union = a + b
    seen = {}
    c = []
    i = 0
    while i < len(union):
        if a[i] not in seen:
            seen[a[i]] = True
        i = i + 1
    for number in seen:
        c.append(number)
    return c

Merge two lists into a single one.


def union(a, b):
    i = 0
    while i < len(a) and a[i] != b:
        i = i + 1
    return i < len(a)

Merge two lists into a single one.


Merge two lists into a single one.


def intersection(a, b):
    seen = {}
    appended = {}
    c = []
    i = 0
    while i < len(a):
        seen[a[i]] = True
    i = i + 1
    i = 0
    while i < len(b):
        if b[i] in seen and b[i] not in appended:
            c.append(b[i])
            appended[b[i]] = True
        i = i + 1
    return c


def intersection(a, b):
    int = {}
    i = 0
    while i < len(a):
        if a[i] in b and not a[i] in int:
            int[a[i]] = True
        i = i + 1
    print(int)


def union(a, b):
    un = {}
    i = 0
    while i < len(a):
        un[a[i]] = True
        i = i + 1
    h = 0
    while i < len(b):
        un[b[h]] = True
        h = h + 1
    print(un)

Merge two lists into a single one.


def intersection(a, b):
    int = {}
    i = 0
    while i < len(a):
        if a[i] in b and not a[i] in int:
            int[a[i]] = True
        i = i + 1
    return int


def union(a, b):
    un = {}
    i = 0
    while i < len(a):
        un[a[i]] = True
        i = i + 1
    h = 0
    while i < len(b):
        un[b[h]] = True
        h = h + 1
    return un

Merge two lists into a single one.


def union(a, b):
    un = {}
    i = 0
    while i < len(a):
        un[a[i]] = True
        i = i + 1
    h = 0
    while i < len(b):
        if not b[h] in un:
            un[b[h]] = True
        h = h + 1
    return un

Merge two lists into a single one.


def intersection(a, b):
    inter = {}
    i = 0
    while i < len(a):
        if a[i] in b and not a[i] in inter:
            inter[a[i]] = True
        i = i + 1
    return inter


def union(a, b):
    un = {}
    i = 0
    while i < len(a):
        un[a[i]] = True
        i = i + 1
    j = 0
    while i < len(b):
        if not b[j] in un:
            un[b[j]] = True
        j = j + 1
    return un

Merge two lists into a single one.


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


def circle_circumference(n):
    cc = 2 * 3.141 * n
    return cc


def circle_area(n):
    ca = 3.141 * n ** 2
    return ca


def square_perimeter(n):
    sp = n + n
    return sp


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


def square_perimeter(n):
    sp = 4 * n
    return sp


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


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


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

def sort(a):
    i = 0
    while i < len(a):
        k = find_position_of_smallest(a, i)
        swap(a, i, k)
        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 circumference(r):
    return 2 * pi * r


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

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

Reverse a list of elements by swapping its elements.


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

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


def double(n):
    m = n + n
    return m


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


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


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


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


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


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


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


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


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


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


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


def circumference(r):
    x = pi * r
    return x


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


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


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


def circumference(n):
    circumference = 2 * pi * n
    return circumference


def area(n):
    area = 2 * pi * n ** 2
    return area


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


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


def area(n):
    area = pi * n ** 2
    return area


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


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


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


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


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


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


def swap(a, i, j):
    while j < len(a) / 2:
        tmp = a[j]
        a[j] = a[i]
        a[i] = tmp
        j = j + 1
        i = i + 1
    return a

def reverse(a):
    j = 0
    i = len(a) - 1
    print(swap(a, i, j))


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


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

def reverse(a):
    j = 0
    i = len(a) - 1
    print(swap(a, i, j))


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


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


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


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

def reverse(a):
    j = 0
    i = len(a) - 1
    print(swap(a, i, j))


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


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


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


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


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


def reverse(a):
    i = 0
    while i < len(a):
        tmp = a[i]
        a[i] = a[-i]
        a[-i] = tmp
        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, a[i], a[j])
        i = i + 1
        j = j - 1
    return a


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


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

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


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


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


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

def reverse(a):
    i = 0
    while i < len(a) / 2:
        j = a[len(a) - 1 - i]
        swap(a, i, j)
        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
    while i < len(a) / 2:
        j = a[len(a) - i - 1]
        swap(a, i, j)
        i = i + 1


def reverse(a):
    i = 0
    while i < len(a) / 2:
        tmp = a[i]
        a[i] = a[len(a) - i - 1]
        a[len(a) - 1 - i] = tmp
        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 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, a[i], a[j])
        i = i + 1
        j = len(a) - i - 1
    return a


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


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


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


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


def circumference(r):
    return 2 * 3.14 * 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) / 2:
        swap(a, i, len(a) - i - 1)
        i = i + 1
    return a


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


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 = a[len(a) - i - 1]
        swap(a, i, j)
        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 reverse(a):
    i = 0
    while i < len(a) / 2:
        swap(a, i, len(a) - i - 1)
        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
    while i < len(a) / 2:
        j = len(a) - i - 1
        swap(a, i, j)
        i = i + 1
    return a


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


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 area(r):
    return pi * r * (pi * r)


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 += 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 += 1
        temp = a[p]
        a[p] = a[i]
        a[i] = temp
        i += 1


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


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


def reverse(a):
    i = 0
    while i < len(a):
        tmp = a[i]
        a[i] = a[len(a) - 1 - i]
        a[len(a) - 1 - i] = tmp
        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:
        func_reverse.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
    i = 0
    while i < len(a):
        print(a[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
    i = 0
    while i < len(a):
        print(a[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
        i = 0
        while i < len(a):
            print(a[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
        i = 0
        while i < len(a):
            print(a)
            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
        i = 0
        while i < len(a):
            i += 1
    return a


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


def reverse(a):
    i = 0
    j = len(a)
    while i < len(a) / 2:
        tmp = a[j]
        a[j] = a[i]
        a[i] = tmp
        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):
    i = len(a) - 1
    j = j + 1
    while i != 0 and j < len(a):
        swap(a, i, j)
        i = i - 1
        j = j + 1
    return a


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


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


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


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


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

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


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


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


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

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


def reverse(a):
    i = 0
    j = len(a)
    while i < len(a):
        tmp = a[j - i]
        a[j - i] = a[i]
        a[i] = tmp
        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
    return a

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


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


def reverse(a):
    i = 0
    while i < len(a):
        tmp = a[len(a) - i]
        a[len(a) - i] = a[i]
        a[i] = tmp
        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 = j - 1


def reverse(a):
    i = 0
    j = len(a)
    if len(a) == 1:
        return a
    else:
        while i < len(a):
            tmp = a[j - i - 1]
            a[j - i - 1] = a[i]
            a[i] = tmp
            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 = 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 = j - 1


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = j + 1
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j += 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        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[smal]:
                small = j
            j += 1
        tmp = a[small]
        a[small] = a[i]
        a[i] = tmp
        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):
    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[p]
        a[p] = a[i]
        a[i] = tmp
        i += 1


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

def reverse(a):
    i = len(a) - 1
    j = 0
    while i != 0 and j < len(a) and j != i:
        swap(a, i, j)
        i = i - 1
        j = j + 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 += 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        i += 1


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

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


def circumference(r):
    return r * 3.141


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


def find_smallest_position(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[i] < 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, j)
        i = i + 1


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


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


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


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
    return a


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

def reverse(a):
    i = len(a) - 1
    j = 0
    while i >= 0 and j < len(a) and j != i:
        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
    return a

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


def reverse(a):
    i = len(a) - 1
    j = 0
    while i > 0 and j < len(a) and j != i:
        tmp = a[i]
        a[i] = a[j]
        a[j] = tmp
        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, j)
        i = i + 1


def area(r):
    return float(3.141) * r ** 2


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


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(i, len(a) - i - 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:
        swap(a, i, len(a) - i - 1)
        i = i + 1


def area(r):
    return float(3.141 * r ** 2)


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


def find_smallest_position(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[i] < 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, len(a) - i - 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:
        swap(a, i, len(a) - i - 1)
    i = i + 1


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


def circumference(r):
    return float(2 * r * p)


def area(r):
    return float(p * r ** 2)


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

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


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


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


def find_smallest_position(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[i] < 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 find_smallest_position(a, i):
    p = i
    j = i + 1
    while j < len(a):
        if a[i] < a[p]:
            p = j
        j = j + 1
    return p

def swap(a, i, j):
    tmp = a[p]
    a[p] = a[i]
    a[p] = 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 2 * pi * r


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

def swap(a, i, j):
    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 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 double(n):
    y = n * 2
    return y


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

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


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


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 area(r):
    return float(3.141 * r ** 2)


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


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


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


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

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


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


def area(r):
    r = c / 2 * 3.141
    return r


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


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


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


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


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


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, j, i):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp
    return a

def reverse(a):
    i = len(a) - 1
    j = 0
    while i != 0 and j < len(a) and j != i:
        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 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 = smallest_position(a, i)
        swap(a, i, p)
        i = i + 1


def selection_sort(a):
    while i < len(a):
        j = i + 1
        i = 0
        p = i
        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):
        j = i + 1
        p = i
        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 swap(a, j, i):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp
    return a

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


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


def swap(a, i, p):
    tmp = a[i]
    a[i] = a[p]
    a[p] = 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
    return a


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


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


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


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


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


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
    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
    return a


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


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


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


def circumference(r):
    return int((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 += 1
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        i += 1
    return a


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


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


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


def reverse(a, i):
    tmp = a[len(a) - i - 1]
    a[len(a) - i - 1] = a[i]
    a[i] = tmp


def swap(a, i, p):
    tmp = a[i]
    a[i] = a[p]
    a[p] = 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
    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
        tmp = a[p]
        a[p] = a[i]
        a[i] = tmp
        i += 1
    return a


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


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


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


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


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


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


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
    p = 1
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1


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
    return a


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


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


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


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


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


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

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


def selection_sort(a):
    i = 0
    while i < len(a):
        j = i
        smallest = j
        while j < len(a):
            if a[j] < a[smallest]:
                smallest = j
            j = j + 1
        a[i], a[smallest] = a[smallest], 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 = i
                tmp = a[p]
                a[p] = a[j]
                a[j] = tmp
            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 = 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 = i
                tmp = a[p]
                a[p] = a[j]
                a[j] = tmp
            j += 1
        i += 1


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


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


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


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


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


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


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


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


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


def area(r):
    return float(3.141 * r ** 2)


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


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


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


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


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


def reverse(a):
    i = 0
    j = len(a) - 1
    while j < len(a) and len(a) > 1:
        tmp = a[j]
        a[j] = a[i]
        a[i] = tmp
        i = i + 1
        j = j - 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
        return a


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


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

def reverse(a):
    j = 0
    i = len(a) - 1
    print(swap(a, i, j))


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


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


def swap(a, i, j):
    while j < len(a) / 2:
        tmp = a[j]
        a[j] = a[i]
        a[i] = tmp
        j = j + 1
        i = i + 1
    return a

def reverse(a):
    j = 0
    i = len(a) - 1
    print(swap(a, i, j))


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


def reverse(a):
    j = 0
    i = len(a) - 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 double(n):
    m = n * 2
    return m


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


def reverse(a):
    tmp = a[len(a) - i - 1]
    a[len(a) - i - 1] = a[i]
    a[i] = tmp
    i = i + 1


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


def circumference(x):
    x = 2 * x * 3.141
    return x


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


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


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


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


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


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

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


def circumference(r):
    return 6.282 * r


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


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


def reverse(a):
    tmp = a[len(a) - 1]
    a[len(a) - 1] = a[i]
    a[i] = tmp
    i = i + 1


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


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


def reverse(a):
    j = 0
    i = len(a) - 1


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


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


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


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


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


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


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


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


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


def reverse(a):
    j = 0
    i = len(a) - 1
    return j


def circumference(x):
    x = 2 * x * 3.141
    return x


def reverse(a):
    j = 0
    i = len(a) - 1
    return j, i


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


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


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


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


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


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


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
    while i < len(a):
        swap(a, i, j)
        i = i + 1


def area(x):
    x = 3.141 * x ** 2
    return x


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


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

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

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


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


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

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

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


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


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


def reverse(a):
    j = 0
    i = len(a) - 1
    return a


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


def swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[i] = 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 area(x):
    x = pi * x ** 2
    return x


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


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 swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = tmp

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


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


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


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

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


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


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


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


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

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


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


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


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


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


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


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


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


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


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


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


def area(r):
    x = pi + r ** 2
    return x


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


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


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


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


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


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


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 double(x):
    y = x * 2
    return y


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


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


def area(n):
    m = 3.14 * 3 ** 2
    return m


def circumference(n):
    m = 2 * 3.14 * n
    return m


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

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


def area(r):
    y = pi + r ** 2
    return y


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


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


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


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


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
    return 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)
    while i < len(a):
        swap(a, i, j)
        i = i + 1
        j = j - 1


def area(n):
    m = 3.14 * n ** 2
    return m


def reverse(a):
    i = 0
    while i < len(a):
        return a[len(a) - i - 1]
        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 j > len(a) / 2:
        tmp = a[i]
        a[i] = a[j]
        a[j] = tmp
        i += 1
        j = j - 1


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


def circumference(n):
    m = 3.141 * n * 2
    return circumference


def area(n):
    x = 3.141 * n ** 2
    return area


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


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


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


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
    j = len(a) + 1
    while i < len(a):
        swap(a, i, j)
        i = i + 1
        j = j - 1


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 swap(a, i, j):
    tmp = a[i]
    a[i] = a[j]
    a[j] = 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 double(n):
    m = 2 * n
    return m


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


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


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


def area(t):
    x = 3.141 * t ** 2
    return area


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


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 double(x):
    y = 2 * x
    return y


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:
        tmp = a[i]
        a[i] = a[j]
        a[j] = tmp
        i += 1
        j = j - 1


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


def area(n):
    m = 3.141 * n ** 2
    return m


def circumference(n):
    m = 2 * 3.141 * n
    return m


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


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


def circumference(r):
    return r * pi * 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[p]
        a[p] = a[i]
        a[i] = tmp
        i = i + 1
    return a


def reverse(a):
    i = 0
    while i < len(a):
        a[len(a) - i - 1]
        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
    while i < len(a) / 2:
        j = len(a) - i - 1
        swap(a, i, j)
        i = i + 1
    return a


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


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


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 j > len(a) / 2:
        swap(a, i, j)
        i += 1
        j = j - 1


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


def area(n):
    m = pi * n ** 2
    return m


def circumference(n):
    m = 2 * pi * n
    return m


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 = j - 1


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


def circumference(n):
    m = 3.141 * n * 2
    return m


def area(n):
    x = 3.141 * n ** 2
    return x


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):
    i = 0
    while i < len(a):
        tmp = a[i]
        a[i] = a[len(a) - i - 1]
        a[len(a) - i - 1] = tmp
        i = i + 1


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


def area(t):
    x = 3.141 * t ** 2
    return x


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 = a[len(a) - i - 1]
        swap(a, i, j)
        i = i + 1


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


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


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


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


def reverse(a):
    i = 0
    j = len(a) - 1


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


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


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


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


def circumference():
    pi = 3.14
    cir = 2 * pi * r
    return cir


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

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


def area(t):
    x = pi * t ** 2
    return x


def circumference(n):
    m = pi * n * 2
    return m


def selection_sort(a):
    i = 0
    while i < len(a):
        j = i + 1
        p = i
        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 2 * 3.141 * r


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


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


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


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


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


def area(r):
    a = r ** 2 * pi
    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
    return a


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


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 = i
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = 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)
        i = i + 1
        j = j - 1


def selection_sort(a):
    p = 0
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if int(a[j]) < int(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 2 * pi * r


def reverse(a):
    i = 0
    j = len(a) - 1
    while i < len(a) / 2:
        tmp = a[i]
        a[i] = a[j]
        a[j] = tmp
        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
    j = len(a) - 1
    while i < len(a) / 2:
        swap(a, i, j)
        i = i + 1
        j = j - 1
    return a


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


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


def circumference(cir):
    r = input()
    cir = 2 * pi * r
    return cir


def reverse(a):
    m = len(a) - i - 1
    return m


def circumference(cir):
    r = 0
    cir = 2 * pi * r
    return cir


def reverse(a):
    m = len(a) - i - 1
    return m
    i = i + 1


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


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


def area(a):
    l = 0
    w = 0
    a = l * w
    return a


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


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


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


def selection_sort(a):
    i = 0
    while i < len(a):
        p = i
        j = i + 1
        while j < len(a):
            if int(a[j]) < int(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):
    p = 0
    j = i + 1
    while j < len(a):
        if a[j] < a[p]:
            p = j
        j = j + 1
    return a


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


def area(l, w):
    a = l * w
    return a


def selection_sort(a):
    p = 0
    j = p + 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 selection_sort(a):
    i = 0
    j = len(a) - 1
    while i < len(a):
        swap(a, i, j)
        i = i + 1
        j = j + 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 = 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 += 1
    return a


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


def reverse(a):
    while i < len(a):
        return 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 = i + 1
        j = j - 1


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


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


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 area(r):
    a = 3.141 * pi ** 2
    return a


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


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


def circumference(r):
    r = 0
    r = 2 * pi * r
    return cir


def area(r):
    l = 0
    w = 0
    r = l * w
    return r


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


def area(r):
    m = 3.141 * r * r
    return m


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


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


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


def circumference(r):
    r = 0
    r = 2 * pi * r
    return 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 circumference(r):
    return 2 * pi * r


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


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
        i = i + 1
    return a


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


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


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 += 1
    return a


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


def reverse(a):
    i = 0
    m = len(a) - i - 1
    i = i + 1
    return m


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


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


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

def reverse(a):
    swap(a, i, j)
    a[len(a) - i - 1]


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


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


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


def selection_sort(a):
    c = 0
    while c < len(a):
        i = c
        p = c
        while i < len(a):
            if a[p] > a[i]:
                p = i
            z = a[p]
            a[p] = a[c]
            a[c] = z
            i += 1
        c += 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 circumference(r):
    c = 2 * p * r
    return c


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


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


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:
        tmp = a[i]
        a[i] = a[len(a) - i - 1]
        a[len(a) - i - 1] = tmp
        i = i + 1
    return a


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


def area(x):
    ar = p * (x * x)
    return ar


def circumference(x):
    cir = 2 * p * x
    return x


def selection_sort(a):
    i = 0
    while i < len(a):
        p = a[i]
        j = i
        while j < len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        tmp = a[i]
        a[i] = a[p]
        a[p] = a[i]
        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
    j = len(a) - i - 1
    while i < len(a) / 2:
        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[i]
        a[i] = a[p]
        a[p] = tmp
        i = i + 1
    return a


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


def selection_sort(a):
    i = 0
    while i < len(a):
        p = a[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] = a[i]
        i = i + 1
    return a


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


def selection_sort(a):
    i = 0
    while i < len(a):
        p = a[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 circumference(r):
    return 2 * pi * r


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


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


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 circumference(n):
    return 2 * pi * n


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


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


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

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


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

def reverse(a):
    i = 0
    n = len(a) - i - 1
    while n < len(a) - 1:
        if a[j] < a[n]:
            swap(a, i, j)
        n = n + 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):
        p = i
        j = i + 1
        while j > len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
    swap(a, i, j)
    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
    return p


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

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


def reverse(a):
    t = ''
    while j < len(a):
        t = a[j] + t
        j = j + 1
        return t


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

def reverse(a):
    i = 0
    while i < len(a):
        swap(a, a[i], a[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):
        p = i
        j = i + 1
        while j > len(a):
            if a[j] < a[p]:
                p = j
            j = j + 1
        swap(a, i, j)
        i += 1


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

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


def reverse(a):
    t = ''
    while j < len(i):
        t = a[j] + t
        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[i] = a[j]
    a[j] = tmp

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 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[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 = i + 1
        j + j - 1
    return a


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


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(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 = 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):
    swap(a, i, j)
    i = 0
    while i < len(a):
        x = a[len(a) - i - 1]


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


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


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

def reverse(a):
    swap(a, i, j)


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 swap(a, i, j):
    tmp = a[j]
    a[j] = a[i]
    a[i] = tmp

def reverse(a):
    i = 0
    n = len(a) - 1
    while n < len(a) / 2:
        swap(a, i, j)
        i = i + 1
        n = n - 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, j, len(a) - 1 - i)
        i = i + 1


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

def reverse(a):
    swap(a, i, j)


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 j < 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
    return p

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 = smallest(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):
    i = 1
    while i < len(a):
        j = i + 1
        swap(a, i, j)
        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) - 1 - 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)


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 = i + 1
        j = j - 1


def reverse(a):
    m = len(a) - i - 1
    return m


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, i1, len(a) - 1 - i)
        i = i + 1


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


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 = 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
    j = a[len(a - i - 1)]
    swap(a, 0, j)
    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


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

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


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


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


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

def reverse(a):
    i = 0
    while i < len(a) - 1:
        j = i + 1
        swap(a, i, j)
        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 = int(a[len(a - i - 1)])
    swap(a, 0, j)
    i = i + 1


def selection_sort(a):
    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] = a[j]

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


def area(r):
    a = pi * r ** 2
    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 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 reverse(a):
    x = len(a) - i - 1
    return x


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, a[i], a[len(a) - 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 = int(a[len(a) - i - 1])
    swap(a, 0, j)
    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 - i)
        i = i + 1


def reverse(a):
    t = ''
    while j < len(i):
        t = a[j] + t
        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 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 = 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:
        j = len(a) - i - 1
        swap(a, i, j)
        i = i + 1


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

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 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(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 reverse(a):
    t = ''
    while j < len(i):
        t = a[j] + t
        j = j + 1
        return t


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

def reverse(a):
    i = 0
    while i < len(a):
        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
    while i < len(a):
        swap(a, i, len(a) - i - 1)


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


def swap(a, x, y):
    tmp = a[x]
    a[x] = a[y]
    a[y] = tmp
    return a

def reverse(a):
    i = 0
    j = len(a) - 1
    while i < len(a) / 2:
        swap(a, i, j)
        i += 1
        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 = int(a[len(a) - i - 1])
    swap(a, i, j)
    i = i + 1


def reverse(a):
    tmp = a[i]
    a[i] = [len(a) - i - 1]
    a[len(a) - i - 1] = tmp
    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) - 1 - i)
        tmp = a[len(a) - 1 - i]
        a[len(a) - 1 - i] = a[i]
        a[i] = tmp
        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):
        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) - 1 - i)
        i += 1


def area(r):
    a = pi * r ** 2
    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, p):
    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):
            p = j
        j = j + 1
    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
    while i < len(a) / 2:
        j = int(a[len(a) - i - 1])
        swap(a, i, j)
    i = i + 1


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


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

def reverse(a):
    i = 0
    while i < len(a) / 2:
        j = len(a) - 1 - 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
    while i < len(a) - 1:
        j = i + 1
        p = 0
        while p < len(a[i:]):
            swap(a, i, j)
            p += 1
        i += 1
    return a


def selection_sort(a):
    s = input()
    a = []
    while s != 'end':
        a.append(int(s))
        s = input()
    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
    i = 0
    while i < len(a):
        print(a[i])
        i = i + 1


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


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 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[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 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 = int(a[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]:
                tmp = a[p]
                a[p] = a[j]
                a[j] = tmp
            j = j + 1
        i = i + 1


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


def selection_sort(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):
    b = a
    tmp = b[j]
    b[j] = b[i]
    b[i] = tmp

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


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:
        j = len(a) - i - 1
        swap(a, i, j)
        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):
        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
    while i < len(a) / 2:
        j = a[len(a) - i - 1]
        swap(a, i, j)
        i = i + 1


def reverse(a):
    i = 0
    while i < len(a):
        tmp = a[i]
        a[i] = [len(a) - i - 1]
        a[len(a) - i - 1] = 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:
        j = len(a) - 1 - i
        swap(a, i, j)
        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):
            p = j
        j = j + 1
    swap(a, i, j)
    i = i + 1


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


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


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

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


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


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


def reverse(a):
    i = 0
    while i < len(a):
        func_reverse.reverse(a)
        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
    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

def reverse(a, i, j):
    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 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