code
"import math

def main(x, y, z):
    n = len(x)
    res = 0
    for i in range(1, n + 1):
        temp = 0
        temp += y[int(n - math.ceil(float(i) / 2))]
        temp += z[i - 1] ** 3
        temp += 13 * x[int(n - math.ceil(float(i) / 2))] ** 2
        temp = math.exp(temp) ** 5
        temp *= 12
        res += temp
    return res * 84"
"from math import ceil

def main(x, y):
    result = 0
    for i in range(1, len(x) + 1):
        result += 21 * (3 * x[i - 1] ** 3 - 82 * y[len(x) - ceil(i / 2)] ** 2 - 1) ** 6
    return result"
"from math import pow, cos, ceil

def f(y, z):
    sum = 0.0
    n = len(y) + 1
    for i in range(1, n):
        c = ceil(i / 4)
        sum += 39 * pow(cos(pow(z[c - 1], 3) / 18 + 7 + 10 * y[n - c - 1]), 7)
    return sum * 92

def main(y, z):
    return f(y, z)"
"def main(n):
    from math import tan
    from math import ceil
    res = 0
    for i in range(1, len(n) + 1):
        res += 44 * tan(n[int(len(n) - ceil(i / 3))]) ** 6
    return res"
"def main(z, y):
    summa = 0
    for i in range(0, 7):
        summa += (y[i // 2] ** 3 - y[i // 2] ** 2 - 60 * z[6 - i // 2]) / 8
    return summa * 28"
"from math import ceil

def f(y: list) -> float:
    n = len(y)
    result = 0.0
    for i in range(1, n + 1):
        result += 17 * (9 * y[n + 1 - ceil(i / 4) - 1] - 74 * y[n + 1 - ceil(i / 4) - 1] ** 2 - 1) ** 2
    return result

def main(y):
    return f(y)"
"def main(x: list) -> float:
    result = 0
    n = len(x)
    for i in range(0, n):
        result += (x[n - 1 - int(i / 4)] ** 3 - x[i] ** 2) ** 6
    return 12 * result"
"def main(y, z, x):
    n = len(y)
    result = 0
    for i in range(1, n + 1):
        result += 51 * 71 * (42 * z[n - i] ** 3 + x[n - i] + y[i - 1] ** 2) ** 3
    return result"
"import math as Math

def main(z, y, x):
    result = 0
    for i in range(0, len(y)):
        result += (x[Math.ceil(i // 2)] ** 3 + 65 * z[i] ** 2 + y[i]) ** 3
    return result"
"def main(z, y):
    res = 0
    for i in range(1, len(z) + 1):
        res += (y[i - 1] ** 3 + 77 * z[i - 1] + 1) ** 5
    return 63 * res"
"import math as m

def main(y, x):
    n = len(y)
    res = 0
    for i in range(1, n + 1):
        y_ind = m.ceil(i / 3) - 1
        res += m.sqrt(y[y_ind] + 87 * x[n - i] ** 3 + 62) ** 5
    return res"
"import math

def main(x, z, y):
    sum = 0
    for i in range(1, len(x) + 1):
        sum += (y[len(x) - math.ceil(i / 2)] ** 2 - 32 * x[math.ceil(i / 4) - 1] - 38 * z[len(x) - math.ceil(i / 3)] ** 3) ** 7
    return 82 * sum"
"import math as m

def main(x, z, y):
    n = len(x)
    res = 0
    for i in range(1, n + 1):
        res += x[m.ceil(i / 4) - 1] + 72 * y[n - m.ceil(i / 2)] ** 2 + 34 * z[n - i] ** 3
    return res"
"def main(x, y, z):

    def f(x_i, y_i, z_i):
        return (x_i ** 3 - 8 * z_i - y_i ** 2) ** 6
    res = 0
    for i in range(len(x)):
        res += f(x[i], y[i // 4], z[i])
    return res"
"from math import atan, ceil

def main(z, x, y):
    f = 0
    n = len(z)
    for i in range(1, n + 1):
        f += atan(x[i - 1] ** 3 + y[ceil(i / 4) - 1] + z[n + 1 - ceil(i / 2) - 1] ** 2) ** 2
    return 81 * f"
"def main(x):
    res = 0
    for a in x:
        res += a ** 3 / 68 + a ** 2
    res *= 61 * 44
    return res"
"import math

def main(x, z, y):
    n = len(x)
    f = 0
    for i in range(1, n + 1):
        f += 65 * (85 * x[n + 1 - i - 1] ** 3 - z[i - 1] - y[n + 1 - math.ceil(i / 4) - 1] ** 2) ** 2
    return f"
"from math import ceil

def main(x):
    result = 0
    n = len(x)
    for i in range(1, n + 1):
        index = n - ceil(i / 3)
        result += x[index] ** 5 / 50
    return result"
"from math import atan, ceil

def main(y, z, x):
    number = 0
    n = len(y)
    for i in range(1, n + 1):
        number += 3 * atan(z[n - ceil(i / 2)] ** 3 - 20 * y[n - ceil(i / 4)] ** 2 - 63 * x[n - i]) ** 2
    return 70 * number"
"from math import floor

def main(y, z, x):
    numb = 0
    n = len(x)
    for i in range(1, n + 1):
        numb += floor(66 * x[n - i] ** 2 - y[n - i] ** 3 - 14 * z[i - 1]) ** 7
    return numb"
"from math import ceil, sqrt

def main(x):
    sum = 0
    n = len(x)
    for i in range(1, n + 1):
        rez1 = x[ceil(i / 4) - 1]
        rez2 = x[n - ceil(i / 4)]
        sum += 66 * (5 * rez1 ** 3 + rez2 ** 2 / 28) ** 2
    return 14 * sum"
"from math import ceil, log, e

def f(z: list, y: list, x: list) -> float:
    assert len(x) == len(y) == len(z)
    n = len(x)
    result = 0.0
    for i in range(1, n + 1):
        result += log(97 * y[n + 1 - ceil(i / 2) - 1] ** 2 + x[i - 1] ** 3 / 11 + z[n + 1 - i - 1]) ** 5
    return result

def main(z, y, x):
    return f(z, y, x)"
"from math import atan, ceil

def main(x, z):
    n = len(x)
    res = 0
    for i in range(1, n + 1):
        res += 30 * atan(84 * x[n - ceil(i / 4)] ** 3 - z[n - i] - 19) ** 7
    return 89 * res"
"import math

def main(y):
    sum = 0
    n = len(y)
    for i in range(n):
        sum = sum + 77 * (y[i] ** 3 - 95 * y[n - 1 - i] ** 2) ** 4
    return 56 * sum"
"import math

def main(z):
    sum = 0
    n = len(z)
    for i in range(n):
        x = n - 1 - i
        sum = sum + 64 * (z[x] ** 2 + z[x] ** 3 + z[x])
    return 10 * sum"
"from math import ceil

def f(z: list, x: list, y: list) -> float:
    n = len(z)
    r = 0
    for i in range(1, n + 1):
        r += (x[ceil(i / 2) - 1] ** 3 / 40 + y[i - 1] + 11 * z[n + 1 - i - 1] ** 2) ** 3
    return r

def main(z, y, x):
    return f(z, y, x)"
"from math import ceil

def main(x):
    n = len(x)
    res = 0
    for i in range(1, n + 1):
        res += (2 * x[ceil(i / 4) - 1] + 0.02 + x[ceil(i / 4) - 1] ** 3) ** 7
    return 19 * res"
"import math

def main(n):
    r = 0
    for i in range(1, len(n) + 1):
        r += math.floor(n[len(n) - i] - 87 * pow(n[len(n) - i], 3))
    return r"
"from math import *

def main(y):
    rez = 0
    for i in range(1, len(y) + 1):
        rez += pow(38 - 82 * pow(y[ceil(i / 3) - 1], 3) - pow(y[i - 1], 2), 3) / 29
    return rez.real"
"from math import *

def main(y):
    f = 0
    for i in range(1, len(y) + 1):
        y1 = y[ceil(i / 2) - 1] ** 2
        f += 17 * (2 * y1 - 84 * y[i - 1] - y[i - 1] ** 3) ** 4
    return f"
"from math import *

def main(z, x, y):
    f = 0
    for i in range(1, len(x) + 1):
        z1 = ceil(i / 2) - 1
        z2 = ceil(i / 3) - 1
        f += (z[z1] ** 3 - 83 * y[z2] ** 2 - 81 * x[z2]) ** 5
    return f"
"from math import *

def main(y, z):
    res = 0
    for i in range(0, len(y)):
        index = len(y) - ceil((i + 1) / 4)
        res += (80 - 54 * y[int(index)] - 60 * z[i] ** 3) ** 5 / 62
    return res"
"from math import *

def main(y, z):
    f = 0
    for i in range(1, len(z) + 1):
        z1 = ceil(i / 2) - 1
        z2 = ceil(i / 3) - 1
        f += 14 * (1 + 39 * z[z1] ** 2 + y[len(z) - 1 - z2] ** 3) ** 6
    return 25 * f"
"from math import *

def main(y, z):
    f = 0
    for i in range(1, len(z) + 1):
        z1 = ceil(i / 2) - 1
        z2 = ceil(i / 3) - 1
        f += 14 * (1 + 39 * z[z1] ** 2 + y[len(z) - 1 - z2] ** 3) ** 6
    return 25 * f"
"from math import *

def main(y, z):
    f = 0
    for i in range(1, len(z) + 1):
        z1 = ceil(i / 2) - 1
        z2 = ceil(i / 3) - 1
        f += 14 * (1 + 39 * z[z1] ** 2 + y[len(z) - 1 - z2] ** 3) ** 6
    return 25 * f"
"import math

def main(y, z, x):
    res = 0
    n = len(x) - 1
    for i in range(1, n + 2):
        res += 61 * math.sqrt(x[n + 1 - i] + z[n + 1 - i] ** 3 / 70 + 50 * y[n + 1 - math.ceil(i / 3)] ** 2) ** 7
    return 80 * res"
"from math import ceil

def main(x):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res += (22 * x[ceil(i / 4) - 1] ** 2 + 17 + x[i - 1] ** 3) ** 3 / 59
    return res"
"def main(x):
    f = 0
    for i in range(len(x)):
        f += (x[i // 2] ** 2 - x[i] ** 3) ** 2
    return 60 * f"
"from math import acos

def main(z, y):
    res = 0
    for i in range(1, len(z) + 1):
        res += acos(y[i - 1] ** 3 + 1 + z[i - 1]) ** 6
    return 82 * res"
"from math import ceil

def main(z, x, y):
    res = 0
    for i in range(1, len(z) + 1):
        ceil_res = ceil(i / 3)
        z_sum = z[ceil_res - 1] ** 2
        y_sum = 70 * y[ceil_res - 1] ** 3
        x_sum = 12 * x[ceil_res - 1]
        res += (z_sum - y_sum - x_sum) ** 3
    return res"
"from math import exp, ceil

def main(x):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res1 = 1 + x[ceil(i / 4) - 1]
        res2 = 94 * x[n + 1 - ceil(i / 3) - 1] ** 3
        res += exp(res1 + res2) ** 2
    return res"
"def main(x):
    f = 0
    for i in range(len(x)):
        f += 32 * (61 * x[-1 - i // 4] ** 3 - x[i // 3]) ** 6
    return f"
"def main(z):
    f = 0
    for i in range(len(z)):
        f += (z[i] ** 2 - 15 * z[-1 - i] - 57 * z[-1 - i] ** 3) ** 4
    return 69 * f"
"from math import ceil

def main(y: list, x: list, z: list):
    sum = 0
    for i in range(0, len(x)):
        sum += (y[i] ** 2 + 12 * z[i] + x[ceil((i + 1) / 4) - 1] ** 3 / 37) ** 4
    return 4 * sum"
"def main(y, z, x):
    res = 0
    for i in range(1, len(y) + 1):
        num_1 = z[len(z) - i] + 35 * x[len(x) - i] ** 2
        num_2 = y[len(y) - i] ** 3
        res += 96 * (num_1 + num_2) ** 6 / 30
    return res"
"import math

def main(z, x):
    ans = 0
    n = len(z)
    for i in range(1, len(z) + 1):
        ans += 25 * (x[n - math.ceil(i / 4)] ** 3 / 87 - z[i - 1] - 1) ** 3
    return ans"
"import math

def main(x):
    f = 0
    for i in range(len(x)):
        f += math.cos(x[-1 - i // 2]) ** 2
    return 32 * f"
"import math

def main(z):
    summ = 0
    n = len(z)
    for i in range(1, n + 1):
        s1 = 1 - z[int(n + 1 - math.ceil(i / 3)) - 1] ** 3 - 46 * z[int(math.ceil(i / 2)) - 1] ** 2
        s1 = 25 * s1 ** 7
        summ += s1
    return 82 * summ"
"from math import tan

def main(y: list, x: list):
    res_total = 0
    for i in range(0, len(x)):
        res_total += tan(y[i] - x[i] ** 3 / 55) ** 3
    res_total *= 71
    return res_total"
"from math import atan, sin, log10, log2, floor

def cal(x, y):
    res = 0
    n = len(x)
    for i in range(1, len(x) + 1):
        res = res + 38 * (54 * y[i - 1] - 24 * x[n - i] ** 2 - 1) ** 7
    return 87 * res

def main(x, y):
    return cal(x, y)"
"from math import ceil

def main(z, y, x):
    res = 0
    n = len(z)
    for i in range(0, n):
        res += 66 * (z[i] ** 2 - 54 * x[n + 1 - ceil((i + 1) / 2) - 1] ** 3 - 34 * y[ceil((i + 1) / 2) - 1]) ** 5
    return res"
"import math

def main(x, y) -> float:
    sum1 = 0
    for i in range(1, len(y) + 1):
        a = y[math.ceil(i / 2) - 1] ** 2 / 86
        b = x[math.ceil(i / 2) - 1]
        sum1 += 16 * math.tan(a + b + 17) ** 4
    return 14 * sum1"
"def main(z):
    res = 0
    for i in range(1, len(z) + 1):
        res += (81 * z[i - 1] + z[len(z) - i] ** 2) ** 4 / 41
    return res"
"def main(z):
    rez_1 = 0
    for i in range(1, len(z) + 1):
        rez_1 += (63 * z[len(z) - i] ** 3 - 0.01) ** 5 / 2
    return rez_1"
"def main(y, z):
    sum = 0
    n = len(y)
    for i in range(1, n + 1):
        res = 21 * (y[i - 1] ** 3 - 85 * z[n + 1 - i - 1] - y[i - 1] ** 2) ** 7
        sum = sum + res
    return 42 * sum"
"import math

def main(z, y):
    row = 0.0
    n = min(len(z), len(y))
    for i in range(n):
        row += (15 * z[n - 1 - i] ** 3 + 82 * z[n - 1 - i] + 52 * y[n - 1 - i] ** 2) / 11
    return 64 * row"
"from math import ceil

def main(x, y, z):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res1 = z[n - i] ** 3
        res2 = 15 * y[n + 1 - ceil(i / 3) - 1] ** 2
        res3 = 98 * x[ceil(i / 4) - 1]
        res += (res1 + res2 + res3) / 53
    return 16 * res"
"from math import ceil

def main(x):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res1 = x[ceil(i / 3) - 1] ** 2 / 23
        res2 = 29 * x[ceil(i / 3) - 1]
        res += 35 * (res1 + res2) ** 4
    return 79 * res"
"import math

def main(y, x):
    n = len(y)
    f = 0
    for i in range(1, n + 1):
        f += 5 * math.asin(y[n - math.ceil(i / 4)] + 1 + x[math.ceil(i / 3) - 1] ** 3)
    return f"
"def main(z, x):
    res = 0
    for i in range(len(z)):
        res += 0.25 + z[i] ** 3 / 42 + x[i // 3] / 64
    return res * 19"
"from math import ceil

def main(z):
    n = len(z)
    sum_i = 0
    for i in range(1, n + 1):
        sum_i += z[n - ceil(i / 2)] ** 4 / 67
    return sum_i"
"from math import ceil

def main(z):
    k = 0
    for i in range(1, len(z) + 1):
        k += z[len(z) - ceil(i / 2)] ** 4 / 91
    return k"
"import math

def main(z):
    s = 0
    for i in range(len(z)):
        s += (z[math.floor(i / 3)] ** 3 + z[i]) ** 7
    return s"
"def main(x, z):
    n = len(x)
    sum = 0
    for i in range(0, n):
        sum += (23 * x[i] - 1 - z[i] ** 3) ** 2
    sum = sum * 27
    return sum"
"import math

def main(x, y):
    summa = 0
    for i in range(1, len(x) + 1):
        a = x[math.ceil(i / 3) - 1] ** 2
        b = y[math.ceil(i - 1)]
        summa += (a + b) ** 7
    return 9 * summa"
"from math import ceil

def main(y, z):
    res = 0
    for i in range(1, len(y) + 1):
        z1 = 77 * z[len(y) - ceil(i / 3)] + 96
        y1 = 42 * y[len(y) - ceil(i / 2)] ** 3
        f = z1 + y1
        res += f ** 6 / 29
    return 87 * res"
"from math import asin

def main(y):
    n = len(y)
    res = 0
    for i in range(1, n + 1):
        res += asin(y[n - i] ** 3 - 1 - y[n - i] ** 2 / 20) ** 7 / 76
    res *= 88
    return res"
"from math import exp

def main(y):
    res = 0
    n = len(y)
    for i in range(0, n):
        res1 = exp(y[n - 1 - i] ** 3 + 58 * y[n - 1 - i] + 17 * y[n - 1 - i] ** 2) ** 4
        res = res + res1
    return res"
"from math import ceil

def main(z):
    sum = 0
    m = len(z)
    for i in range(0, m):
        sum = sum + (97 * z[m - ceil((i + 1) / 3)] ** 2) ** 3
    return 62 * 89 * sum"
"from math import *

def main(x, z):
    result_sum = 0
    n = len(x)
    for i in range(1, n + 1):
        result_sum += 34 * pow(pow(z[n - ceil(i / 2)], 2) - x[n - ceil(i / 2)] / 18, 4)
    result_sum *= 38
    return result_sum"
"def main(x):
    sum1 = 0
    n = len(x)
    for i in range(1, n + 1):
        sum1 += 43 * (x[n - i] ** 3 - x[(i - 1) // 3]) ** 3
    return 87 * sum1"
"import math

def main(y):
    sum = 0
    y.insert(0, 0)
    for i in range(1, len(y)):
        ceil_value = y[math.ceil(i / 3)]
        under_log = y[i] ** 3 + ceil_value
        log_result = math.log10(under_log) ** 7
        sum += log_result
    return 51 * sum"
"import math

def main(x, z, y):
    n = len(x)
    res = 0
    for i in range(0, n):
        res += pow(88 * x[i] * x[i] - y[math.ceil(i / 2)] / 98 - pow(z[n - 1 - i], 3), 7)
    return res"
"from math import *

def main(z, y, x):
    n = len(z)
    sum = 0
    for i in range(1, n + 1):
        sum += (z[i - 1] ** 2 + x[n - ceil(i / 2)] + y[n - ceil(i / 3)] ** 3 / 77) ** 5
    return 68 * sum"
"import math

def main(x):
    n = len(x)
    result = 0
    for i in range(1, n + 1):
        result += 23 * (13 * x[n - i] - 54 * x[math.ceil(i / 3 - 1)] ** 2 - 65) ** 3
    return 38 * result"
"import math

def main(x, z, y):
    ans = 0
    n = len(x)
    for i in range(1, n + 1):
        k = 74 * z[n + 1 - math.ceil(i / 3) - 1] ** 2 + 31 * y[n + 1 - i - 1] ** 3 + x[int(math.ceil(i / 4)) - 1]
        ans += 60 * k ** 4
    return 7 * ans"
"from math import ceil

def main(x, y):
    result = 0
    temp = 0
    i = 1
    length = len(x)
    while i <= length:
        i += 1
        temp = pow(x[length - i], 3)
        result += pow(68 - 16 * pow(y[length + 1 - ceil(i / 4) - 1], 2) - temp, 7)
    return result * 48"
"from math import cos, sin, log, sqrt, floor, ceil

def main(z):
    f = 0
    for i in range(1, len(z) + 1):
        f += (z[i - 1] ** 3 + 61 * z[len(z) - ceil(i / 4)] + 73 * z[len(z) - i] ** 2) ** 3
    result = 32 * f
    return result"
"import math

def main(z):
    res = 0
    for i in range(1, len(z) + 1):
        res += math.log(80 * z[math.ceil(i / 2) - 1] + 85 * z[len(z) - math.ceil(i / 3)] ** 2 + z[math.ceil(i / 2) - 1] ** 3) ** 6
    return 49 * res"
"def main(y):
    result = 0
    n = len(y)
    for i in range(1, n + 1):
        result += (y[n - i] / 43 + 60 * y[abs((i - 1) // 2)] ** 2 + 85) ** 5
    return 60 * result"
"import math

def main(y, x):
    n = len(y)
    result = 0
    for i in range(1, n + 1):
        result += 97 * math.log(99 * x[n - 1 - abs((i - 1) // 2)] + x[n - 1 - abs((i - 1) // 2)] ** 2 + y[n - i] ** 3, 10)
    return 62 * result"
"import math

def main(z, y, x):
    res = 0
    for i in range(3):
        res += pow(pow(y[i], 3) + pow(z[2 - i], 2) + 32 * x[math.ceil((i + 1) / 4) - 1], 4)
    return res"
"import math

def main(x, y):
    sum = 0
    n = len(x)
    for i in range(1, n + 1):
        s1 = 59 * y[n + 1 - math.ceil(i / 2) - 1]
        s2 = x[n + 1 - math.ceil(i / 2) - 1] ** 3
        sum += 82 * math.floor(s1 - s2) ** 5
    return sum"
"from math import tan

def main(z, x, y):
    summ = 0
    tg = 0
    for i in range(0, len(x)):
        tg = tan(y[int(i / 3)] - 51 * z[int(i / 3)] ** 3 - 60 * x[int(i / 3)] ** 2)
        summ += 8 * tg ** 3
    return summ * 45"
"def main(y):
    res = 0
    n = len(y)
    for i in range(1, n + 1):
        res += 36 * (55 * y[n - i] ** 2 + 88 * y[n - i]) ** 5
    res = res * 27
    return res"
"import math

def main(x, y, z):
    i = 0
    summa = 0
    while i < len(y):
        aa = math.pow(z[i], 3)
        a = aa - y[i] - 79 * math.pow(x[math.ceil((i + 1) / 2 - 1)], 2)
        b = 14 * math.pow(a, 5)
        summa = b + summa
        i = i + 1
    return 7 * summa"
"import math

def main(y, z, x):
    n = len(x)
    result = 0
    for i in range(0, n):
        tmp = x[math.ceil(i // 4)] ** 3 / 56
        result += (tmp + y[i] + z[i] ** 2) ** 5
    return result"
"import math

def main(n):
    rez = 0
    for i in range(1, len(n) + 1):
        rez += 93 * (n[len(n) - math.ceil(i / 3)] - n[math.ceil(i / 3) - 1] ** 2 - 41) ** 6
    return rez.real"
"from math import log

def main(vect):
    ans = 0
    n = len(vect)
    for i in range(n):
        ans += log(0.02 + vect[i] ** 2 + 89 * vect[i])
    return float('{:.2e}'.format(ans))"
"import math

def main(z, x):
    summ = 0
    for i in range(8):
        summ += 4 * (65 * x[7 - i] - x[7 - math.ceil((i + 1) / 3 - 1)] ** 3 - z[math.ceil((i + 1) / 3 - 1)] ** 2)
    return summ"
"def main(n):
    res = 0
    for i in range(1, len(n) + 1):
        res += (n[len(n) - i] ** 3 - 21 * n[len(n) - i] ** 2) ** 7
    return 65 * res"
"import math

def main(z, x, y):
    n = len(x)
    f = 0
    for i in range(1, n + 1):
        a = 0
        a += pow(y[math.ceil(i / 2) - 1], 2)
        a += pow(z[n + 1 - math.ceil(i / 2) - 1], 3)
        a += x[n + 1 - math.ceil(i / 4) - 1] / 34
        a = pow(a, 2) / 4
        f += a
    return f"
"from math import ceil

def main(z, y, x):
    n = len(z)
    sum = 0
    for i in range(1, n + 1):
        sum += 16 * (y[ceil(i / 4) - 1] ** 3 + x[n - i] ** 2 + z[i - 1]) ** 2
    return 34 * sum"
"def main(x):
    a = 0
    for i in range(len(x)):
        a += 38 * (x[len(x) - 1 - i] ** 2 + 71 * x[len(x) - 1 - i] ** 3 + 1) ** 6
    return a"
"def main(y, z, x):
    n = len(y)
    local_sum = 0
    for i in range(1, n + 1):
        term1 = x[n - i] ** 3
        term2 = y[(i - 1) // 3]
        term3 = z[n - i] ** 2 / 84
        local = (term1 - term2 - term3) ** 7
        local_sum += local
    return 91 * 86 * local_sum"
"def main(n):
    ans = 0
    for i in range(1, len(n) + 1):
        ans += (n[len(n) - i] ** 2 + 99 * n[len(n) - i] ** 3) ** 7
    return ans"
"def main(x, z):
    one = 0
    n = len(x)
    for i in range(len(x)):
        one += 59 * (68 * z[i] ** 2 + 79 * x[n - 1 - i]) ** 6
    return 92 * one"
"from math import ceil

def main(y):
    n = len(y)
    sum = 0
    for i in range(1, n + 1):
        sum += y[n - ceil(i / 3)] ** 7 / 91
    return sum"
"def main(z, y):
    res = 0
    for i in range(1, len(z) + 1):
        res += (61 * y[i - 1] ** 2 - z[i - 1] ** 3 / 76 - 68) ** 2
    return res"
"import math

def main(z, y, x):
    ans = 0
    n = len(x)
    for i in range(1, n + 1):
        p = 94 * z[n - i] ** 2 - 85 * y[i - 1] - x[math.floor((i - 1) / 2)] ** 3
        ans += p ** 2
    return ans"
"import math

def main(y):
    f = 0
    n = len(y)
    for i in range(1, n + 1):
        a = pow(y[n + 1 - math.ceil(i / 2) - 1], 3)
        b = y[math.ceil(i / 3) - 1]
        c = pow(y[math.ceil(i / 3) - 1], 2)
        v = 76 * pow(a - b - c, 2)
        f += v
    return f"
"import math

def main(y):
    sum = 0
    for i in range(1, len(y) + 1):
        sum += 37 * (32 + y[len(y) - math.ceil(i / 3)] ** 2) ** 2
    return 24 * sum"
"import math

def main(y):
    res = 0
    n = len(y) - 1
    i = 1
    while i <= n + 1:
        res += math.cos(46 * y[n + 1 - i] ** 2 + 1) ** 2
        i += 1
    res *= 30
    return res"
"import math

def main(z, y, x):
    res = 0
    n = len(x)
    for i in range(0, n):
        temp = 43 * math.tan(x[n - 1 - i] + 71 * y[i] ** 2 + 57 * z[n - 1 - i] ** 3) ** 6
        res += temp
    return res"
"import math

def main(n):
    s = 0
    for i in n:
        s += math.tan(82 * i + i ** 2) ** 5
    return s"
"import math

def main(y, z):
    ans = 0
    n = len(y)
    for i in range(1, n + 1):
        a = z[n - i]
        b = z[n - math.ceil(i / 3)] ** 3
        c = 23 * y[n - math.ceil(i / 4)] ** 2
        ans += 91 * math.cos(a + b + c) ** 2
    return ans"
"import math

def main(y, z):
    ans = 0
    n = len(y)
    for i in range(1, n + 1):
        a = 49 * z[n - math.ceil(i / 2)] ** 3
        b = y[i - 1]
        c = 12 * z[n - i] ** 2
        ans += 49 * (a - b - c) ** 5
    return ans"
"from math import ceil

def main(z):
    res = 0
    n = len(z)
    for i in range(1, n + 1):
        res1 = z[n + 1 - ceil(i / 4) - 1]
        res2 = 81 * z[ceil(i / 4) - 1] ** 2
        res3 = z[ceil(i / 4) - 1] ** 3
        res += (res1 + res2 + res3) ** 5
    return 5 * res"
"import math

def main(z):
    r = 0
    S = 0
    s0 = 0
    n = len(z)
    for i in range(1, n + 1):
        r = round(i / 2 + 0.1)
        s0 = 28 * pow(z[n - r], 3) + 62 * z[n - r] + 25 * pow(z[i - 1], 2)
        S += 12 * pow(s0, 5)
    return S"
"def main(y):
    n = len(y)
    summ = 0
    for i in range(0, n):
        yi = y[int(i / 4)]
        u = y[int(i / 4)] ** 3
        q = (83 - yi - u) ** 5
        summ = summ + q
    return summ"
"def main(z, x, y):
    f = 0
    for i in range(1, len(z) + 1):
        f += 68 * (x[len(z) - i] ** 2 / 98 + 90 * y[i - 1] + z[(i - 1) // 2] ** 3) ** 5
    return f"
"def main(x):
    sum_me = 0
    n = len(x)
    for i in range(1, n + 1):
        sum_me += (69 * x[n + 1 - i - 1] ** 2 + 31 + x[i - 1] ** 3) ** 6 / 60
    return sum_me"
"import math

def main(y, z):
    return calculate(y, z)

def calculate(y, z):
    result = 0.0
    n = len(y)
    for i in range(1, n + 1):
        j = n + 1 - i - 1
        result += math.exp(z[j] ** 2 / 94 + y[j] ** 3 + y[j]) ** 6
    return 29 * result"
"def main(x, y, z):
    answer = 0
    n = len(x)
    for i in range(0, n):
        answer += 70 * (x[i // 4] ** 2 - 44 * z[n - 1 - i // 3] - 42 * y[n - 1 - i // 2] ** 3) ** 4
    return answer"
"def main(y, z, x):
    s = 0
    n = 1
    for i in range(0, len(y)):
        xi = x[n + 1 - int(i / 4)] ** 3
        zi = z[int(i / 3)] ** 2
        yi = y[i]
        q = 86 * (95 * xi - 19 * zi - yi)
        s = s + q
    return s"
"def main(z):
    sum = 0
    for i in range(1, len(z) + 1):
        sum += 97 * (36 * z[len(z) - i] + 47 * z[len(z) - i] ** 2) ** 3
    return sum"
"import math

def main(x, z):
    result = 0
    n = len(x)
    for i in range(1, n + 1):
        result += math.ceil(48 * z[i - 1] - x[n - i] ** 2 - 1) ** 3 / 74
    return 18 * result"
"from math import ceil

def main(x, z):
    n = len(x)
    return sum([48 * x[n - ceil(i / 4)] + 16 * z[n - ceil(i / 4)] ** 2 + 48 for i in range(1, n + 1)])"
"def main(z, x):
    n = len(z)
    sum = 0
    for i in range(0, n):
        sum += (95 * x[n - 1 - i] ** 3 - z[i] ** 2) ** 7
    return 73 * sum"
"def main(x):
    result = 0
    n = len(x)
    for i in range(1, n + 1):
        cur = x[int(n + 1 - i / 2) - 1]
        result += pow(cur + 1 + 59 * pow(cur, 2), 4)
    return 50 * result"
"def main(x):
    result = 0
    n = len(x)
    for i in range(1, n + 1):
        cur = x[int(n + 1 - i / 2) - 1]
        result += pow(cur + 1 + 59 * pow(cur, 2), 4)
    return 50 * result"
"def main(x, z, y):
    n = len(x)
    res = 0
    for i in range(n):
        res += 73 * (pow(x[i // 2], 3) - z[i] - 6 * pow(y[i], 2)) ** 6
    res = '{:.2e}'.format(res)
    return float(res)"
"import math

def main(x, y):
    result = 0
    n = len(x)
    for i in range(1, n + 1):
        a = 62 * x[n - i] ** 2
        b = y[i // 3] ** 3
        result += math.log10(a + b) ** 7 / 74
    return 2 * result"
"from math import *

def main(x):
    var = 0
    n = len(x)
    for i in range(1, n + 1):
        q = n + 1 - ceil(i / 3) - 1
        temp = x[q] ** 2 - x[q] ** 3 - 1
        var += pow(abs(temp), 7)
    return var * 52"
"from math import ceil

def main(y, z):
    n = len(y)
    result = 0
    for i in range(n):
        result += ceil(94 + y[i] + 73 * z[n - 1 - i] ** 3) ** 6
    return result"
"import math as m

def main(x):
    res = 0
    for i in range(1, len(x) + 1):
        res += 94 * (1 - 14 * x[len(x) + 1 - m.ceil(i / 3) - 1] - 38 * x[i - 1] ** 3) ** 7
    res = 80 * res
    return res"
"import math

def main(z, y, x):
    res = 70
    n = len(z)
    t = 0
    for i in range(1, n + 1):
        a = y[n + 1 - math.ceil(i / 2) - 1]
        a = x[i - 1] - z[math.ceil(i / 3) - 1] ** 3 - 35 * a ** 2
        t += 3 * a ** 2
    res *= t
    return res"
"from math import *

def main(y, z):
    f = 0
    n = len(y)
    for i in range(1, n + 1):
        f += 38 * (z[ceil(i / 4) - 1] - y[n + 1 - ceil(i / 4) - 1] ** 3) ** 3
    return 65 * f"
"from math import *

def main(x, y, z):
    f = 0
    n = len(x)
    for i in range(1, n + 1):
        t = (x[n + 1 - ceil(i / 2) - 1] ** 2 / 31 + z[ceil(i / 3) - 1] ** 3 + y[n + 1 - ceil(i / 3) - 1]) ** 7
        f += 75 * t
    return f"
"from math import *

def main(y):
    n = len(y)
    func = 0
    for i in range(1, n + 1):
        func += y[n + 1 - ceil(i / 4) - 1] ** 4 / 86
    return func"
"import math

def main(arr):
    res = 0
    for i in range(1, len(arr) + 1):
        a = arr[math.ceil(i / 3) - 1]
        res += math.cos(1 - arr[math.ceil(i / 3) - 1] ** 3 - a) ** 4
    return res"
"from math import ceil

def main(x: list, y: list):
    result = 0
    n = len(x)
    for i in range(1, n + 1):
        result += pow(y[n - ceil(i / 4)] ** 3 + 27 * pow(y[n - ceil(i / 4)], 2) + 57 * x[i - 1], 2)
    result *= 71
    return result"
"from math import ceil

def main(x: list, y: list):
    result = 0
    n = len(x)
    for i in range(1, n + 1):
        result += pow(y[n - ceil(i / 4)] ** 3 + 27 * pow(y[n - ceil(i / 4)], 2) + 57 * x[i - 1], 2)
    result *= 71
    return result"
"from math import *

def closed_range(start, stop, step=1):
    dir = 1 if step > 0 else -res1
    return range(start, stop + dir, step)

def f(y):
    n = len(y)
    res = 0
    for i in closed_range(1, n):
        ind1 = n + 1 - ceil(i / 3)
        res += 82 * pow(abs(69 * pow(y[ind1 - 1], 3) + 46 * pow(y[ind1 - 1], 2) + 60), 6)
    return res

def formatExp(fl):
    return '%.2e' % fl

def main(a):
    return f(a)"
"def main(x):
    n = len(x)
    return sum(((89 * x[n - 1 - i] ** 3 - 9 * x[n - 1 - i]) ** 7 for i in range(0, n)))"
"def main(z, x):
    result = 0
    n = len(z)
    for i in range(n):
        result += 56 * (x[n - 1 - i] - 34 * z[n - 1 - i // 2] ** 3) ** 3
    return result * 70"
"import math

def main(y):
    n = len(y)
    s = 0.0
    for i in range(1, n + 1):
        s = s + math.log10(y[n + 1 - i - 1] + 2 * y[int(math.ceil(i / 4.0)) - 1] ** 3) ** 5
    return s"
"import math

def main(y):
    x = 0
    n = len(y)
    for i in range(n):
        x += 84 * (y[math.floor(i / 2)] + 96 + y[i] ** 3 / 3) ** 4
    return 5 * x"
"import math

def main(x):
    n = len(x)
    s = 0.0
    for i in range(1, n + 1):
        s += x[int(math.ceil(i / 2.0)) - 1] ** 2 - 56 * x[int(math.ceil(i / 2.0)) - 1]
    s = s * 32
    return s"
"import math

def main(y):
    summa = 0
    for i in range(1, len(y) + 1):
        summa += math.pow(math.pow(y[int(math.ceil(i / 2) - 1)], 2) + math.pow(y[len(y) - i], 3) + 39, 4)
    return summa * 47
main([-0.83, 0.47, -0.03, 0.95])"
"import math

def main(z, x):
    result = 0
    n = len(z)
    for i in range(1, n + 1):
        result += 97 * (x[n - i] ** 3 + 1 + z[math.ceil(i / 4) - 1]) ** 2
    return result"
"def main(y, x):
    ans = 0
    for i in range(len(x)):
        ans += 2 * (80 * x[i // 4] + 67 * x[len(x) - 1 - i] ** 3 + y[i // 4] ** 2) ** 5
    ans *= 55
    return ans
main([-0.98, -0.05, -0.03, 0.23, 0.34, 0.0], [0.03, -0.36, -0.0, -0.89, 0.52, 0.55])"
"def main(y):
    n = len(y)
    func = 0
    for i in range(1, n + 1):
        func += 50 * (12 * pow(y[n + 1 - i - 1], 3) - 1) ** 4
    return func * 83"
"import math

def main(exp_list):
    sum = 0
    for i in range(0, len(exp_list)):
        sum += 17 * (29 * exp_list[math.floor(i / 3)] ** 2 + 34 + 28 * exp_list[i]) ** 4
    return sum"
"def main(y, z):
    ans = 0
    n = len(y)
    for i in range(1, n + 1):
        ans += pow(pow(z[n - i], 3) + y[i - 1], 6)
    return 54 * ans"
"import math
from decimal import Decimal

def main(z, x):
    s = 0
    n = len(z)
    for i in range(1, n + 1):
        s1 = z[n - i] ** 2
        s2 = 46 * z[n - i]
        s3 = x[n - i] ** 3
        s += (s1 + s2 + s3) ** 3
    return s"
"from math import *

def main(x, y):
    n = len(x)
    res = 0.0
    for i in range(1, n + 1):
        res += 1 / 46 * exp(27 * x[i - 1] - 2 * y[n - ceil(i / 3)] ** 2 - 32) ** 4
    return res * 78"
"import math
import sys

def main(x):
    t = 0
    for i in range(0, len(x)):
        t += x[i] * 3 / 86 + 84 + x[i] ** 2
    return 90 * t"
"import math

def main(y, x):
    result = 0
    n = len(y)
    for i in range(1, n + 1):
        result += (92 * y[n - i] - x[math.trunc(n - i / 3)] ** 2 - y[n - i] ** 3) ** 5
    return result"
"from math import acos

def main(z):
    res = 0
    n = len(z)
    for i in range(n):
        res += acos(0.02 + z[n - i - 1] + z[n - i - 1] ** 3) ** 4
    return 78 * res"
"import math

def main(x, z, y):
    s = 0
    n = 2
    for i in range(1, 3):
        s += 2 * (y[n + 1 - i - 1] ** 3 + z[n + 1 - math.ceil(i / 4) - 1] ** 2 + x[math.ceil(i / 2) - 1]) ** 4
    return s"
"import math

def main(y, x, z):
    res = 31
    sum1 = 0
    n = 2
    for i in range(1, 3):
        sum1 += (x[n + 1 - math.ceil(i / 2) - 1] ** 2 + z[n + 1 - math.ceil(i / 4) - 1] ** 3 + 28 * y[math.ceil(i / 3) - 1]) ** 5 / 52
    res *= sum1
    return res"
"import math

def main(z):
    n = z.__len__()
    counter = 0
    for i in range(1, n + 1):
        counter += math.log(z[n - math.ceil(i / 3)], 10) ** 4
    return counter * 67"
"import math

def main(z, x, y):
    s = 0
    for i in range(1, len(x) + 1):
        s = s + 10 * (36 * y[math.ceil(i / 3 - 1)] + x[math.ceil(i / 3 - 1)] ** 3 / 29 + z[math.ceil(i / 4 - 1)] ** 2) ** 7
    return s"
"import math

def main(z):
    n = len(z)
    res = 0
    for i in range(1, n + 1):
        res += 65 * (z[math.ceil(i / 2) - 1] + z[n - math.ceil(i / 3)] ** 3 + 1) ** 2
    return res"
"import math

def main(a):
    n = len(a)
    b = 0
    for i in range(1, n + 1):
        b += a[n + 1 - 1 - math.ceil(i / 4)] ** 4 / 53
    return b"
"from math import exp
from math import ceil

def main(z, x):
    sum = 0
    for i in range(1, len(z) + 1):
        sum += 48 * exp(76 * x[i - 1] ** 2 - z[ceil(i / 2) - 1] ** 3 - 1) ** 4
    return 3 * sum"
"from math import ceil

def main(y, z):
    n = len(y)
    summ = 0
    for i in range(1, n + 1):
        summ += (18 * y[n + 1 - ceil(i / 4) - 1] ** 3 + z[ceil(i / 3) - 1]) ** 4
    return 33 * summ"
"import math

def main(y, x):
    ans = 0
    n = len(x)
    for i in range(1, n + 1):
        ans += (x[n - i] ** 2 - y[n - math.ceil(i / 2)]) ** 7
    return 76 * ans"
"def main(z):
    n = len(z)
    sum = 0
    for i in range(1, n + 1):
        sum += (z[i - 1] + 88 * z[n + 1 - i - 1] ** 2 + z[i - 1] ** 3) ** 6
    return sum"
"import math

def main(z, x, y):
    n = len(y)
    summ = 0
    for i in range(1, n + 1):
        summ += (13 * z[i - 1] + 36 * x[math.ceil(i / 3) - 1] ** 2 + 12 * y[n + 1 - i - 1] ** 3) ** 5
    return 920 * summ"
"def main(y, z):
    ans = 0
    for i in range(len(y)):
        ans += (z[len(y) - 1 - i] ** 2 - 38 * y[i]) ** 4
    return ans
main([0.24, 0.23, 0.28], [-0.81, 0.86, 0.39])"
"import math

def main(x):
    value = 0.0
    n = len(x)
    for i in range(1, n + 1):
        xi = x[n - math.ceil(float(i) / 3)]
        value += pow(2 * pow(xi, 3) + 19 * pow(xi, 2) + xi, 2)
    return 33 * value"
"def main(list_of_vectors):
    summ = 0
    n = len(list_of_vectors)
    for i in range(0, n):
        summ += 46 * (51 * list_of_vectors[n - 1 - i] - list_of_vectors[n - 1 - i] ** 2 - list_of_vectors[n - 1 - i] ** 3 / 44) ** 2
    return 23 * summ"
"def main(list_of_vectors):
    summ = 0
    n = len(list_of_vectors)
    for i in range(0, n):
        summ += 46 * (51 * list_of_vectors[n - 1 - i] - list_of_vectors[n - 1 - i] ** 2 - list_of_vectors[n - 1 - i] ** 3 / 44) ** 2
    return 23 * summ"
"import math

def main(z):
    s = 0
    for i in range(0, len(z)):
        s += 84 * (22 * z[i] - 96 - z[i] ** 2) ** 7
    return s"
"from math import asin
from math import ceil

def main(x, z):
    s = 0
    for i in range(len(x)):
        s += 10 * asin(x[ceil(i // 2)] ** 2 - z[ceil(i // 4)] / 12 - 1) ** 7
    return s"
"def f(y):
    result = 0
    for i in range(len(y)):
        result += (y[i] ** 3 - 35 - 49 * y[i]) ** 4
    return result * 76

def main(y):
    return f(y)"
"import math

def main(z, y, x):
    sum_x = 0
    sum_y = 0
    sum_z = 0
    sum_all = 0
    n = 6 - 1
    for i in range(0, 6):
        sum_y = y[n + 1 - math.ceil((i + 1) / 2)] ** 3
        sum_x = 72 * x[n + 1 - math.ceil((i + 1) / 3)]
        sum_z = 82 * z[i] ** 2
        sum_all += 34 * (sum_y - sum_x - sum_z) ** 6
    return sum_all
main([0.68, 0.08, 0.45, 0.59, 0.14, 0.1], [-0.07, 0.81, -0.33, 0.74, -0.74, -0.17], [0.72, -0.72, 0.12, -0.18, -0.84, -0.42])
main([-0.08, 0.58, -0.15, 0.2, 0.41, -0.74], [-0.88, -0.73, 0.29, -0.26, 0.88, -0.36], [-0.88, -0.09, -0.82, 0.53, 0.25, -0.91])"
"from math import ceil

def main(z, y, x):
    n = len(z)
    ans = 0
    for i in range(1, n + 1):
        ans += 20 * (z[ceil(i / 3) - 1] + x[n - i] ** 2 + y[n - ceil(i / 2)] ** 3 / 9) ** 7
    return ans"
"import math

def main(z, x, y):
    result = 0
    n = len(z)
    for i in range(1, n + 1):
        var1 = z[math.ceil(i / 3) - 1] ** 3
        var2 = -16 * y[i - 1] ** 2
        var3 = -1 * x[n - math.ceil(i / 2)] / 74
        result += (var1 + var2 + var3) ** 2 / 71
    return result"
"import math

def main(y, x, z):
    result = 0
    n = len(z)
    for i in range(1, n + 1):
        var1 = 19 * z[math.ceil(i / 4) - 1]
        var2 = y[i - 1] ** 3
        var3 = x[n - i] ** 2
        result += (var1 + var2 + var3) ** 6
    return 23 * result"
"import math

def main(x, z, y):
    result = 0
    n = len(z)
    for i in range(1, n + 1):
        r1 = 22 * pow(z[math.ceil(i / 3) - 1], 3)
        r2 = 67 * pow(x[n - i], 2)
        r3 = y[n - math.ceil(i / 2)]
        result += 33 * pow(r1 + r2 + r3, 6)
    return 58 * result"
"import math

def main(z, x):
    sum = 0
    n = len(z)
    for i in range(n):
        sum += 92 * x[n - 1 - math.ceil(i // 3)] ** 3 - 43 * z[n - 1 - i]
    return sum"
"from cmath import exp
from math import ceil
import math

def main(x, y):
    sum = 0
    lxdxd = 0
    for i in range(0, len(x)):
        exponenta = math.exp(y[ceil(i // 2)] ** 2 + x[ceil(i // 3)])
        lxdxd += 80 * exponenta ** 3
    return 70 * lxdxd"
"from math import sqrt
from math import ceil

def main(x, z, y):
    result = 0
    for i in range(0, len(x)):
        first_term = z[len(x) - 1 - i // 2] / 48
        second_term = y[i] ** 2 / 75
        third_term = 79 * x[i] ** 3
        result += (first_term + second_term + third_term) ** 3
    return result"
"import math

def main(y, z):
    f = 0
    for i in range(0, len(y)):
        f += (y[i] ** 3 - z[round(i / 3)]) ** 3
    return f"
"import math

def main(z, y, x):
    n = len(z)
    ans = 0
    for i in range(1, n + 1):
        s1 = 64 * x[n - math.ceil(i / 3)] ** 3
        s2 = 3 * y[n - math.ceil(i / 3)] ** 2
        s3 = z[n - math.ceil(i / 2)]
        ans += 90 * (s1 + s2 + s3) ** 5
    return ans"
"def main(y):
    n = len(y)
    res = 0
    for i in range(1, n + 1):
        res += pow(6 - 79 * pow(y[n - i], 3) - 84 * pow(y[n - i], 2), 3)
    return 31 * res"
"import math as math

def main(z):
    n = len(z)
    res = 0
    for i in range(1, n + 1):
        res += 26 * (z[i - 1] / 63 - pow(z[n - i], 2))
    return 28 * res"
"from math import *

def main(y):
    total = 0
    n = len(y)
    for i in range(1, n + 1):
        a = 89 * y[ceil(i / 4 - 1)]
        b = 62 * pow(y[ceil(i / 4 - 1)], 2)
        c = pow(y[n - ceil(i / 2)], 3)
        total += pow(a + b + c, 4)
    return total * 3"
"import math

def main(z, x, y):
    n = len(y)
    summ = 0
    for i in range(1, n + 1):
        summ += (y[n + 1 - math.ceil(i / 4) - 1] ** 2 - z[math.ceil(i / 3) - 1] - x[math.ceil(i / 2) - 1] ** 3) ** 4
    return 69 * summ"
"def main(y):
    su = 0
    n = len(y) - 1
    for i in range(0, len(y)):
        su += (y[n - i] + y[n - i] ** 3) ** 6
    return su * 98"
"from math import log2, floor, ceil

def main(mass):
    arg1 = 0
    len1 = len(mass)
    i = 1
    while i <= len1:
        arg1 += 41 * (1 - mass[ceil(i / 4) - 1] - 72 * mass[ceil(i / 4) - 1] ** 3)
        i += 1
    return arg1"
"import math

def main(y, z, x):
    result = 0
    n = len(x)
    for i in range(1, len(x) + 1):
        result += 58 * (28 * y[n - i] ** 3 - z[math.floor((i - 1) / 3)] - 92 * x[i - 1] ** 2) ** 2
    return 16 * result
main([-0.97, -0.76], [0.14, 0.42], [0.02, -0.57])
main([0.95, -0.79], [0.43, -0.31], [0.41, -0.49])"
"import math

def main(z):
    n = len(z)
    sum = 0
    for i in range(0, n):
        sum += math.floor(96 * z[n - i - 1] ** 2 + z[i] + 53) / 69
    return sum"
"import math

def main(x, y, z):
    n = len(x)
    sum = 0
    for i in range(1, n + 1):
        sum += (96 * y[math.floor((i - 1) / 3)] ** 3 - 58 * z[n - i] - 87 * x[n - i] ** 2) ** 6
    return sum
main([-0.4, -0.23, 0.35, -0.35], [0.16, -0.68, -0.44, -0.53], [-0.64, -0.82, -0.06, -0.9])
main([0.27, 0.35, -0.04, -0.14], [0.14, 0.72, -0.38, 0.46], [0.73, -0.19, -0.82, -0.18])"
"import math

def main(n):
    rez = 0
    for i in range(1, len(n) + 1):
        rez += 77 * (40 * n[math.ceil(i / 4) - 1] - n[math.ceil(i / 4) - 1] ** 2) ** 3
    return rez.real"
"def main(y, z):
    result = 0
    n = len(y)
    for i in range(n):
        result += 33 * pow(z[n - 1 - i] - 39 * pow(y[n - 1 - i], 2), 7)
    return result"
"import math

def main(x):
    length = len(x)
    f1 = 0
    for i in range(1, length + 1):
        f1 += 10 * (91 * x[length - math.ceil(i / 3)] + 10 * x[i - 1] ** 3) ** 5
    return f1"
"import math

def main(z, x, y):
    sum = 0
    n = len(x)
    for i in range(1, n + 1):
        sum += 25 * (x[n - math.ceil(i / 4)] ** 2 / 83 + y[n - i] ** 3 + 38 * z[i - 1]) ** 6
    return 40 * sum"
"import math

def main(z, x, y):
    result = 0
    for i in range(0, len(z)):
        z1 = z[math.floor(i / 3)]
        y1 = y[math.floor(i / 2)]
        x1 = x[math.floor(i / 3)]
        result += 25 * (z1 ** 3 + y1 ** 2 + x1) ** 3
    return result"
"from math import ceil

def main(x):
    total = 0
    for i in range(1, 4):
        total += 90 * (x[3 - ceil(i / 4)] ** 3 + 53 * x[ceil(i / 2) - 1] + 51)
    return total"
"import math

def main(z, x, y):
    sum = 0
    n = len(x)
    for i in range(1, n + 1):
        sum += (z[n - i] ** 2 + 6 * x[math.ceil(i / 3) - 1] + y[n - math.ceil(i / 4)] ** 3) ** 7
    return 81 * sum"
"import math

def main(y):
    f = 0
    for i in range(1, len(y) + 1):
        f += (55 * y[len(y) - abs(math.ceil(i / 4))]) ** 7 / 34
    return f * 29"
"import math

def main(y):
    total = 0
    for i in range(1, 5, 1):
        total += pow(87 * pow(y[4 - math.ceil(i / 3)], 3) + 46 * pow(y[i - 1], 2), 5)
    return 29 * total"
"from math import *

def fun(y):
    result = 0
    for i in range(1, len(y) + 1):
        result += log10(0.05 + 61 * y[ceil(i / 4) - 1] ** 2 + 25 * y[ceil(i / 4) - 1]) ** 2
    return 82 * result

def main(y):
    return fun(y)"
"from math import ceil, log2

def main(z, x, y):
    n = len(z)
    a = 0
    for i in range(1, n + 1):
        a += log2(x[i - 1] / 39 + y[n - ceil(i / 3)] ** 2 + 33 * z[n - i] ** 3) ** 6
    return a"
"import cmath

def f5(z):
    result = 0
    for i in range(len(z)):
        result += 38 * cmath.exp(46 * z[i] ** 3 - 35 * z[i] ** 2) ** 7
    return result.real

def main(n):
    return f5(n)"
"import math

def main(arr):
    sum1 = 0
    for i in arr:
        sum1 += 60 * pow(math.log(54 * pow(i, 2) - 48 * pow(i, 3), 2), 3)
    return 91 * sum1"
"import math

def main(x, y, z):
    n = len(y)
    sum = 0
    for i in range(1, n + 1):
        a_1 = y[n - math.ceil(i / 3)]
        a_2 = pow(x[n - math.ceil(i / 2)], 3)
        a_3 = pow(z[n - i], 2)
        sum += pow(math.log2(90 * a_1 + a_2 + 38 * a_3), 2) / 41
    return sum"
"import math

def main(arr):
    f = 0
    n = len(arr)
    for i in range(1, n + 1):
        f += 92 * math.asin(arr[n - math.ceil(i / 4)]) ** 2
    return 87 * f"
"from math import ceil

def main(x, z):
    sum = 0
    n = len(x)
    for i in range(1, n + 1):
        sum += (z[n - ceil(i / 4)] ** 3 / 54 - 42 * x[ceil(i / 2) - 1]) ** 3 / 83
    return 85 * sum"
"from math import *

def main(y, x):
    f = 0
    n = len(y)
    for i in range(1, n + 1):
        f += 43 * (73 * x[n + 1 - ceil(i / 2) - 1] ** 3 - y[ceil(i / 4) - 1] - 1) ** 6
    return f"
"def main(some_list):
    y = 0
    n = len(some_list)
    for i in range(0, n):
        y += (some_list[i] ** 2 - 66 * some_list[n - 1 - i] ** 3) ** 2
    return y"
"from math import ceil

def main(y, x):
    number = 0
    n = len(y)
    for i in range(1, n + 1):
        number += (y[i - 1] + x[n + 1 - ceil(i / 2) - 1] ** 2 + y[i - 1] ** 3) ** 7
    return number"
"from math import ceil

def main(z, x, y):
    f = 0
    n = len(z)
    for i in range(1, n + 1):
        f += 31 * (y[ceil(i / 4) - 1] ** 2 - z[n + 1 - i - 1] ** 3 - 7 * x[n + 1 - ceil(i / 2) - 1]) ** 7
    return 70 * f"
"import math

def main(x):
    result = 0
    n = len(x) - 1
    for i in range(1, len(x) + 1):
        a = 67 * x[n + 1 - math.ceil(i / 3)] ** 3
        result += (a + x[n + 1 - math.ceil(i / 3)] ** 2 / 42 + x[n + 1 - math.ceil(i / 3)] / 2) ** 2
    return 23 * result"
"import math

def f(z, y, x):
    total = 0
    long = len(z)
    for i in range(1, long + 1):
        total += 49 * math.asin(x[long + 1 - i - 1] - z[i - 1] ** 2 - y[long + 1 - i - 1] ** 3)
    return 30 * total

def main(z, y, x):
    return f(z, y, x)"
"def main(array):
    return sum([70 * (array[int(i / 4)] ** 2 + array[int(i / 4)] ** 3 + 69) ** 2 for i in range(1, len(array) + 1)])"
"import math

def main(x, y):
    n = len(x)
    f = 0
    for i in range(1, n + 1):
        f += (x[i - 1] / 6 + y[n - math.ceil(i / 2)] ** 2 + x[i - 1] ** 3) ** 6
    return 86 * f"
"import math as m

def main(x):
    q = 0
    for i in range(len(x)):
        j = int(i / 3)
        q += m.pow(m.log10(7 * m.pow(x[j], 2) - m.pow(x[j], 3)), 5)
    return q * 79"
"import math

def main(*vector):
    d = 0
    n = len(vector)
    for i in range(1, n + 1):
        k = 64 * vector[0][i - 1]
        m = 59 * vector[1][n - i] ** 2
        g = (k + m + vector[2][math.ceil(i / 2) - 1] ** 3) ** 3
        d = d + 87 * g
    return 66 * d"
"from math import *

def main(y, z):
    result = 0
    n = len(z)
    for i in range(0, n):
        x1 = 2 - 28 * z[i] ** 3 - 43 * y[i]
        result += 67 * x1
    return result"
"from math import ceil

def main(x, y):
    res = 0
    for i in range(1, len(x) + 1):
        first = 11 * x[len(x) - i] ** 3
        second = 14 * y[len(x) - ceil(i / 4)] ** 2
        res += 16 * abs(first - second)
    return res"
"def main(y, x):
    return sum([(x[int(i / 4)] - y[i] ** 2) ** 7 for i in range(0, len(y))])"
"from math import ceil

def main(z, y, x):
    n = len(y)
    f = 0
    for i in range(1, n + 1):
        f += 21 * (z[i - 1] ** 2 + x[ceil(i / 3) - 1] ** 3 / 5 + y[ceil(i / 4) - 1] / 97) ** 4
    return f"
"import math

def main(y, z):
    sum = 0
    length = len(y)
    for i in range(1, length + 1):
        one = z[length - math.ceil(i / 2)] ** 3
        one += 53 * y[length - math.ceil(i / 3)] ** 2
        one += 19 * y[math.ceil(i / 3) - 1]
        sum += 71 * one ** 2
    return 6 * sum"
"import math

def main(x):
    n = len(x)
    sum = 0
    for i in range(1, n + 1):
        sum += 44 * (88 * x[i - 1] ** 3 + x[math.ceil(i / 2) - 1])
    return 20 * sum"
"import math

def main(y, x, z):
    result = 0
    n = len(z)
    for i in range(n):
        a = x[int(i / 2)] - z[int(i / 3)] ** 3 / 90
        b = y[int(i / 2)] ** 2 / 15
        result += (a - b) ** 6
    return result"
"def main(y: list):
    n = len(y)
    y.insert(0, 0)
    return sum(((87 * y[n + 1 - i] ** 3) ** 2 / 97 for i in range(1, n + 1)))"
"import math

def main(x, z, y):
    n = len(x)
    res = 0
    for i in range(0, n):
        a = x[n - 1 - math.ceil(i // 4)]
        b = y[n - 1 - math.ceil(i // 3)] ** 3
        res += (z[math.ceil(i // 2)] ** 2 - a - b) ** 5
    return res"
"import math

def main(z, y):
    n = len(y)
    result = 0
    i = 1
    while i <= n:
        a = 53 * z[i - 1] ** 2
        b = y[n - math.ceil(i / 4)] / 63
        result += math.tan(a + b) ** 5
        i += 1
    return result"
"from math import ceil

def main(y, x, z):
    sum = 0
    n = len(x) - 1
    for i in range(1, len(x) + 1):
        sum += (14 * y[n + 1 - ceil(i / 4)] - 38 * x[n + 1 - ceil(i / 4)] ** 3 - z[n + 1 - i] ** 2) ** 6
    return 16 * sum"
"def f(z, y, x):
    result = 0
    for i in range(0, len(z)):
        result += (y[i] ** 2 / 16 + 75 * x[i] ** 3 + z[i]) ** 7
    return result

def main(*args):
    return f(*args)"
"def main(z, y, x):
    f = 0
    n = len(z) - 2
    for i in range(n + 2):
        f += 87 * (z[i] - x[n + 1 - i] ** 3 / 5 - y[i] ** 2) ** 2
    return f"
"from typing import List

def get_amount(a: List[int | float]) -> int | float:
    n = len(a)
    summ = 0
    for i in range(1, n + 1):
        summ += (60 * a[n - i] ** 3) ** 3 / 30
    return summ

def main(a: List[int | float]) -> int | float:
    return 24 * get_amount(a)"
"import math

def main(z, x):
    result = 0
    n = len(z)
    i = 1
    while i <= n:
        first = 49 * x[n + 1 - math.ceil(i / 3) - 1]
        second = 84 * z[math.ceil(i / 3) - 1] ** 3
        third = x[n + 1 - math.ceil(i / 3) - 1] ** 2
        result += 15 * (first - second - third) ** 5
        i += 1
    return result * 34"
"import math

def main(y, z, x):
    result = 0
    n = len(y)
    for i in range(0, n):
        result += (z[math.floor(i / 4)] / 23 + 92 * x[math.floor(i / 4)] ** 3 + y[i] ** 2) ** 6
    return result
main([-0.87, -0.17, -0.55, 0.95, -0.54], [-0.86, -0.39, -0.98, -0.16, 0.56], [0.49, 0.46, -0.82, -0.36, 0.05])"
"import math

def main(x, y, z):
    r = 0
    n = len(y)
    for i in range(1, n + 1):
        a = x[n - math.ceil(i / 3)] ** 2
        r = r + 40 * math.atan(y[n - i] ** 3 - 32 * a - 2 * z[math.ceil(i / 3) - 1]) ** 4
    return r"
"import math

def main(x, z, y):
    n = len(x)
    res = 0
    for i in range(1, n + 1):
        a = 97 * y[i - 1] * y[i - 1] - 24 * z[n - i]
        b = pow(x[int((i - 1) / 2)], 3)
        res += 13 * (a - b)
    return res"
"def main(x):
    result = 0
    for i in range(1, len(x) + 1):
        result += 34 * pow(66 - 87 * pow(x[len(x) + 1 - i - 1], 3), 4)
    return 41 * result"
"import math

def main(x, y):
    res = 0
    n = len(x)
    for i in range(0, n):
        a = 79 * y[n - 1 - math.ceil(i // 3)]
        res += 22 * (x[math.ceil(i // 2)] ** 2 + a) ** 4
    return 29 * res"
"def main(x):
    sum = 0
    n = len(x)
    for i in range(1, n + 1):
        sum += 78 * (46 * (x[n - i] ** 3 + 98 * x[n - i] + x[n - i] ** 2 / 65) ** 6)
    return sum"
"import math

def main(z, y, x):
    r2 = 0
    n = len(x)
    for i in range(0, n):
        r1 = 68 * y[n - 1 - i] ** 3 + z[n - 1 - math.ceil(i // 4)] ** 2
        r2 += (r1 + x[i // 4] / 11) ** 2
    return 88 * r2"
"from math import *

def main(y, x):
    k = 0
    n = len(x) - 1
    for i in range(1, len(x) + 1):
        k += 4 * (47 * x[n + 1 - ceil(i / 4)] ** 2 - 50 * y[n + 1 - i] - 16 * x[n + 1 - ceil(i / 4)] ** 3) ** 7
    return k * 51"
"import math

def main(z, x, y):
    n = len(x)
    res = 0
    for i in range(0, n):
        a = z[math.ceil(i // 3)] ** 2 / 93
        res += (a + x[math.ceil(i // 3)] ** 3 + 17 * y[i]) ** 5
    return 5 * res"
"from math import ceil

def main(y, x, z):
    n = len(x)
    total = 0
    for i in range(1, n + 1):
        total += (y[i - 1] - z[ceil(i / 3) - 1] ** 2 - 56 * x[n + 1 - ceil(i / 3) - 1] ** 3) ** 4 / 15
    return total * 52"
"import math

def main(y, z, x):
    y_len = math.sqrt(pow(y[0], 2) + pow(y[1], 2))
    z_len = math.sqrt(pow(z[0], 2) + pow(z[1], 2))
    x_len = math.sqrt(pow(x[0], 2) + pow(x[1], 2))
    res = 0
    for i in range(1, 3):
        res += pow(x[i - 1] / 9 + pow(y[i - 1], 2) + pow(z[1 - i // 4], 3), 4)
    return res"
"import math

def main(x, z):
    s = 0
    n = len(x)
    for i in range(1, n + 1):
        i3 = math.ceil(i / 3)
        i4 = math.ceil(i / 4)
        s += 56 * (36 * x[n - i3] ** 2 - z[n - i4] ** 3 - z[i3 - 1]) ** 7
    return s
main([0.16, -0.19, -0.7, 0.08, -0.96, -0.73], [0.33, 1.0, -0.35, -0.56, -0.13, -0.69])
main([1.0, -0.96, -0.83, 0.41, -0.45, -0.74], [0.15, -0.24, 0.96, 0.83, -0.91, -0.15])"
"import math

def main(y):
    f = 0
    for i in range(0, len(y)):
        f += (21 * y[i] ** 3 - 89 * y[i]) ** 6 / 20
    return f"
"import math

def main(y):
    answer = 0
    for i in range(0, len(y)):
        answer += pow(pow(y[i], 3) + y[math.ceil((i + 1) / 4) - 1], 2)
    return answer * 52"
"def main(x, y):
    f = 0
    for i in range(1, len(x) + 1):
        f += 39 * (72 * x[len(x) - i] ** 3 - y[(i - 1) // 2] / 50 - 82 * x[(i - 1) // 2] ** 2) ** 5
    return 54 * f"
"import math

def main(y, x):
    s = 0
    for i in range(1, len(y) + 1):
        s = s + (y[len(y) - i] ** 2 - x[len(x) - math.ceil(i / 4)] ** 3) ** 4
    return s"
"import math

def main(x, y):
    n = len(x)
    s = 0
    for i in range(1, n + 1):
        s += 89 * (11 * x[n - math.ceil(i / 4)] - 21 * y[n - i] ** 2) ** 3
    return s"
"import math

def main(x, y, z):
    rez = 0
    n = len(x) - 1
    for i in range(1, n + 2):
        t1 = z[n + 1 - math.ceil(i / 3)]
        t2 = x[n + 1 - i] ** 2 + y[n + 1 - math.ceil(i / 3)] ** 3 / 46
        rez = rez + 7 * (t1 - t2) ** 7
    return rez"
"def main(n):
    from math import ceil
    res = 0
    for i in range(1, len(n) + 1):
        a = n[int(len(n) - ceil(i / 4))]
        b = 49 * n[int(len(n) - ceil(i / 4))] ** 3
        c = n[int(len(n) - ceil(i / 4))] ** 2
        res += 85 * (a - b - c) ** 7
    return res"
"from math import *

def main(x, y, z):
    n = len(x)
    r = 0
    for i in range(len(x)):
        r += (17 * z[n - 1 - i] ** 3 - 28 * y[i] ** 2 - 21 * x[n - 1 - i]) ** 6
    return 40 * r"
"from math import ceil

def main(z, x):
    sum = 0
    n = len(z)
    for i in range(1, n + 1):
        sum = sum + (97 * z[ceil(i / 3) - 1] + 20 + 50 * x[n - ceil(i / 4)] ** 2) ** 4
    return sum"
"import math

def main(y, z, x):
    summ = 0
    n = len(x)
    for i in range(1, n + 1):
        summ += 12 * math.ceil(x[n - math.ceil(i / 4)] ** 2 + 60 * y[n - math.ceil(i / 3)] + 41 * z[n - i] ** 3) ** 3
    return summ"
"from math import floor

def main(y, z, x):
    n = len(y)
    a = 0
    for i in range(1, n + 1):
        first = 49 * y[floor((i - 1) / 3)] ** 2
        second = 88 * x[floor((i - 1) / 4)] ** 3
        third = z[i - 1] / 61
        a += (first + second + third) ** 2
    return a"
"from math import *

def main(y, x, z):
    f = 0
    for i in range(0, len(x)):
        f += 18 * (z[i] ** 3 + 63 * y[ceil((i + 1) / 2) - 1] ** 2 + 42 * x[i]) ** 4
    return f"
"import math

def main(z):
    r = 0
    n = len(z)
    for i in range(0, n):
        temp = 38 * pow(52 * z[i] ** 3 - 61 * z[i] - 96 * z[i] ** 2, 6)
        r += temp
    return r"
"from math import ceil

def main(y, z, x):
    n = len(y)
    res = 0
    for i in range(1, n + 1):
        res += (30 * y[n - ceil(i / 3)] ** 2 - x[n - i] - z[n - i] ** 3 / 30) ** 3
    res *= 79
    return res"
"from math import *

def main(x):
    s = 0
    n = len(x)
    for i in range(1, n + 1):
        s += pow(47 + x[n - i] + pow(x[n - 1 - i // 3], 2), 7) / 65
    return 17 * s"
"def main(y):
    res = 0
    for i in range(1, len(y) + 1):
        res += 2 * (41 * y[len(y) - i] ** 3 + 1) ** 2
    return res"
"import math

def main(x, y):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        r1 = 81 * x[i - 1]
        r2 = x[math.ceil(i / 3) - 1] ** 2
        r3 = y[n - math.ceil(i / 4)] ** 3
        res += 42 * (r1 + r2 + r3) ** 7
    return res"
"import math

def main(arr):
    n = len(arr)
    sum1 = 0
    for i in range(1, n + 1):
        sum1 += pow(pow(arr[i - 1], 3) - pow(arr[n + 1 - i - 1], 2), 4)
    return sum1"
"import math

def main(x, y, z):
    f = 0
    n = len(x)
    z.insert(0, 0)
    z.insert(1, 0)
    for i in range(1, n + 1):
        f += 2 * (71 * z[n + 1 - (i - 1) // 2] + y[i - 1] ** 3 + 91 * x[(i - 1) // 4] ** 2) ** 5
    return f"
"def main(x, y):
    h = 0
    n = 2
    for i in range(n + 1):
        h += 56 * (y[i] + y[n - i] ** 3 + 87 * x[n - i] ** 2) ** 6
    return 76 * h"
"import math

def main(x):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        a = x[n - math.ceil(i / 2)] ** 3 / 2
        b = x[n - i] ** 2
        c = x[i - 1]
        res += 57 * (a - b - c) ** 6
    res = 28 * res
    return res"
"import math

def main(z, x, y):
    f = 0
    n = len(x) - 1
    for i in range(0, n + 1):
        f += math.atan(z[n - math.floor(i / 2)] + 29 * y[i] ** 2 + x[i] ** 3) ** 5
    return f * 28"
"import math

def f(z, x):
    a = 0
    n = len(z)
    for i in range(0, n):
        a += 4 * math.sin(11 * z[n - 1 - i] - z[n - 1 - i] ** 2 - x[i // 2] ** 3) ** 7
    return 15 * a

def main(*args):
    return f(*args)"
"def main(x, y):
    s = 0
    n = len(x)
    for i in range(len(x)):
        s += y[i // 2] ** 3 - 10 * x[n - 1 - i] - y[i // 2] ** 2 / 17
    return s"
"from math import cos
from math import ceil

def main(x):
    n = len(x)
    sum = 0
    for i in range(1, n + 1):
        sum += 83 * cos(x[n + 1 - ceil(i / 4) - 1]) ** 7
    return sum"
"import math

def main(z, y):
    sum = 0
    n = len(y)
    i = 1
    while i <= n:
        a = y[n - math.ceil(i / 2)]
        sum += (36 * a ** 2 - z[n - i] - 77) ** 5
        i += 1
    return 29 * 76 * sum"
"import math

def main(x, y):
    z = 0
    z1 = 0
    for i in range(len(x)):
        z = (61 * x[len(x) - 1 - i] ** 3 + y[i] ** 2 + 37 * x[i // 3]) ** 2
        z1 += z
    return z1"
"import math

def main(y, x, z):
    n = len(y) - 1
    result = 0
    for i in range(1, n + 2):
        A = z[math.ceil((i - 2) / 2)] ** 2 - y[n + 1 - math.ceil(i / 2)]
        B = 37 * x[n + 1 - math.ceil(i / 3)] ** 3
        result += 30 * (A - B) ** 2
    return result
main([0.08, 0.82, 0.05, -0.85, -0.65, 0.35, -0.82, 0.51], [0.24, 0.19, 0.99, 0.56, -0.81, 0.76, -0.68, -0.08], [0.11, -0.74, 0.43, 0.86, -0.91, -0.56, 0.07, -0.31])
main([0.6, -0.6, -0.13, -0.61, -0.62, -0.77, -0.33, -0.17], [-0.47, 0.81, -0.9, 0.18, 0.28, 0.55, 0.09, 0.53], [-0.7, 0.84, 0.63, 0.39, 0.66, 0.74, 0.07, 0.01])"
"import math

def main(x, z):
    result = 0
    n = len(x) - 1
    for i in range(0, n + 1):
        a = z[n + 1 - math.ceil((i + 1) / 3)] ** 2 - 54 * x[n + 1 - (i + 1)]
        result += 34 * math.atan(a) ** 7
    return result * 13
main([-0.18, 0.91, -0.21, 0.31, -0.71, 0.31, 0.37, 0.89], [-0.18, -0.14, 0.03, -0.13, 0.36, -0.55, -0.4, 0.42])
main([0.45, -0.73, 0.28, -0.18, 0.26, -0.11, -0.25, 0.16], [0.86, 0.65, 0.22, 0.79, -0.39, 0.02, 0.47, 0.97])"
"import math

def f(z, y, x):
    result = 0
    n = len(x) - 1
    for i in range(0, n + 1):
        a = y[i] ** 2
        b = 29 * z[n + 1 - math.ceil((i + 1) / 2)]
        c = x[math.ceil((i - 2) / 3)] ** 3
        result += 80 * (a + b + c) ** 4
    return result * 71

def main(z, y, x):
    return f(z, y, x)"
"import math

def main(x, y):
    res = 0
    n = len(x) - 1
    for i in range(1, n + 2):
        p = x[n + 1 - math.ceil(i / 4)]
        o = y[n + 1 - i]
        res = res + pow(math.log10(82 - p - pow(o, 3) / 32), 7) / 42
    return 67 * res"
"def main(x, y, z):
    s = 0
    n = len(x)
    for i in range(len(x)):
        s += (83 * z[n - 1 - int(i / 2)] + x[int(i / 2)] ** 3 + 60 * y[i] ** 2) ** 6 / 45
    return s"
"def main(y, x):
    f = 0
    n = len(y)
    for i in range(1, n + 1):
        f += 70 * (x[i - 1] ** 3 + y[i - 1] ** 2 + 1) ** 5
    return f"
"import math

def main(x, y, z):
    res = 0
    n = len(x) - 1
    for i in range(1, n + 2):
        res += pow(math.floor(45 * pow(z[i - 1], 3) + pow(x[n + 1 - i], 2) / 91 + y[i - 1]), 3)
    return res"
"import math

def main(arr):
    f = 0
    n = len(arr)
    for i in range(1, n + 1):
        f += 6 * (81 * math.fabs(arr[n - math.ceil(i / 4)]) ** 2) ** 7
    return f"
"import math

def main(y, x, z):
    f = 0
    n = len(x)
    for i in range(1, n + 1):
        f += (62 * x[len(x) - math.ceil(i / 3)] ** 2 + z[len(z) - i] ** 3 + y[i - 1]) ** 7 / 57
    f *= 8
    return f"
"def main(y, z, x):
    n = 3
    i = 0
    k = 0
    for i in range(n):
        k = k + (22 * y[i] + x[n - 1 - i] ** 3 + 25 * z[i] ** 2) ** 5
    return k"
"def main(x):
    _sum = 0
    _sum += 30 * (96 + 97 * x[1] ** 2 + 97 * x[1]) ** 7
    _sum += 30 * (96 + 97 * x[2] ** 2 + 97 * x[2]) ** 7
    _sum += 30 * (96 + 97 * x[2] ** 2 + 97 * x[2]) ** 7
    return _sum * 6"
"import math

def main(vector):
    a = 0
    for i in range(1, len(vector) + 1):
        b = 1 if round(i / 4) == i / 4 else 0
        a += (29 + 89 * vector[b] ** 2 + vector[b]) ** 4
    return a * 35"
"import math

def main(y, x, z):
    value = 0
    n = len(y)
    for i in range(0, n):
        num = math.pow(x[n - i - 1], 2) + 78 * math.pow(y[math.ceil((i + 1) / 4 - 1)], 3)
        value += num + 62 * z[math.ceil((i + 1) / 2 - 1)]
    return 72 * value"
"import math

def main(y):
    _sum = 0
    n = len(y)
    for i in range(1, n + 1):
        v1 = 31 * y[int(n - 1 + 1 - math.ceil(i / 4))]
        v2 = 11 * math.pow(y[int(n - 1 + 1 - math.ceil(i / 2))], 3)
        _sum += math.pow(v1 + 1 + v2, 4)
    return _sum"
"import math

def main(x, y):
    s = 0
    for i in range(1, len(x) + 1):
        t3 = math.ceil(i / 3)
        t4 = math.ceil(i / 4)
        s += math.log(y[t4 - 1] ** 3 + 34 * y[len(x) - t3] ** 2 + x[i - 1] / 77) ** 5
    return 78 * s"
"def main(z, x):
    res = 0
    for i in range(0, len(x)):
        res += (18 - x[len(x) - 1 - int(i / 4)] ** 2 - 85 * z[i]) ** 2
    return res"
"import math

def main(x):
    ans = 0
    n = len(x)
    for i in range(n):
        ans += (1 - x[n - 1 - i] ** 2 - x[n - 1 - i]) ** 1.5 / 32
    return ans * 96
main([0.06, -0.62, 0.17, -0.02, -0.33])"
"import math

def main(z, y):
    res = 0
    for i in range(0, 3):
        res += pow(math.sin(pow(y[i // 4], 2) + pow(z[i // 4], 3) + 86 * z[i]), 3)
    return res"
"def main(y, z):
    res = 0
    n = len(y)
    for i in range(1, n + 1):
        res += (z[n - i] ** 3 + 0.02 + y[i - 1] / 18) ** 7
    return res * 84"
"from math import ceil

def main(y):
    n = len(y)
    res = 0
    for i in range(n):
        res += 43 * (y[n - i - 1] ** 2 - 91 * y[ceil(i // 4)] ** 3) ** 2
    return res"
"import math

def main(x):
    n = len(x)
    sum = 0
    for i in range(0, n):
        sum += 94 * math.sin(28 * x[n - 1 - i] ** 3 + 95 * x[i // 3] ** 2 + x[i // 3]) ** 6
    return sum
main([0.51, 0.38, 0.26, -0.75, -0.37, 0.05])"
"import math

def main(z):
    ans = 0
    n = len(z)
    for i in range(n):
        ans += (z[n - 1 - i] ** 2 - 1 - z[i // 4]) ** 7
    return ans
main([0.65, 0.43])"
"from math import ceil

def main(y, z, x):
    res = 0
    for i in range(1, 8):
        res += pow(53 * pow(x[ceil(i / 4) - 1], 2) - 93 * pow(z[7 - i], 3) - 29 * y[i - 1], 6)
    return res"
"from math import log10, ceil

def main(y, z, x):
    result = 0
    n = len(y)
    for i in range(1, n + 1):
        result += log10(x[i - 1] + z[n - ceil(i / 2)] ** 3 + 96 * y[ceil(i / 3) - 1] ** 2) ** 3
    return 19 * result"
"from math import sin

def main(z, x, y):
    res = 0
    n = len(x)
    for i in range(0, n):
        x3 = x[i] * x[i] * x[i]
        y0 = y[n - 1 - int(i / 3)]
        res += 90 * pow(sin(x3 / 13 + z[i] + y0 * y0), 7)
    return 77 * res"
"import math

def main(y):
    f = 0.0
    n = len(y)
    for i in range(n):
        f += (67 * y[n - 1 - i] - 81 * y[i // 2] ** 3) ** 5
    return f"
"from math import ceil

def main(z, x):
    sum = 0
    n = len(z)
    for i in range(1, n + 1):
        p = z[n - ceil(i / 3)]
        a = 29 * p ** 2
        b = 17 * x[i - 1] ** 3
        sum += 37 * (a - b - p) ** 6
    return sum"
"import math

def main(z):
    result = 0
    for i in range(0, len(z)):
        result += (1 + 52 * z[i] + z[i] ** 3) ** 2
    return 95 * result"
"def main(z):
    summa = 0
    for i in range(0, len(z)):
        summa += (1 + 52 * z[i] + z[i] ** 3) ** 2
    return summa * 95"
"import math

def main(z, y, x):
    result = 0
    for i in range(0, len(z)):
        y1 = y[math.floor(i / 4)] ** 3
        x1 = x[math.floor(i / 4)]
        result += 67 * (47 * x1 - y1 / 79 - z[i] ** 2)
    return result"
"import math

def main(y, z):
    res = 0
    n = len(y)
    for i in range(n):
        res += 53 * math.sin(z[n - 1 - i // 3] + y[i] ** 2 / 8 + y[i] ** 3) ** 7
    return res"
"import math

def main(z, y, x):
    n = len(z)
    result = 0
    for i in range(1, n + 1):
        support = 95 * z[n - math.ceil(i / 3)] ** 2
        support1 = x[n - i] ** 3
        support2 = 24 * y[n - math.ceil(i / 3)]
        result += 78 * math.log(support - support1 - support2, 10) ** 5
    return result"
"import math

def main(x, z):
    res = 0
    n = len(x) - 2
    for i in range(0, n + 2):
        p = x[n + 1 - i]
        o = z[i]
        res += (p ** 3 + o ** 2 + 1) ** 2
    return 13 * res"
"import math

def main(vec1, vec2):
    result = 0
    for i in range(1, len(vec1) + 1):
        result += (82 * vec2[i - 1] ** 3 - 0.02 - vec1[math.ceil(float(i) / 3) - 1] ** 2) ** 7
    return result"
"import math

def main(x, z, y):
    f = 0
    n = len(x)
    for i in range(1, n + 1):
        a = y[n - math.ceil(i / 3)] / 46
        b = z[n - i] ** 3
        c = 10 * x[n - math.ceil(i / 4)] ** 2
        f += (a + b + c) ** 7
    return f * 50"
"from math import exp

def main(y_vec):
    return sum([99 * exp(y_vec[len(y_vec) - i // 4 - 1]) ** 3 for i in range(len(y_vec))])"
"def main(x):
    result = 0
    n = len(x)
    for i in range(0, n):
        result += (x[n - 1 - i] / 83 + x[i] ** 3) ** 7
    return 44 * result
main([0.71, -0.06])"
"import math

def main(z, y, x):
    sum = 0
    j = 0
    k = 0
    for i in range(0, 6):
        if i == 2:
            k = 1
        if i == 4:
            j = 1
            k = 2
        sum += 78 * math.sin(79 * x[i] ** 2 + z[j] + 35 * y[k] ** 3) ** 6
    return sum * 85
main([-0.57, -0.23, 0.68, 0.43, -0.98, 0.03], [-0.2, -0.32, -0.73, -0.13, 0.63, 0.03], [-0.79, -0.57, 0.24, -0.63, -0.89, -0.16])
main([-0.94, -0.16, 0.62, 0.7, 0.78, -0.75], [0.67, 0.28, -0.29, -0.55, 0.95, 0.94], [-0.48, 0.42, 0.93, 0.92, -0.38, 0.47])"
"def main(y):
    s = 0
    n = len(y)
    for i in range(0, n):
        s += (98 * y[i] - 39 * y[i] ** 3 - 44) ** 4
    return s
main([-0.19, 0.35, -0.05, 0.55, -0.96, 0.07])"
"import math

def main(x, y, z):
    summa = 0.0
    n = len(x)
    for i in range(1, n + 1):
        summa = summa + pow(27 * pow(z[i - 1], 2) - 69 * x[n + 1 - math.ceil(i / 3) - 1] - pow(y[n + 1 - math.ceil(i / 2) - 1], 3), 5) / 54
    return summa"
"import math

def main(n):
    sun = 0
    y = len(n)
    for i in range(1, y + 1):
        sun += math.pow(1 + 41 * math.pow(n[y - i], 3) + 34 * math.pow(n[y - i], 2), 4) / 55
    return 54 * sun"
"import math

def main(x):
    n = len(x) - 1
    res = 0
    for i in range(1, n + 2):
        res += math.cos(x[n + 1 - math.ceil(i / 4)] ** 2) ** 7
    return res
main([-0.9, -0.59, 0.56, 1.0, 0.99, 0.04])"
"import math

def main(arr_y, arr_x):
    res = 0
    n = len(arr_x)
    for i in range(1, n + 1):
        res += pow(arr_y[n - math.ceil(i / 4)] / 62 + pow(arr_x[math.ceil(i / 2) - 1], 3) / 50, 7)
    return res"
"import math

def main(arr_x, arr_y, arr_z):
    f = 0
    n = len(arr_x)
    for i in range(1, n + 1):
        f += pow(math.floor(62 * arr_y[math.ceil(i / 2) - 1] + 71 * pow(arr_x[n - math.ceil(i / 4)], 2) + 24 * pow(arr_z[math.ceil(i / 4) - 1], 3)), 2)
    return f"
"import math

def main(z, x):
    func_value = 0
    for i in range(0, len(z)):
        func_value += math.tan(x[math.floor(i / 4)] + 26 * z[i] ** 3 + 1) ** 7
    func_value *= 30
    return func_value"
"import math
from array import *

def main(y, z):
    n = len(y)
    res = 0
    for i in range(1, n + 1):
        index = n + 1 - math.ceil(i / 3) - 1
        res += (0.02 + 53 * y[index] ** 2 + z[index]) ** 3
    return res"
"import math

def main(x, y):
    sum = 0
    n = len(x)
    for i in range(1, n + 1):
        sum += y[i - 1] + 7 * x[n + 1 - math.ceil(i / 3) - 1] ** 2 + 1
    return 32 * sum"
"import math

def main(x):
    sum = 0
    for i in range(len(x)):
        sum += math.pow(32 - 32 * math.pow(x[math.floor(i / 4)], 2) - x[math.floor(i / 4)] / 67, 2)
    return 61 * sum"
"from math import ceil

def main(x, z, y):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        s = ceil(i / 3)
        res += 6 * (41 * y[s - 1] ** 3 + 12 * x[n - i] ** 2 + 27 * z[n - s]) ** 3
    return res"
"from math import ceil

def main(x, y):
    n = len(x)
    res = 0
    for i in range(1, n + 1):
        res += (x[n - ceil(i / 3)] + y[n - i] ** 3 / 31 + 46 * y[n - i] ** 2) ** 2
    return res"
"def main(y, z):
    result = 0
    for i in range(1, len(y) + 1):
        result = result + (z[len(z) - 1 - i] / 2 + 45 + y[i - 1] ** 3) ** 4
    return result"
"import math

def main(z, x, y):
    n = len(z) - 1
    ans = 0
    d = 0
    for i in range(1, n + 1):
        a = y[math.ceil(i / 3) - 1]
        b = x[math.ceil(i / 4) - 1] ** 3 / 86
        c = z[n + 1 - math.ceil(i / 2)] ** 2
        ans += (a + b + c) ** 6 / 9
    return ans * 43 * 2"
"import math

def main(z, x, y):
    answer = 0
    for i in range(0, len(z)):
        answer += (63 * y[len(z) - 1 - math.floor(i / 4)] ** 3 - 13 * z[i] ** 2 - x[len(z) - 1 - math.floor(i / 4)]) ** 4 / 54
    return answer"
"import math

def main(x):
    result = 0
    n = len(x)
    for i in range(1, n + 1):
        result += (x[n - i] ** 3 + x[math.ceil(i / 4) - 1] ** 2 + 0.02) ** 5
    return result"
"import math

def main(z):
    s = 0
    n = len(z)
    for i in range(n):
        s += abs(z[n - math.ceil((i + 1) / 2)] ** 3) / 52
    return s"
"from math import *

def main(y, x):
    n = len(x)
    result = 0
    for i in range(n):
        result += (y[i] ** 3 + 81 * x[n - 1 - i] + 98 * x[n - 1 - i] ** 2) ** 6
    return 90 * result"
"import math

def main(z, x, y):
    n = len(y)
    f = 0
    for i in range(1, n + 1):
        f += 94 * (x[n + 1 - i - 1] - 12 * z[i - 1] ** 2 - 16 * y[i - 1] ** 3) ** 7
    return f"
"import math

def main(x, y, z):
    n = len(x)
    result = 0
    for i in range(1, n + 1):
        result += 61 * 33 * (x[i - 1] ** 2 / 45 + 7 * z[math.ceil(i / 4 - 1)] ** 3 + y[n - i]) ** 2
    return result"
"def main(x, z, y):
    n = len(x)
    a = 0
    for i in range(1, n + 1):
        a += 81 * (98 * x[i - 1] + z[i - 1] ** 2 / 87 + y[n - i] ** 3) ** 6
    return a"
"import math

def main(y):
    summ = 0
    for i in range(len(y)):
        summ += 5 * (44 * y[i // 4] - 76 * y[i // 4] ** 2) ** 2
    return 59 * summ"
"import math

def main(z, x):
    f = 0
    for i in range(1, len(z) + 1):
        f += 3 * (z[math.ceil(i / 4 - 1)] ** 3 - 42 * x[math.ceil(i / 3 - 1)]) ** 2
    return f * 63"
"import math

def main(z, y):
    result = 0
    n = len(z)
    for i in range(1, n + 1):
        result += 44 * math.log2(90 * y[n - i] ** 2 + 37 * z[n - math.ceil(i / 4)] ** 3) ** 6
    return result"
"def main(x, y):
    result = 0
    n = len(x)
    for i in range(n):
        result += (x[i] ** 3 + y[n + 1 - 2 - i // 3] ** 2 + 60 * x[n + 1 - 2 - i]) ** 6
    result *= 96
    return result"
"import math

def main(z, x, y):
    n = len(z)
    res = 0
    for i in range(1, n + 1):
        el1 = 15 * math.pow(y[math.ceil(i / 3) - 1], 2)
        el2 = 77 * x[n + 1 - math.ceil(i / 3) - 1]
        el3 = math.pow(z[n + 1 - math.ceil(i / 3) - 1], 3)
        res += 4 * math.pow(el1 + el2 + el3, 4)
    return res"
"import math

def main(z):
    result = 0
    n = len(z) - 1
    for i in range(0, n + 1):
        result += pow(pow(z[i], 3) + 1 + pow(z[i], 2), 4)
    return 70 * result"
"def main(x=set()):
    f = 0
    for n in x:
        f += 5 * (98 * n ** 2 - 82 - n ** 3) ** 4
    return f"
"import math

def main(list1, list2):
    n = len(list1)
    result = 0
    for i in range(1, n + 1):
        result = result + 31 * (list1[n - i] - 20 * pow(list1[n - i], 2) - pow(list2[n - math.ceil(i / 3)], 3))
    result = result * 33
    return result"
"import math

def main(y, z):
    result = 0
    for i in range(1, len(z) + 1):
        result = result + 7 * math.atan(y[len(y) - i] ** 2 / 59 + z[math.ceil(i / 2) - 1] + 0.03) ** 6
    return 59 * result"
"def main(z, x):
    n = len(z)
    res = 0
    for i in range(1, n + 1):
        res += (z[n + 1 - i - 1] ** 2 + 18 * x[i - 1]) ** 2
    return res"
"import math

def main(x, y):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res += pow(1 + 20 * pow(y[n - i], 3) + x[n - i], 2)
    return res"
"from math import ceil

def main(y, z, x):
    res = 0
    n = 5
    for i in range(1, n + 2):
        a = x[n + 1 - i] ** 3 / 2
        b = 90 * y[n + 1 - ceil(i / 4)]
        c = 26 * z[n + 1 - i] ** 2
        res += (a - b - c) ** 3
    return res
main([0.59, 0.2, -0.23, -0.11, -0.12, -0.7], [0.79, -0.08, -0.86, -0.5, -0.31, 0.43], [-0.54, 0.36, 0.81, 0.99, -0.47, -0.56])"
"import math
import array

def f5(list: array):
    s = 0
    for i in range(len(list)):
        s += math.cos(0.5 - list[len(list) - math.ceil((i + 1) / 4)] ** 3) ** 6
    return 98 * s

def main(n):
    return f5(n)"
"import math

def main(x, z, y):
    n = len(x)
    result = 0
    for i in range(1, n + 1):
        result += x[math.ceil(i / 4) - 1] ** 2 - 2 * y[math.ceil(i / 3) - 1] - 6 * z[i - 1] ** 3
    return 64 * 45 * result"
"def main(z):
    res = 0
    n = len(z)
    for i in range(n):
        res += (5 * z[i // 4] ** 2 + z[i // 4] ** 3) ** 7
    return res"
"import math

def main(z, x):
    n = len(z)
    ans = 0
    for i in range(1, n + 1):
        ans += 21 * (z[n - math.ceil(i / 2)] ** 2 / 38 - x[n - i] - 80 * z[n - math.ceil(i / 2)] ** 3) ** 3
    return ans"
"def main(x, y):
    res = 0
    n = len(x)
    for i in range(n):
        res += 84 * (1 + y[i // 4] ** 3 + x[i // 4] ** 2) ** 4
    return res"
"from math import ceil

def main(massive):
    n = len(massive)
    result = 0
    for i in range(1, n + 1):
        result = result + 48 * (79 + massive[n + 1 - ceil(i / 2) - 1] / 14) ** 4
    return result"
"import math

def main(y):
    n = len(y)
    result = 0
    for i in range(1, n + 1):
        result += 10 - y[n - i] - 63 * y[n - i] ** 3
    return 54 * result"
"from math import *

def main(x, y):
    n = len(y)
    result = 0
    for i in range(n):
        result += abs(73 * x[i] ** 3 + 94 * y[n - 1 - i] ** 2) ** 4 / 54
    return 49 * result"
"import math

def main(z, y, x):
    n = len(z)
    sum = 0
    for i in range(1, n + 1):
        sum = sum + math.sin(y[math.ceil(i / 3) - 1] ** 3 / 19 + x[i - 1] ** 2 + z[n - i]) ** 5
    return sum"
"def main(y):
    n = len(y)
    sum1 = 0
    for i in range(n):
        sum1 += (32 * y[i] ** 3 - 55 * y[i] ** 2 - 1) ** 6
    return sum1"
"import math

def main(z, x, y):
    n = len(z)
    sum_result = 0
    for i in range(1, n + 1):
        sum_result += 78 * (23 * y[n - i] ** 2 - 97 * z[i - 1] ** 3 - 15 * x[n - math.ceil(i / 2)])
    return 58 * sum_result"
"import math

def main(y, x):
    sum = 0
    n = len(x)
    for i in range(1, n + 1):
        sum += (x[n - math.ceil(i / 3)] + 26 * x[i - 1] ** 3 + 54 * y[math.ceil(i / 3) - 1] ** 2) ** 7
    return sum"
"import math

def main(x):
    n = len(x)
    result = 0
    for i in range(1, n + 1):
        result += math.asin(x[n - math.ceil(i / 2)]) ** 7 / 43
    return result"
"import math

def main(z, x):
    ans = 0
    n = len(x)
    for i in range(1, n + 1):
        sk1 = 69 * x[math.ceil(i / 2) - 1] ** 3
        sk2 = z[n - math.ceil(i / 3)] ** 2
        ans += 48 * (sk1 + sk2)
    ans = 84 * ans
    return ans"
"import math

def main(x, z):
    answer = 0
    n = len(x)
    for i in range(1, n + 1):
        answer += 62 * (24 * z[i - 1] + x[n - math.ceil(i / 2)] ** 3) ** 6
    return answer * 36"
"import math

def main(y, z):
    x = 0
    for i in range(0, len(z)):
        x = x + 41 * math.cos(z[int(i / 2)] ** 3 - 85 - 26 * y[int(i / 2)]) ** 7
    return x"
"import math

def main(z):
    answer = 0
    n = len(z)
    for i in range(1, n + 1):
        answer += (1 + 19 * z[n - math.ceil(i / 4)]) ** 3 / 73
    return answer"
"def main(z, y, x):
    from math import tan
    n = len(x)
    ans = 0
    for i in range(1, n + 1):
        ans += 24 * tan(42 * z[(i - 1) // 4] ** 3 + y[i - 1] / 61 + x[n + 1 - i - 1] ** 2) ** 5
    return 42 * ans"
"from math import ceil

def main(y):
    n = len(y)
    a = 0
    for i in range(1, n + 1):
        a += (y[n - ceil(i / 2)] + 48 * y[i - 1] ** 2) ** 7 / 94
    return 73 * a"
"from math import ceil
from math import log

def main(x, z, y):
    res = 0
    n = 3
    for i in range(1, n + 2):
        b = 11 * z[i - 1]
        c = x[ceil((i - 2) / 2)] ** 2
        d = y[n + 1 - ceil(i / 2)] ** 3
        res += 35 * log(b - c - d, 10) ** 5
    return res
main([-0.39, -0.32, 0.85, 0.38], [0.03, 0.23, 0.29, 0.23], [0.52, -0.53, -0.67, 0.29])"
"import math

def main(y, x, z):
    sum = 0
    n = len(x)
    for i in range(1, n + 1):
        sum += (54 * y[n - i] ** 2 + 8 * x[math.ceil(i / 4) - 1] + z[math.ceil(i / 2) - 1] ** 3) ** 3
    return sum"
"import math

def main(x, y):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        r1 = 10
        r2 = 40 * x[math.ceil(i) - 1] ** 2
        r3 = y[math.ceil(i / 4) - 1] ** 3
        res += 63 * (r1 + r2 + r3) ** 5
    return 94 * res"
"def main(y):
    res = 0
    for i in range(1, len(y) + 1):
        res += (99 - y[len(y) - i] ** 3 - y[len(y) - i] ** 2) ** 7
        res1 = 68 * res
    return res1
main([-0.32, -0.04])"
"def main(y):
    res = 0
    for i in range(1, len(y) + 1):
        res += (99 - y[len(y) - i] ** 3 - y[len(y) - i] ** 2) ** 7
        res1 = 68 * res
    return res1
main([-0.32, -0.04])"
"from math import ceil, atan

def main(z):
    n = len(z)
    result = 0
    for i in range(1, n + 1):
        result += 9 * pow(atan(z[n - ceil(i / 3)]), 2)
    return result * 82"
"import math

def main(arr):
    res = 0
    n = len(arr)
    for i in range(1, n + 1):
        x = arr[n + 1 - math.ceil(i / 4) - 1]
        res += (33 * x ** 2 + x ** 3 + 59 * x) ** 6
    return 47 * res"
"import math

def main(y, z):
    answer = 0
    n = len(y)
    for i in range(1, n + 1):
        answer += 76 * (14 * z[n - i] ** 3 + y[n - i]) ** 4
    return answer * 59"
"from math import ceil as m

def main(z):
    f = 0
    n = len(z)
    for i in range(1, n + 1):
        f += 61 * m(z[n + 1 - m(i / 3) - 1] ** 3 / 2 + 15 * z[m(i / 2) - 1] ** 2 + 1) ** 3
    return f"
"def main(x, y):
    n = len(x)
    sum = 0
    for i in range(n):
        sum += (y[i // 2] ** 3 / 48 + 82 + 73 * x[i]) ** 4
    return 40 * sum"
"import math

def main(x, y, z):
    n = len(x)
    res = 0
    for i in range(n):
        res += z[math.ceil((i + 1) / 4) - 1] ** 3
        res += y[n + 1 - (i + 2)]
        res += x[i] ** 2
    return 94 * res"
"def main(y, z):
    n = len(y)
    f = 0
    for i in range(1, n + 1):
        f += z[i - 1] - 45 * y[n + 1 - i - 1] ** 2
    return f"
"from math import atan, ceil

def main(x: []):
    result = 0
    n = len(x)
    for i in range(1, n + 1):
        result += atan(x[ceil(i / 4 - 1)] ** 3 / 62 - 25 * x[ceil(i / 3 - 1)] - 24) ** 3
    return result"
"import math

def main(y):
    result = 0
    n = len(y)
    for i in range(0, n):
        result += math.log2(y[i] ** 3 / 70 + 99 * y[n - 1 - math.trunc(i / 4)]) ** 3
    return 3 * result"
"import math

def main(x, z, y):
    res = 0
    n = 6
    for i in range(1, n):
        res += (x[5 + 1 - math.ceil(i / 4) - 1] - 86 * z[math.ceil(i / 4) - 1] ** 3 - y[math.ceil(i / 3) - 1] ** 2) ** 7 / 66
    res *= 67
    return res"
"import math as m

def main(z, y, x):
    n = len(z)
    s = 0
    for i in range(1, n + 1):
        s += 81 * 81 * m.cos(y[n - m.ceil(i / 4)] ** 3 + 60 * z[n - m.ceil(i / 4)] ** 2 + 82 * x[m.ceil(i / 4 - 1)]) ** 7
    return s"
"import math

def main(x):
    f = 0
    if not isinstance(x, list):
        x = [x]
    for i in range(1, len(x) + 1):
        f += math.asin(x[len(x) - 1 + 1 - math.ceil(i / 4)] ** 2) ** 4
    return f"
"import math

def main(x, z, y):
    n = len(x)
    res = 0
    for i in range(n):
        res += 89 * (50 * z[n - math.ceil((i + 1) / 4)] ** 2 - 54 * x[n - math.ceil((i + 1) / 3)] ** 3 - 93 * y[i]) ** 6
    return res"
"import math

def main(x):
    s = 0
    n = len(x)
    for i in range(1, n + 1):
        s += math.sin(x[n - math.ceil(i / 3)] ** 2 / 99 + x[n - math.ceil(i / 3)] ** 3 / 30 + x[n - i]) ** 3
    return s"
"import math

def main(y, x, z):
    result = 0
    n = len(z)
    for i in range(1, n + 1):
        var1 = 93 * z[n - math.ceil(i / 4)] ** 2
        var2 = 55 * x[math.ceil(i / 4) - 1] ** 3
        var3 = 55 * y[n - i]
        result += (var1 + var2 + var3) ** 3
    return 60 * result"
"def main(x, y, z):
    sum = 0
    n = len(x)
    for i in range(1, n + 1):
        sum += (82 * y[n - i] ** 2 + z[i - 1] / 71 + x[i - 1] ** 3) ** 4
    return sum"
"import math

def main(x):
    result = 0
    n = len(x)
    for i in range(1, n + 1):
        result += abs(x[n - i] - x[math.ceil(i / 4) - 1] ** 2 - x[math.ceil(i / 4) - 1] ** 3) ** 7
    return 96 * 38 * result"
"import math

def main(x, z):
    sum = 0
    n = len(x)
    for i in range(1, n + 1):
        sum += 69 * math.exp(z[n - i] ** 2 + 47 * x[i - 1] ** 3 + 41)
    return sum"
"import math

def main(y, x, z):
    n = len(y)
    result = 0
    for i in range(1, n + 1):
        result += (59 * z[math.ceil(i / 4 - 1)] ** 3 - 42 * y[i - 1] - x[i - 1] ** 2) ** 2
    return 46 * result"
"import math

def main(vector):
    n = len(vector)
    vector.insert(0, 0)
    temp_sum = 0
    for i in range(1, n + 1):
        arg1 = pow(vector[n + 1 - math.ceil(i / 3)], 3)
        arg2 = pow(vector[n + 1 - i], 2)
        temp_sum += 3 * pow(arg1 + arg2 + 60, 5)
    return temp_sum"
"import math

def main(z, x, y):
    summ = 0
    for i in range(8):
        summ += 73 * math.cos(y[i] ** 2 - x[i] - 51 * z[6 + 1 - i] ** 3) ** 5
    return summ"
"import math

def main(z):
    x = 0
    n = len(z)
    for i in range(n):
        x += 39 * z[math.ceil((i + 1) / 4) - 1] ** 2 + 47 * z[math.ceil((i + 1) / 3) - 1]
    return x"
"import math

def main(y):
    res = 0
    n = len(y) - 1
    for i in range(1, n + 2):
        p = y[n + 1 - math.ceil(i / 3)]
        res += p ** 3 / 77
    return res"
"from math import ceil

def main(x, y, z):
    n = len(y)
    f = 0
    for i in range(1, n + 1):
        f += 62 * (z[i - 1] + y[ceil(i / 4) - 1] ** 2 + x[n + 1 - i - 1] ** 3) ** 4
    return f"
"import math

def main(x, z):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res += 17 * 11 * (x[n - i] ** 2 - 69 - z[math.ceil(i / 4 - 1)]) ** 2
    return res"
"import math

def main(y, z):
    sum = 0
    n = len(y)
    for i in range(1, n + 1):
        sum += (y[i - 1] ** 3 + 0.01 + z[n + 1 - i - 1] ** 2) ** 4
    return 87 * sum"
"import math

def main(lst):
    s = 0
    for i in range(0, len(lst)):
        s += pow(math.log10(62 * pow(lst[i], 3) + 85 + lst[i] / 98), 5)
    return 18 * s"
"import math

def main(x):
    res = 0
    for i in range(len(x)):
        res += 10 * math.sin(x[len(x) - math.ceil((i + 1) / 4)]) ** 4
    return res"
"import math

def main(x, z):
    sum1 = 0
    sum1 += 23 * (92 + 64 * z[2] ** 3 + x[2] / 93) ** 2
    sum1 += 23 * (92 + 64 * z[2] ** 3 + x[1] / 93) ** 2
    sum1 += 23 * (92 + 64 * z[1] ** 3 + x[0] / 93) ** 2
    return sum1"
"def main(z):
    res = 0
    for i in range(len(z)):
        res += (5 * z[i] + z[i // 4] ** 3 + 64) ** 3
    res *= 94
    return res"
"def main(y):
    s = 0
    for i in range(len(y)):
        s += 15 * y[len(y) - i - 1] - y[i - 1] ** 3
    return s"
"def main(x, z):
    tmp = 0
    n = len(x)
    for i in range(n):
        tmp += (7 * z[n - 1 - i] + x[i] ** 2) ** 2
    return 63 * tmp"
"from math import *

def main(y, x):
    rez = 0
    for i in range(0, len(x)):
        a = x[len(x) - 1 - i // 2] ** 2 / 50
        b = 31 * y[len(y) - 1 - i // 2] ** 3
        rez += (a - b) ** 7
    return 72 * rez.real"
"import math

def main(y, z, x):
    s = 0
    for i in range(0, len(y)):
        s += z[i] ** 3 - y[i] ** 2 / 23 - 63 * x[i // 2]
    return s"
"def main(z, y):
    answer = 0
    n = len(z)
    for i in range(1, n + 1, 1):
        elem_1 = y[i - 1]
        elem_1 = elem_1 * elem_1
        elem_2 = z[n - i]
        elem_2 = elem_2 * elem_2 * elem_2
        answer += elem_1 - 43 * elem_2 - 4 * y[n - 1 - (i - 1) // 3]
    return answer"
"def main(x):
    result = 0
    for i in range(1, len(x) + 1):
        result += 39 * (x[i - 1] ** 3 - x[i - 1] - 1) ** 3
    return 69 * result"
"import math

def main(z, y, x):
    n = len(z)
    res = 0
    for i in range(0, n):
        temp_y = y[n - 1 - i]
        temp_z = z[math.floor(i / 3)]
        temp_x = x[math.floor(i / 4)]
        temp_res = math.pow(temp_y, 2) - math.pow(temp_z, 3) - temp_x
        res += math.pow(temp_res, 3) / 70
    return float('{:.2e}'.format(res))"
"import math as m

def f(y, z):
    temp = 0
    n = len(y)
    for i in range(1, n + 1):
        temp += m.acos(y[m.ceil(i / 2) - 1] - z[n + 1 - m.ceil(i / 3) - 1] ** 3) ** 4
    return 56 * temp

def main(y, z):
    return f(y, z)"
"from math import *

def main(y, z):
    n = len(y)
    sum1 = 0
    for i in range(1, n + 1):
        sum1 += 75 * pow(96 + 94 * z[i - 1] + 90 * pow(y[i - 1], 2), 6)
    return 65 * sum1"
"import math as m

def main(a):
    b = 0
    for z in a:
        b += 13 * (71 * z ** 2 - z ** 3 / 59 - 38 * z) ** 5
    return float('{:.2e}'.format(b))"
"import math

def main(x, y):
    n = len(x)
    sum = 0
    for i in range(1, n + 1):
        sum += math.ceil(x[i - 1] ** 3 + 45 * x[n - math.ceil(i / 4)] ** 2 + y[n - math.ceil(i / 3)]) ** 5
    return 81 * sum"
"import math

def main(x, y):
    f = 0
    for i in range(len(x)):
        f = f + math.asin(y[i] ** 2 / 44 - x[i]) ** 5 / 35
    return f"
"import math

def main(y, x, z):
    f = 0
    n = len(y)
    for i in range(n):
        sum1 = 46 * x[i] * x[i] + pow(z[i], 3)
        sum2 = 35 * y[n - math.ceil((i + 1) / 2)]
        f += 59 * pow(sum1 + sum2, 4)
    return f * 51"
"import math

def main(y, z, x):
    f = 0
    n = len(x)
    for i in range(n):
        a = 2 * pow(x[n - math.ceil((i + 1) / 3)], 2)
        b = 81 * pow(z[n - math.ceil((i + 1) / 4)], 3)
        f += 5 * math.sqrt(a + b + y[i])
    return f"
"import math

def main(y, x, z):
    f = 0
    n = len(x)
    for i in range(n):
        a = 56 * y[n - (i + 1)] + 81 * pow(z[n - (i + 1)], 3)
        f += pow(math.sin(a + 29 * pow(x[n - (i + 1)], 2)), 4)
    return 28 * f"
"import math

def main(x, y, z):
    sum = 0
    n = len(x)
    for i in range(0, n):
        sum += math.cos(z[n - 1 - i] / 43 + 93 * x[i] ** 2 + y[n - 1 - i // 4] ** 3 / 52) ** 6
    return 46 * sum"
"import math
from math import cos

def main(listelem):
    result = 0
    for i in range(1, len(listelem) + 1, 1):
        result += 31 * cos(1 + 45 * pow(listelem[len(listelem) - math.ceil(i / 3)], 2))
    return result"
"import math

def main(x, z):
    r1 = 0
    x.insert(0, 0)
    z.insert(0, 0)
    for i in range(1, len(x)):
        r1 += (4 * z[math.ceil(i / 3)] + 21 * x[i] ** 3 + 66) ** 5
    return 71 * r1"
"def main(x, y, z):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res += 27 * x[int(n - i / 2)] - y[int(n - i / 4)] ** 2 - 82 * z[i - 1] ** 3
    return 71 * res"
"import math

def main(z, x, y):
    sum_ = 0
    n = len(z)
    for i in range(1, n + 1):
        sum_ += 87 * pow(z[n - math.ceil(i / 4)] - pow(y[i - 1], 3) - 83 * pow(x[n - i], 2), 7)
    sum_ *= 26
    return sum_"
"import math

def main(x, z):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res += math.asin(z[int(i / 4)] / 16 + x[int(n - i / 4)] ** 2 / 2 + 1) ** 2
    return 58 * res"
"import math

def main(y, z, x):
    sum = 0
    n = len(x)
    for i in range(0, n):
        sum += 72 * math.sin(14 * z[n - 1 - i // 4] ** 3 - y[i] ** 2 - 80 * x[n - 1 - i // 3]) ** 6
    return sum * 2"
"import math

def main(z, y, x):
    n = len(x) - 1
    S = 0
    for i in range(0, n + 1):
        S += 74 * math.asin(y[n - math.floor(i / 2)] ** 2 / 6 - z[i] ** 3 - x[i] / 14) ** 3
    return S"
"import math

def main(y):
    s = 0
    n = 1
    for i in range(0, len(y)):
        yi = y[n + 1 - int(i / 2)] ** 3
        s += (77 * yi) ** 5 / 63
    f = 58 * s
    return f"
"import math

def main(z, x):
    result = 0
    for i in range(1, len(z) + 1):
        result += math.cos(2 * z[i - 1] - 1 - x[len(x) - i] ** 2) ** 2
    return result * 26"
"import math

def main(x):
    f = 0
    for i in range(0, len(x)):
        f = f + 72 * (x[math.floor(i / 4)] / 47 - 14 * x[i] ** 3) ** 5
    return f"
"import math

def main(array):
    res = 0
    max_index = len(array) - 1
    for i in range(1, len(array) + 1):
        res += (17 * array[max_index + 1 - i] - array[max_index + 1 - math.ceil(i / 3)] ** 3) ** 6
    res *= 73
    return res"
"def main(z):
    n = len(z) - 1
    p = 0
    for i in range(1, len(z) + 1):
        p += 52 * (z[n + 1 - i] ** 2 / 45 + z[n + 1 - i] ** 3) ** 5
    return p * 36"
"import math

def main(list1, list2, list3):
    n = len(list1)
    result = 0
    for i in range(1, n + 1):
        result = result + 49 * (56 * list2[i - 1] - pow(list1[math.ceil(i / 2) - 1], 3) - 1 / 86 * pow(list3[n - i], 2)) ** 6
    result = result * 87
    return result"
"import math

def main(z):
    f = 0
    n = len(z)
    for i in range(n):
        sum1 = pow(z[i], 3)
        sum2 = 3 * pow(z[n - 1 - i], 2)
        sum3 = 10 * z[n - 1 - i]
        f += 88 * pow(sum1 + sum2 + sum3, 4)
    return f"
"import math

def main(y, x, z):
    f = 0
    n = len(y)
    f += 81 * (y[0] + 45 * z[n - 1] ** 3 + x[n - 1] ** 2) ** 5
    for i in range(1, n - 1):
        sum1 = y[math.ceil(i / 4) - 1]
        sum2 = 45 * pow(z[n - 1 - i], 3)
        sum3 = pow(x[n - math.ceil(i / 4)], 2)
        f += 81 * pow(sum1 + sum2 + sum3, 5)
    f += 81 * (y[1] + 45 * z[0] ** 3 + x[n - 2] ** 2) ** 5
    return f"
"def main(y, z, x):
    a = 0
    n = len(y)
    for i in range(n):
        a += y[i] ** 3 - 26 * x[n - 1 - i] ** 2 - 58 * z[i // 4]
    return a"
"import math

def main(y):
    f = 0
    n = 1
    for i in range(1, len(y) + 1):
        yi1 = y[int(i / 4)]
        f += 86 * math.cos(26 - yi1 - yi1 ** 3 / 29) ** 6
    return f"
"from math import ceil

def main(z):
    f = 0
    n = len(z)
    for i in range(1, n + 1):
        f += 9 * (87 * z[ceil(i / 2) - 1] ** 2 - 33 - z[ceil(i / 2) - 1] ** 3 / 37) ** 4
    return 50 * f"
"import math

def main(y):
    sum = 0
    n = len(y)
    for i in range(1, n + 1):
        sum += 91 * math.log10(y[n + 1 - math.ceil(i / 4) - 1]) ** 4
    return sum"
"def f(z, y):
    a = 0
    n = len(z)
    for i in range(0, n):
        a += 7 * (z[i] - 7 * y[n - 1 - i] ** 3)
    return a

def main(*args):
    return f(*args)"
"def main(y, z, x):
    s = 0
    n = 4
    for i in range(0, len(y)):
        xi = x[n + 1 - int(i / 3)] ** 2
        zi = z[i]
        yi = y[n + 1 - i] ** 3
        q = 27 * (49 * xi + zi + yi) ** 6
        s = s + q
    return s"
"from math import *

def main(x, z, y):
    n = len(x)
    f = 0
    for i in range(1, n + 1):
        f += 90 * (z[n + 1 - ceil(i / 4) - 1] ** 2 - y[n + 1 - ceil(i / 3) - 1] ** 3 / 57 - x[ceil(i / 4) - 1]) ** 5
    return 48 * f"
"def main(x, z, y):
    sum = 0
    n = len(x) - 1
    for i in range(0, n + 1):
        sum += (2 * x[n - i] + y[int(i // 3)] ** 2 + z[n - i] ** 3) ** 5
    return 93 * sum"
"import math

def main(y, x, z):
    sum = 0
    n = len(x)
    for i in range(1, n + 1):
        sum += (56 * x[n - math.ceil(i / 3)] ** 2 - y[n - math.ceil(i / 3)] ** 3 - z[n - math.ceil(i)]) ** 7 / 69
    return sum * 95"
"import math

def main(x, y, z):
    ans = 0
    n = len(x)
    for i in range(1, n + 1):
        a = 35 * y[n - math.ceil(i / 4)] ** 3
        b = x[i - 1] ** 2
        c = 45 * z[i - 1]
        ans += 8 * (a + b + c) ** 2
    return ans"
"import math

def main(z):
    f = 0
    n = len(z)
    for i in range(1, n + 1, 1):
        el1 = 99 + 12 * z[n - math.ceil(i / 2)]
        el2 = 61 * math.pow(z[n - math.ceil(i / 2)], 2)
        el3 = el1 + el2
        f += math.pow(el3, 2)
    return 14 * f"
"def main(y):
    res = 0
    for i in range(1, len(y) + 1):
        res += 99 * (41 * y[int((i - 1) / 2)] ** 3 + y[int((i - 1) / 2)] + 0.01) ** 4
    return res"
"import math

def main(x, y, z):
    f = 0
    n = len(y)
    f += math.exp(93 * x[0] - y[0] ** 3 - 93 * z[n - 1] ** 2) ** 3
    for i in range(1, n - 2):
        sum1 = 93 * x[math.ceil(i / 4) - 1]
        sum2 = y[i] ** 3
        sum3 = 93 * z[n - math.ceil(i / 3)] ** 2
        f += math.exp(sum1 - sum2 - sum3) ** 3
    f += math.exp(93 * x[0] - y[3] ** 3 - 93 * z[n - 2] ** 2) ** 3
    f += math.exp(93 * x[1] - y[4] ** 3 - 93 * z[n - 2] ** 2) ** 3
    return f * 71"
"import math

def main(x):
    s = 0
    for i in range(len(x)):
        s += 35 * (63 * x[i] + 31 + x[i] ** 2) ** 3
    return 78 * s"
"import math

def main(y, z, x):
    res = 0.0
    n = len(x)
    for i in range(1, n + 1):
        res += pow(2 * x[n - math.ceil(i / 3)] + pow(y[math.ceil(i / 4) - 1], 3) / 77 + pow(z[math.ceil(i / 2) - 1], 2), 6)
    return res"
"from math import *

def main(x, y):
    n = len(x)
    su = 0
    for i in range(1, n + 1):
        su += 62 * (27 * y[ceil(i / 2) - 1] + 1 + 14 * pow(x[ceil(i / 3) - 1], 3)) ** 6
    return 99 * su"
"import math

def main(x):
    f = 0
    n = len(x)
    for i in range(1, n + 1):
        f += x[n - math.ceil(i / 3)] ** 2 / 10
    return f"
"import math

def main(n):
    result = 0
    for i in range(1, len(n) + 1):
        result += pow(math.ceil(pow(n[len(n) - math.ceil(i / 3)], 3) + pow(n[len(n) - math.ceil(i / 4)], 2) + 85 * n[len(n) - math.ceil(i / 3)]), 6)
    return result"
"import math

def main(y):
    sum = 0
    n = len(y)
    for i in range(1, n + 1):
        sum += math.log(y[n - math.ceil(i / 4)] / 27 + y[math.ceil(i / 4) - 1] ** 3 + 1)
    return 88 * sum"
"import math as m

def main(x, y, z):
    res = 0
    for i in range(6):
        a = m.pow(y[m.floor(i / 2)], 2) / 45
        b = m.pow(z[i], 3) / 25
        c = 35 * x[m.floor(i / 4)]
        res += 43 * m.pow(a - b - c, 4)
    return res"
"def main(y):
    r1 = 0
    n = len(y)
    y.insert(0, 0)
    for i in range(1, len(y)):
        r1 += 28 * (57 * y[n + 1 - i] ** 3) ** 6
    return 13 * r1"
"def main(z, y):
    res = 0
    n = len(z)
    for i in range(0, n):
        res += 51 * (y[n - 1 - i] ** 2 - 45 * z[n - 1 - i] ** 3 - 57 * z[n - 1 - i // 3])
    return 77 * res"
"import math

def main(x: list):
    n = len(x)
    x.insert(0, 0)
    return 38 * sum(((26 + 65 * x[n + 1 - math.ceil(i / 3)] ** 3 + x[n + 1 - i] ** 2) ** 5 for i in range(1, n + 1)))"
"def main(y, z):
    n = len(y)
    answer = 0
    for i in range(n):
        part_1 = 57 * z[int(i / 4)] + 64 * y[n - 1 - i] ** 2
        part_2 = y[n - 1 - i] ** 3
        answer = answer + 54 * (part_1 + part_2) ** 5
    return answer * 15"
"from math import ceil

def main(y, x, z):
    n = len(y)
    res = 0
    for i in range(1, n + 1):
        res += (51 * y[n - ceil(i / 3)] ** 2 + x[i - 1] ** 3 + 37 * z[i - 1]) ** 7
    res *= 94
    return res"
"import math

def main(z):
    s = 0
    for i in range(len(z)):
        q = math.cos(z[len(z) - 1 - i] + 1 + z[len(z) - 1 - i] ** 2)
        s += q
    return s"
"from math import exp, ceil

def main(z, x, y):
    f = 0
    n = len(y)
    for i in range(1, n + 1):
        f += exp(70 * z[n + 1 - i - 1] ** 2 + 71 * x[i - 1] ** 3 + y[n + 1 - ceil(i / 2) - 1]) ** 3
    return 70 * f"
"def main(z, x):
    f = 0
    for i in range(len(z)):
        f += 94 * pow(37 * x[i] + pow(z[i], 3), 5)
    return f"
"import math

def main(z):
    counter = 0
    for i in range(0, len(z)):
        counter += 52 * (52 * z[i] ** 2 - z[round(i / 2)] / 69 - 85) ** 7
    return 49 * counter"
"from math import *

def main(x, y):
    rez = 0
    for i in range(0, len(x)):
        a = x[len(x) - 1 - i]
        b = y[ceil(i // 2)] ** 3 + y[len(y) - 1 - i] ** 2
        rez += 99 * (a - b) ** 3
    return 44 * rez.real"
"from math import sqrt

def main(x, z, y):
    sum = 0
    for i in range(1, len(x) + 1):
        d = 70 * x[i - 1] * x[i - 1] + 72 * y[i - 1] * y[i - 1] * y[i - 1]
        a = d + z[len(x) - i] / 54
        b = sqrt(a) ** 3
        c = b / 79
        sum += c
    return 77 * sum"
"from math import *

def main(y, x, z):
    res = 0
    n = len(y)
    for i in range(n):
        res = res + pow(atan(pow(x[n - 1 - i], 3) + pow(y[n - 1 - int(i / 3)], 2) + 95 * z[n - 1 - int(i / 3)]), 2)
    return res"
"import math

def main(x, y):
    s = 0
    n = 1
    for i in range(0, len(y)):
        xi1 = 75 * x[int(i / 2)] ** 2
        xi2 = x[n + 1 - i]
        yi = 37 * y[n + 1 - i] ** 3
        s += math.floor(xi1 - xi2 - yi) ** 5
        f = 49 * s
    return f"
"import math

def f(y, x):
    sum = 0
    n = len(y)
    for i in range(n):
        sum += (57 * y[n - 1 - math.floor(i / 2)] ** 2 + 62 + 80 * x[n - 1 - math.floor(i / 4)]) ** 7
    sum *= 23
    return sum

def main(y=[0.49, 0.53, 0.38, 0.28, 0.87, -0.74, 0.91], x=[0.66, 0.53, -0.2, 0.9, 0.57, -0.91, -0.96]):
    return f(y, x)"
"from math import ceil, log10

def main(z, y, x):
    n = len(z)
    a = 0
    for i in range(1, n + 1):
        a += 31 * log10(x[ceil(i / 4) - 1] ** 2 - z[n - ceil(i / 3)] ** 3 - 63 * y[n - i])
    return 92 * a"
"def main(x, z, y):
    res = 0
    for i in range(8):
        res += 18 * (x[i] ** 3 - z[i] ** 2 - y[i] / 18) ** 4
    return res"
"from math import ceil

def main(z):
    n = len(z)
    result = 0
    for i in range(1, n + 1):
        result += (z[n - ceil(i / 3)] + 79 * z[n - ceil(i / 3)] ** 2 + 79 * z[n - ceil(i / 3)] ** 3) ** 2
    return result"
"from typing import List, Union
import math

def main(y: List[Union[float, int]], z: List[Union[float, int]], x: List[Union[float, int]]):
    sum = 0
    length = len(x)
    for i in range(1, length + 1):
        sum += z[math.ceil(i / 3) - 1] + x[length - math.ceil(i / 4)] ** 3 + y[math.ceil(i / 2) - 1] ** 2
    sum *= 71 * 43
    return sum"
"from math import ceil as c, sin as s

def f(z, y, x):
    sum = 0
    n = len(z)
    for i in range(1, n + 1):
        sum += s(x[c(i / 4 - 1)] ** 2 - 87 * z[c(i / 3 - 1)] ** 3 - 68 * y[n - i]) ** 2
    return sum * 2668

def main(z=[0.64, -0.35, -0.6, -0.32], y=[0.84, 0.82, 0.11, 0.92], x=[-0.06, 0.68, 0.57, 0.48]):
    return f(z, y, x)"
"import math

def main(y):
    s = 0
    for i in range(1, len(y) + 1):
        s += math.atan(y[len(y) - math.ceil(i / 3)]) ** 7 / 93
    s *= 21
    return s"
"import array
y = [-0.5, -0.23, -0.14, 0.8, -0.64, 0.09]

def main(y):
    f = 0
    for i in range(1, len(y) + 1):
        f = f + (y[len(y) - i] - 1 - 89 * y[len(y) - i] ** 3) ** 4
    return 12 * f"
"import array
y = [-0.38, 0.59, 0.76, -0.1, -0.28, -0.57, 0.32]
z = [0.61, -0.39, 0.54, 1.0, -0.47, -0.84, 0.62]

def main(y, z):
    f = 0
    for i in range(1, len(y) + 1):
        f = f + (57 * z[len(z) - i] ** 3 + 31 + 80 * y[(i - 1) // 4] ** 2) ** 3
    return 95 * f"
"def main(y):
    res = 0
    n = len(y)
    for i in range(1, n + 1):
        res += 42 * (45 * y[n - i] ** 2 + 66 * y[n - i] + y[n - i] ** 3) ** 6
    return res"
"import math

def main(y, x, z):
    n = len(z)
    res = 0
    for i in range(1, n + 1):
        res1 = 89 * z[i - 1]
        res2 = pow(y[n - math.ceil(i / 2)], 3)
        res3 = 86 * pow(x[math.ceil(i / 2) - 1], 2)
        res += 29 * pow(res1 - res2 - res3, 5)
    return 87 * res"
"import math

def main(z, x):
    n = len(z)
    result = 0
    for i in range(n):
        result += 44 * (42 * z[i] ** 3 - 42 * x[i // 2]) ** 3
    return result"
"import math

def main(y):
    z = 0
    for i in range(len(y)):
        z += 75 * math.sin(55 * y[i // 4] + y[i // 4] ** 2 / 97) ** 4
    return 59 * z"
"import math

def main(x, y):
    f = 0
    for i in range(len(x)):
        f += math.log(17 * x[i] ** 3 - 19 * y[len(y) - 1 - i] - 1) ** 4
    return f"
"import math
from typing import List

def main(y: List[float]):
    n = len(y)
    return 80 * 86 * (n + sum([38 * y[i - 1] ** 3 + y[i - 1] for i in range(1, n + 1)]))"
"import math

def main(x, y, z):
    s = 0
    for i in range(6):
        s += 27 * pow(math.atan(8 * pow(y[i], 3) - 4 * z[i // 2] ** 2 - 93 * x[i]), 7)
    return s"
"from math import ceil

def f(x, y):
    f = float(0)
    for i in range(1, len(x) + 1):
        f += ((41 - 77 * x[len(x) - ceil(i / 3)] ** 3 - y[i - 1] ** 2) ** 0.5) ** 3 / 55
    return f

def main(arg1, arg2):
    return f(arg1, arg2)"
"def main(x, y):
    res = 0
    for i in range(1, len(y) + 1):
        res += 40 * (x[len(y) - (i + 1) // 2] ** 3 - 66 * y[len(y) - i] - 47 * y[i // 4] ** 2) ** 5
    return 50 * res"
"from math import ceil

def main(z, x, y):
    n = len(z)
    return 11 * sum([52 * (69 * y[n - ceil(i / 3)] - 99 * z[n - ceil(i / 2)] ** 3 - x[n - ceil(i / 4)] ** 2 / 99) ** 7 for i in range(1, n + 1)])"
"import math

def main(y, x):
    f = 0
    n = len(y)
    for i in range(n):
        if i % 3 == 0:
            sum1 = 12 * x[math.ceil(i / 3)] ** 2
            sum2 = 11 * y[n - 1 - i] ** 3
            f += (sum1 - sum2) ** 6
        elif i % 3 != 0:
            sum1 = 12 * x[math.ceil(i / 3) - 1] ** 2
            sum2 = 11 * y[n - 1 - i] ** 3
            f += (sum1 - sum2) ** 6
    return 69 * f"
"import math
z = []
x = []

def main(z, x):
    f = 0
    for i in range(0, len(x)):
        t = int(i / 2)
        p = int(i / 4)
        f += 75 * (1 - x[p] ** 3 - z[t] ** 2) ** 4
    f_2 = 75 * f
    return f_2"
"import math

def main(z, y):
    p = 0
    n = len(z)
    for i in range(0, n):
        p += (y[n + 1 - int(i / 2) - 2] + 1 + z[int(i / 2)] ** 2) ** 4
    return p"
"import math

def main(z, y):
    sum1 = 0
    for i in range(1, len(z) + 1):
        sum1 += (y[len(z) - math.ceil(i / 4)] ** 3 + z[math.ceil(i / 2) - 1] + 74 * z[math.ceil(i / 2) - 1] ** 2) ** 7
    return sum1"
"import math

def main(z):
    sum_i = 0
    for i in range(1, len(z) + 1):
        sum_i += (49 * z[len(z) - i] - 0.06) ** 4 / 66
    return 93 * sum_i"
"def main(x):
    b = 0
    for i in range(0, len(x)):
        b = b + (50 + x[int(i / 2)] ** 2 + 22 * x[int(i / 2)] ** 3) ** 2
    return b"
"import math

def get_value(x, i):
    return x[i - 1]

def f(x, z):
    n = len(x)
    result = 0
    for i in range(1, n + 1):
        part1 = get_value(z, n + 1 - i)
        part2 = get_value(z, n + 1 - math.ceil(i / 3)) ** 3
        part3 = 30 * get_value(x, n + 1 - math.ceil(i / 2)) ** 2
        result += (part1 + part2 + part3) ** 2
    return result

def main(x, y):
    return f(x, y)"
"def main(x, z):
    s = 0
    i = 0
    while i < len(x):
        s += (51 * z[5 - i] ** 2 - 4 - 62 * x[(i + 3) // 3 - 1]) ** 5
        i += 1
    s *= 71
    return s"
"from math import *

def main(z):
    n = len(z)
    func = 0.0
    for i in range(0, n):
        func += (49 * z[abs(int(i / 3))] - 1 - z[i] ** 2) / 4
    return 23 * func"
"import math

def main(y):
    rex3 = 0
    for i in range(0, len(y)):
        rex1 = y[int(i / 2)] / 79
        rex2 = y[int(i / 2)]
        rex3 = rex3 + 82 * pow(rex1 + 7 * pow(rex2, 2), 5)
    res = 83 * rex3
    return res"
"def main(z):
    r1 = 0
    n = len(z)
    z.insert(0, 0)
    for i in range(1, len(z)):
        r1 += (z[n + 1 - i] ** 3 / 76 + z[n + 1 - i] + 1) ** 2
    return r1"
"from math import *

def main(z, x, y):
    n = len(z)
    f = 0
    for i in range(1, n + 1):
        f += pow(92 * z[n + 1 - ceil(i / 4) - 1] + 95 * pow(y[i - 1], 2) + pow(x[n + 1 - i - 1], 3), 2)
    return f"
"import math

def main(z, y, x):
    sum = 0
    for i in range(0, len(z)):
        term = 51 * z[math.floor(i / 2)] - y[i] ** 2 / 97 - 80 * x[i] ** 3
        sum += 89 * term
    return 97 * sum"
"from math import ceil

def main(x: list, z: list):
    n = len(x)
    return 85 * sum([64 * x[n - i] - x[ceil(i / 2) - 1] ** 2 - z[n - ceil(i / 2)] ** 3 for i in range(1, n + 1)])"
"import math

def main(x):
    s = 0
    for i in range(1, len(x) + 1):
        s += (x[len(x) - math.ceil(i / 2)] ** 3 / 49) ** 4
    return 72 * s"
"import math

def main(y):
    n = len(y)
    res = 81
    res0 = 0
    for i in range(1, n + 1):
        res0 += 27 * (63 + y[n - math.ceil(i / 2)] ** 2) ** 4
    return res * res0"
"import math

def main(y, z):
    a = 0
    for i in range(0, len(y)):
        d = z[math.ceil(i / 3)] ** 2 / 81
        c = (72 - d - 52 * y[len(y) - (i + 1)]) ** 5
        a = a + 58 * c
    return a"
"from array import *
import math

def main(x):
    func = 0.0
    for i in range(1, 7):
        func += (x[math.ceil(i / 3) - 1] + x[math.ceil(i / 3) - 1] ** 2) ** 3
    return func"
"from math import *

def main(z, x):
    n = len(z)
    fun = 0
    for i in range(1, n + 1):
        fun += 46 * (x[n + 1 - ceil(i / 3) - 1] ** 2 + 36 + z[ceil(i) - 1] ** 3) ** 3
    return fun"
"import math

def main(x):
    sum = 0
    n = len(x)
    for i in range(n):
        sum += math.sin(77 * x[i] ** 2 + x[i]) ** 6
    return sum"
"def main(z, y):
    N = len(z)
    result = 0
    for i in range(N):
        result += z[i // 2] ** 3 / 66 + y[i] + 73 * y[i // 4] ** 2
    return 14 * result"
"import math

def main(y, z, x):
    n = len(x)
    result = 0
    for i in range(1, n + 1):
        a = x[math.ceil(i / 4) - 1]
        a = a / 92
        b = y[n - math.ceil(i / 3)]
        b = b ** 3
        c = z[n - i]
        c = c ** 2 / 39
        result += abs(a - b - c) ** 6
    result = 88 * result
    return result"
"from math import ceil

def main(z, x):
    n = len(z)
    result = 0
    for i in range(1, n + 1):
        result += z[n - ceil(i / 4)] ** 2 + 0.01 + 8 * x[n - ceil(i / 2)] ** 3
    return result"
"def main(z):
    x = 0
    for i in range(0, len(z)):
        x += 32 * (1 + z[i] ** 2 + z[i] ** 3) ** 7
    return x"
"import math

def main(z):
    l1 = []
    n = len(z)
    for i in range(1, n + 1):
        a = 3 * (87 + z[n + 1 - i - 1] ** 2 + 65 * z[i // 4]) ** 7
        l1.append(a)
    return 60 * math.fsum(l1)"
"import math

def main(z, y):
    n = len(z) - 1
    sum = 0
    for i in range(1, n + 2):
        sum += 62 * (62 * y[n + 1 - math.ceil(i / 4)] - 33 * z[n + 1 - i] ** 3) ** 2
    return sum"
"from math import exp, ceil

def main(x):
    n = len(x)
    sum_x = 0
    for i in range(1, n + 1):
        sum_x += 9 * exp(44 * x[n - ceil(i / 3)] ** 3 - x[i - 1] ** 2 / 58) ** 6
    return sum_x"
"import math

def main(y):
    result = 0
    n = len(y)
    for i in range(1, n + 1):
        result += 99 * math.cos(y[n + 1 - math.ceil(i / 3) - 1]) ** 2
    return result"
"from math import ceil

def main(x, z, y):
    n = len(x)
    sum_i = 0
    for i in range(1, n + 1):
        sum_i += y[ceil(i / 4) - 1] ** 2 + 79 * z[n - i] + 32 * x[n - ceil(i / 3)] ** 3
    return 68 * 65 * sum_i"
"import math

def main(z):
    s = 0
    for i in range(0, len(z)):
        s += 80 * (z[math.floor(i / 2)] ** 3 + 47 * z[math.floor(i / 3)]) ** 3
    return s"
"def round(x):
    x = float(x)
    x = x / 4
    if int(x) < x:
        return int(x + 1)
    else:
        return int(x)

def main(z, x):
    sum = 0
    n = len(z)
    for i in range(1, n + 1):
        sum = sum + 20 * (1 + 19 * z[round(i) - 1] ** 2 + 33 * x[n - i]) ** 2
    return sum"
"import math

def main(z, x):
    s = 0
    n = len(z)
    for i in range(1, n + 1):
        s = s + math.sin(z[math.ceil(i / 2) - 1] ** 2 - x[n + 1 - math.ceil(i / 2) - 1] ** 3) ** 6
    return s"
"import math

def main(y, z):
    sum = 0
    for i in range(1, len(y) + 1):
        sum += (z[len(z) - i] ** 2 / 66 + z[len(z) - i] + y[len(y) - math.ceil(i / 2)] ** 3) ** 5
    return sum"
"import math

def main(x, y, z):
    summ = 0
    for i in range(0, 4):
        summ += 69 * x[i] + 53 * pow(y[math.floor(i / 2)], 2) + pow(z[i], 3) / 68
    return summ"
"from math import log, ceil

def main(y, x, z):
    n = len(y)
    result = 0.0
    for i in range(1, n + 1):
        a = z[n - ceil(i / 2)] ** 2
        b = 78 * x[n - ceil(i / 3)]
        c = 75 * y[i - 1] ** 3
        result += 12 * log(a + b + c) ** 3
    return 48 * result"
"import math

def main(y):
    f = 0
    for i in range(1, 9):
        f += 31 * (y[math.ceil(i / 3) - 1] + y[math.ceil(i / 3) - 1] ** 2) ** 2
    return 90 * f"
"def main(x):
    n = len(x)
    result = 0
    for i in range(1, n + 1):
        result += 49 * (1 + 53 * x[n - i] ** 3 + x[n - i]) ** 7
    return result"
"import math

def main(y, x, z):
    f = 0
    n = 2
    for i in range(1, n + 1):
        a = y[n + 1 - math.ceil(i / 4) - 1] ** 3
        b = 26 * z[math.ceil(i / 4) - 1] ** 2
        c = 69 * x[n + 1 - math.ceil(i / 3) - 1]
        f += 93 * (a - b - c) ** 5
    return f"
"import math
from math import ceil

def main(y: list, z: list, x: list):
    g = []
    result = 0
    n = 6
    for i in range(1, n + 1):
        g.append(54 * (y[ceil(i / 2) - 1] ** 2 - 69 * x[i - 1] ** 3 - 55 * z[ceil(i / 2) - 1]) ** 5)
    result = math.fsum(g)
    return result"
"def main(x, y, z):
    sum = 0
    n = len(x)
    for i in range(n):
        sum += 8 * (z[n - i - 1] ** 3 - y[n - i - 1] ** 2 - 35 * x[int(i / 3)]) ** 3
    return sum"
"def main(y, z):
    sum = 0
    n = len(y)
    for i in range(1, n + 1):
        sum += (97 * z[n - i] ** 3 + y[n - i] ** 2 / 48 + 51) ** 4
    return 97 * sum"
"import math

def main(x, y):
    f = 0
    for i in range(0, len(x)):
        f = f + (y[i] ** 2 + 19 + 54 * x[math.floor(i / 2)] ** 3) ** 2
    return 62 * f"
"import math

def main(z):
    temp = 0
    n = len(z) - 1
    for i in range(1, n + 2):
        temp += math.log2(1 + z[n + 1 - math.ceil(i / 3)] ** 3 + 81 * z[n + 1 - i])
    temp = 33 * temp
    return temp"
"import math

def main(vector):
    summa = 0
    for i in range(0, len(vector)):
        summa += abs(63 - 60 * vector[math.floor(i / 3)] ** 3) ** 7 / 78
    return 74 * summa"
"import math

def main(z, x):
    n = len(x)
    result = 0
    for i in range(1, n + 1):
        result += 59 * (25 * x[n - i] - 37 * z[math.ceil(i / 4) - 1] ** 3 - 1) ** 3
    return result"
"import math

def main(y):
    ans = 0
    for i in range(0, len(y)):
        ans += math.floor(77 * y[len(y) - math.ceil((i + 1) / 4)] ** 2) ** 2
    return 24 * ans"
"def main(z, y):
    vector_len = len(z)
    result = 0
    for ii in range(1, vector_len + 1):
        a = y[vector_len - int((ii - 1) / 4) - 1] ** 3
        b = y[vector_len - int((ii - 1) / 4) - 1] ** 2
        c = z[int((ii - 1) / 3)]
        result += (a - b - 77 * c) ** 4
    result *= 46 * 74
    return result"
"import math

def main(z, x):
    n = len(z)
    answer = 0
    for i in range(n):
        answer += 66 * math.log(41 * z[i] + 42 * x[n - 1 - int(i / 4)] ** 2) ** 4
    return answer * 79"
"import math

def main(x, z):
    s = 0
    n = len(x)
    for i in range(1, n + 1):
        s += (62 * x[i - 1] ** 2 + z[n + 1 - math.ceil(i / 2) - 1] ** 3 + x[n + 1 - i - 1]) ** 4
    return s"
"import math

def main(x):
    sum = 0
    n = len(x)
    for i in range(n):
        sum += (49 * x[math.floor(i / 4)] ** 2 + x[math.floor(i / 4)] ** 3 + 1) ** 7
    return 5 * sum"
"import math

def main(z, y, x):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        p = x[math.ceil(i / 4) - 1]
        o = y[n + 1 - math.ceil(i / 2) - 1]
        w = z[math.ceil(i / 2) - 1]
        res = res + pow(math.log(pow(o, 2) - pow(p, 3) - w), 5) / 17
    return res"
"from math import ceil

def main(x):
    res = 0
    y = [0] * (len(x) + 1)
    for i in range(len(y)):
        if i != 0:
            y[i] = x[i - 1]
    for i in range(1, len(x) + 1):
        res += (y[ceil(i / 4)] ** 2 - 1 - 32 * y[len(x) + 1 - i] ** 3) ** 2
    return res"
"import math

def main(x):
    s = 0
    y = [0] * (len(x) + 1)
    for i in range(len(y)):
        if i != 0:
            y[i] = x[i - 1]
    for i in range(1, len(x) + 1):
        s += 44 * (10 * y[math.ceil(i / 4)] ** 2 - 30) ** 2
    return s"
"import math

def main(z):
    z.insert(0, 0)
    summa = 0
    n = len(z)
    for i in range(1, n):
        e = z[n + 1 - i - 1]
        summa = summa + math.pow(e + math.pow(e, 2) + 39, 3)
    return summa"
"import math

def main(z, y, x):
    n = len(z)
    sum = 0
    for i in range(n):
        sum += (x[int(math.floor(i / 2))] ** 2 / 23 - 35 * y[int(n - 1 - math.floor(i / 4))] ** 3 - z[int(n - 1 - math.floor(i / 4))]) ** 5
    return sum"
"import math

def main(a):
    n = len(a)
    sum1 = 0
    for i in range(n):
        sum1 += 27 * math.exp(a[n - 1 - math.floor(i / 3)]) ** 4
    return 11 * sum1"
"import math

def main(y):
    y.insert(0, 0)
    n = len(y)
    res = 0
    for i in range(1, n):
        res += math.log10(11 * y[n + 1 - i - 1] ** 2) ** 2
    res *= 68
    return res"
"import math

def main(z, x, y):
    count = 0
    for i in range(1, 5):
        count += math.pow(math.atan(math.pow(x[5 - math.ceil(i / 2) - 1], 3) - y[i - 1] - 13 * math.pow(z[5 - i - 1], 2)), 7)
    return count"
"from math import ceil

def main(z, y, x):
    ans = 0
    m = [0] * (len(x) + 1)
    n = [0] * (len(y) + 1)
    k = [0] * (len(z) + 1)
    for i in range(len(m)):
        if i != 0:
            m[i] = x[i - 1]
            n[i] = y[i - 1]
            k[i] = z[i - 1]
    for i in range(1, len(m)):
        tmp = m[ceil(i / 2)] ** 3
        tm = n[ceil(i / 2)] ** 2
        t = 61 * k[len(x) + 1 - ceil(i / 4)]
        ans += 2 * (tmp + tm + t) ** 5
    return 58 * ans"
"from math import ceil

def main(y, z, x):
    ans = 0
    m = [0] * (len(x) + 1)
    n = [0] * (len(y) + 1)
    k = [0] * (len(z) + 1)
    for i in range(len(m)):
        if i != 0:
            m[i] = x[i - 1]
            n[i] = y[i - 1]
            k[i] = z[i - 1]
    for i in range(1, len(m)):
        tmp = 7 * k[ceil(i / 4)]
        tm = 52 * n[len(x) + 1 - ceil(i / 4)] ** 3
        t = 73 * m[i] ** 2
        ans += tmp - tm - t
    return ans"
"import math

def main(z, y):
    sum = 0
    for i in range(0, len(z)):
        sum += 63 * (1 - pow(z[i], 2) / 60 - y[len(z) - i - 1] / 34)
    return sum"
"import math

def main(x, z):
    n = len(x) - 1
    s = 0
    for i in range(1, n + 2):
        s += (92 * z[n + 1 - math.ceil(i / 2)] ** 3 - 88 * x[n + 1 - i] ** 2 - 1) ** 7
    return s"
"import math

def main(z, y):
    res = 0
    for i in range(1, len(z) + 1):
        res += 91 * math.atan(y[i - 1] ** 3 + z[i - 1] + 0.03) ** 2
    return res"
"import math

def main(z, x, y):
    ans = 0
    n = 3
    for i in range(n):
        ans += (84 * y[n + 1 - math.ceil((i + 1) / 2) - 1] + 68 * x[n + 1 - math.ceil((i + 1) / 2) - 1] ** 3 + z[math.ceil((i + 1) / 2) - 1] ** 2) ** 6 / 13
    return ans"
"import math

def main(x, z):
    sum = 0
    n = 8
    for i in range(n):
        t = x[n + 1 - math.ceil((i + 1) / 4) - 1] ** 2
        sum += 65 * math.atan(z[n - i - 1] ** 3 + 57 * x[n - i - 1] + t) ** 7
    return 5 * sum"
"import math

def main(y, z, x):
    sm = 0
    n = 3
    for i in range(n):
        sm += 86 * (y[math.ceil((i + 1) / 3) - 1] ** 3 / 38 - z[i] ** 2 - x[i]) ** 7
    return 24 * sm"
"import math

def main(x):
    res = 0
    for i in range(0, len(x)):
        res1 = 58 * x[i] ** 2 - 1 - 9 * x[i] ** 3
        res = res + math.log(res1, math.e) ** 2
    return res"
"def main(y):
    sum = 0
    for i in range(1, len(y) + 1):
        sum += (0.02 + y[i // 4] ** 2 + y[i // 4] ** 3 / 25) ** 7
    return sum * 42"
"import math

def main(y):
    n = len(y) - 1
    S = 0
    for i in range(0, n + 1):
        S += math.log(1 + y[n - i] ** 3 + y[n - i]) / 61
    return S"
"from math import ceil

def main(y):
    rez = 0
    n = len(y)
    for i in range(1, n + 1):
        rez += y[n - ceil(i / 2)] ** 2 - y[n - ceil(i / 2)] - 97 * y[ceil(i / 3) - 1] ** 3
    return rez"
"from array import *
import math

def main(z, y, x):
    func = 0.0
    for i in range(1, 8):
        func += (y[7 - i] ** 2 / 67 + x[7 - math.ceil(i / 4)] + z[7 - math.ceil(i / 2)] ** 3) ** 7
    return 77 * func"
"import math

def main(y, x):
    Sum = 0
    for i in range(1, len(x) + 1):
        a = 1 + 78 * x[i - 1] + 44 * y[math.ceil(i / 3) - 1] ** 3
        Sum += 13 * a ** 4
    return Sum"
"import math

def main(y, z, x):
    n = len(y)
    res = 0
    for i in range(n):
        res = res + 10 * (58 * y[i] ** 3 - 22 * z[i] ** 2 - x[i]) ** 4
    return res * 93"
"from math import ceil

def main(z):
    sm = 0
    for i in range(1, len(z) + 1):
        sm += (27 * z[ceil(i / 3) - 1] ** 3 + 44 * z[ceil(i / 3) - 1] + 1) ** 4
    return sm"
"import math

def main(x, z):
    sol = 0
    for i in range(0, len(x)):
        sol = sol + (40 + z[i] ** 3 + 43 * x[i]) ** 3
    return sol"
"def main(z, x):
    summ = 0
    for i in range(0, len(z)):
        summ += 32 * (84 * z[i] ** 3 - 46 * x[i] ** 2 - 59) ** 7
    return summ"
"import math

def main(x):
    n = 7
    f = 0
    for i in range(1, n + 1):
        f += (0.02 + x[n + 1 - math.ceil(i / 3) - 1] ** 3 / 70) ** 2
    return f"
"def main(z):
    x = 0
    for i in range(len(z)):
        x += 43 * (17 * z[i // 2] ** 2 + 23 * z[len(z) - 1 - i] ** 3) ** 7
    return x"
"def main(x, y):
    output = 0
    n = 0
    for i in range(len(x)):
        output += 73 * (x[n + 1 - int(i / 3)] ** 2 - 91 * y[n + 1 - int(i / 3)] ** 3 - 0.03)
    return output"
"def main(y):
    x = 0
    for i in range(len(y)):
        x += 90 * (43 + y[len(y) - (i + 4) // 4] + 73 * y[len(y) - 1 - i] ** 2) ** 3
    return x"
"import math

def main(z, x, y):
    n = 8
    o = 0
    for i in range(n):
        g = z[n + 1 - (i + 1) - 1]
        h = 79 * x[n + 1 - math.ceil((i + 1) / 3) - 1] ** 3
        p = 35 * y[n + 1 - (i + 1) - 1] ** 2
        o += 52 * (g - h - p) ** 7
    return 85 * o"
"import math

def main(x, z, y):
    sum = 0
    n = len(x)
    for i in range(0, n):
        sum += (22 * x[i] - y[n - 1 - i] ** 2 - 60 * z[i] ** 3) ** 5
    return sum"
"def main(z):
    x = 0
    for i in range(len(z)):
        x += 64 * (16 - 90 * z[i] ** 3 - 82 * z[len(z) - 1 - i]) ** 7
    return 37 * x"
"import math

def main(y, z):
    sum = 0
    n = len(y)
    for i in range(1, n + 1):
        a = y[n - i]
        b = pow(z[int(n - i / 4)], 2)
        sum += 32 * pow(1 + a + b, 4)
    return sum"
"import math

def main(x, z):
    s = 0
    for i in range(0, len(x)):
        s = s + (44 * x[math.floor(i / 4)] ** 3 + 35 * x[math.floor(i / 2)] ** 2 + z[i]) / 5
    return s"
"import math

def main(z, x):
    n = len(x)
    sum = 0
    x.append(x[n - 1])
    z.append(z[n - 1])
    for i in range(n - 1, 0, -1):
        x[i] = x[i - 1]
        z[i] = z[i - 1]
    for i in range(1, n + 1):
        sum += 30 * pow(59 * x[n + 1 - math.ceil(i / 2)] - pow(z[math.ceil(i / 3)], 3) - 0.04, 6)
    return sum"
"import math

def main(z):
    result = 0
    n = len(z)
    for i in range(1, n + 1):
        var1 = (89 * z[i - 1] + 38 * z[n + 1 - i - 1] ** 2) ** 7
        var2 = var1 / 39
        result += var2 * 33
    return result"
"import math

def main(z, x):
    n = len(z)
    var_1 = 0
    for i in range(1, n + 1):
        var_1 += (46 * x[n - math.ceil(i / 4)] ** 2 - 65 * x[n - math.ceil(i / 3)] ** 3 - 51 * z[n - math.ceil(i / 3)]) ** 7 / 43
    return 40 * var_1"
"import math

def main(x, z, y):
    f = 0
    n = len(x)
    for i in range(1, n + 1):
        f += (z[math.ceil(i / 2) - 1] ** 2 - 96 * x[math.ceil(i / 2) - 1] - y[n - 1 - (math.ceil(i / 4) - 1)] ** 3) ** 5
    return f"
"import math
n = 2

def main(z, x):
    summation = 0
    for i in range(0, n):
        summation += 64 * pow(59 - 85 * pow(x[i], 2) - 14 * z[n - math.ceil((i + 1) / 3)], 6)
    summation *= 87
    return summation"
"import math
n = 3

def main(x, z):
    summation = 0
    for i in range(0, n):
        summation += 98 * pow(abs(84 * pow(z[n - math.ceil((i + 1) / 2)], 3) + pow(x[n - i - 1], 2)), 7)
    summation *= 51
    return summation"
"import math

def main(z, x, y):
    n = len(y)
    a = 0
    for i in range(n):
        part_1 = z[i] ** 2 + x[n - 1 - int(i / 3)]
        part_2 = y[int(i / 2)] ** 3
        a = a + math.acos(part_1 + part_2) ** 4 / 70
    return 87 * a"
"def main(x, y, z):
    a = 0
    for i in range(len(x)):
        a += abs(y[len(x) - 1 - i // 4] - 20 * x[len(x) - 1 - i // 4] ** 3 - 13 * z[len(x) - 1 - i // 2] ** 2) ** 5
    return 20 * a"
"import math

def main(n):
    result = 0
    z = len(n)
    for i in range(1, z + 1):
        r1 = 98 * n[z - i] - 65 * math.pow(n[z - i], 3) - n[i - 1] * n[i - 1]
        result += r1 / 98
    return result"
"import math

def main(z, y, x):
    R = 0
    for i in range(1, 3):
        R += (27 * y[math.ceil(i / 2) - 1] + z[math.ceil(i / 3) - 1] ** 3 / 96 + x[3 - math.ceil(i / 4) - 1] ** 2) ** 4
    return 97 * R"
"import math

def main(x):
    value = 0
    for i in range(0, len(x)):
        value += math.pow(math.pow(x[i + 1 - len(x)], 3) - 57 * x[math.floor(len(x) / 4)] - 98 * math.pow(x[math.floor(len(x) / 4)], 2), 5)
    sum = 62 * value
    return sum"
"import math

def main(z, x):
    value = 0
    for i in range(0, len(x)):
        atan = math.pow(math.atan(74 * z[i] - 99 - 50 * math.pow(x[math.floor(i / 2)], 3)), 3)
        value += 8 * atan
    return value"
"import math

def main(y):
    value = 0
    for i in range(0, len(y)):
        value += 6 * (y[len(y) - 1 - math.floor(i / 3)] - 63 * y[math.floor(i / 3)] ** 2) ** 3
    return value"
"def main(z):
    s = 0
    for i in range(1, len(z) + 1):
        s1 = 66 * z[len(z) + 1 - i - 1] ** 3
        s2 = z[len(z) + 1 - i - 1] ** 2
        s += 64 * (79 - s2 - s1) ** 6
    return s * 94"
"import math

def main(f_y):
    n_0 = len(f_y)
    s_0 = 0
    for i in range(0, n_0, 1):
        s_0 = s_0 + 70 * pow(7 - 32 * pow(f_y[i // 2], 3) - f_y[i // 2], 6)
    res_0 = 71 * s_0
    return res_0"
"def main(mega_list):
    sum = 0
    for (i, x) in enumerate(mega_list):
        sum += (1 - mega_list[int(i / 4)] ** 3 - x) ** 6
    return sum"
"import math

def main(z):
    s = 0
    n = len(z)
    for i in range(n):
        t = n + 1 - math.ceil((i + 1) / 3) - 1
        x = 95 * (z[t] ** 3 / 4 + z[i] ** 2 + 30 * z[t]) ** 3
        s += x
    return s * 36"
"def main(x, z):
    s1 = (53 * z[5] + 1 + 17 * x[0] ** 2) ** 2
    s2 = (53 * z[4] + 1 + 17 * x[1] ** 2) ** 2
    return 4 * s1 + 2 * s2"
"import cmath
import math

def f(x):
    n = len(x) - 2
    s = 0
    for i in range(0, len(x)):
        s += 78 * (x[n + 1 - i] ** 2 + 42 * x[i] ** 3) ** 4
    return s.real

def main(x):
    return f(x)"
"import math

def main(x):
    vctr = 0
    for i in range(1, len(x) + 1):
        vctr = vctr + 36 * (44 * x[len(x) - math.ceil(i / 3)] ** 2) ** 2
    return vctr"
"import math

def main(y, x):
    res = 0
    n = len(y) - 1
    for i in range(0, len(y)):
        res += (6 * y[n + 1 - math.ceil((i + 1) / 4)] ** 3 + x[i] ** 2 + 37 * x[i]) ** 7
    return res"
"def main(z):
    sum1 = 0
    for i in range(1, len(z) + 1):
        sum1 += 59 * pow(pow(z[i - 1], 2) + pow(z[i - 1], 3) + z[i - 1], 4)
    return sum1"
"from math import ceil
n = 6

def main(y, z, x):
    global n
    res = 0
    for i in range(n):
        res += ceil(47 * y[-1 - i] ** 2 - 25 * x[-1 - i] ** 3 - z[i]) ** 7
    return res * 71"
"import math

def main(x, z):
    n = 3
    f = 0
    for i in range(1, n + 1):
        a = x[n - i] ** 2
        f += 9 * (43 * x[n - i] ** 3 + z[math.ceil(i / 3) - 1] + a) ** 5
    f1 = 75 * f
    return f1"
"def main(z, x):
    from math import ceil
    s = 0
    n = len(x) - 1
    for i in range(n + 1):
        s += 0.04 - x[n - i] ** 3 / 99 - z[int(ceil((i + 1) / 3)) - 1]
    return 72 * s"
"def main(y, z):
    n = len(y)
    x = 0
    for i in range(1, n + 1):
        x += z[n - i // 5 - 1] - 31 * y[n - i] ** 2 - 1
    return 71 * x"
"from math import ceil

def main(y, z):
    res = 0
    y1 = [0] * (len(y) + 1)
    z1 = [0] * (len(z) + 1)
    for i in range(len(y1)):
        if i != 0:
            y1[i] = y[i - 1]
            z1[i] = z[i - 1]
    for i in range(1, len(y) + 1):
        res += 61 * (z1[len(z) + 1 - i] ** 3 - 52 * y1[ceil(i / 4)] - 45) ** 7
    return res"
"import math

def main(x):
    n = len(x)
    res = 0
    for i in range(0, n):
        res += 87 * math.ceil(x[math.ceil(i // 3)] ** 2 - 51 * x[i] - 1) ** 2
    return 90 * res"
"import math

def main(x, y, z):
    res = 0
    n = len(x)
    x.insert(0, 0)
    y.insert(0, 0)
    z.insert(0, 0)
    for i in range(1, n + 1):
        a1 = int(math.ceil(i / 3.0))
        a2 = n + 1 - int(math.ceil(i / 2.0))
        res += math.log10(37 * y[i] ** 3 + 94 * x[a1] + 89 * z[a2] ** 2) ** 7
    return res"
"def main(x, z, y):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res += 58 * y[n - i] ** 2 + 93 * x[i - 1] + 82 * z[i - 1] ** 3
    return res * 67 * 90"
"import math

def main(x, z):
    n = len(z)
    result5 = 0
    for i in range(1, n + 1):
        a = z[n - i] ** 3 + z[n - i] ** 2 / 29 + x[n - math.ceil(i / 4)]
        result5 += math.tan(a) ** 6 / 46
    return result5"
"from math import cos

def main(z, y, x):
    n = len(z)
    return sum([74 * cos(y[n - i] ** 3 + z[i - 1] ** 2 + x[n - i]) ** 6 for i in range(1, n + 1)])"
"def main(y):
    n = len(y)
    result = 0
    for i in range(1, n + 1):
        result += 3 * (y[i - 1] ** 2 + y[i - 1] ** 3) ** 3
    return result"
"from math import *

def main(x, y, z):
    f = 0
    n = len(x)
    for i in range(1, n + 1):
        f += 67 * pow(pow(y[i - 1], 3) / 43 - 80 * x[i - 1] - pow(z[ceil(i / 2) - 1], 2), 2)
    return f"
"import math

def main(z, y):
    n = len(y)
    result5 = 0
    for i in range(1, n + 1):
        a = z[n - math.ceil(i / 4)] ** 2 + 91 * y[n - i] ** 3 + 1
        result5 += math.exp(a) ** 4
    return result5"
"def f(y):
    return (y ** 2 + y / 47) ** 2 / 49

def main(y):
    sumi = 0
    n = len(y)
    for i in range(0, n, 1):
        sumi = sumi + f(y[n - i - 1])
    return sumi"
"import math

def func(x, y):
    return (38 * y ** 3 - x / 6 - x ** 2) ** 3

def main(y, x):
    sumi = 0
    n = len(y)
    for i in range(0, n):
        sumi += func(x[n - math.ceil((i + 1) / 4)], y[n - math.ceil((i + 1) / 2)])
    return sumi * 3"
"import math

def main(y, z):
    y.insert(0, 0)
    z.insert(0, 0)
    i = 1
    s = 0
    n = 3
    a = 0
    for i in range(n):
        i = i + 1
        s = 20 * (93 - 82 * y[i] - z[n + 1 - i] ** 3) ** 4
        a = a + s
    a = a * 37
    return a"
"def main(y):
    n = len(y)
    a = 0
    for i in range(n):
        a += 48 * (y[i] - 6 - y[i] ** 2 / 34) ** 5
    return a"
"import math

def main(y, z, x):
    n = len(x)
    result = 0
    for i in range(1, n + 1):
        result += (74 * x[i - 1] - 30 * z[n - i] ** 2 - y[math.ceil(i / 3 - 1)] ** 3) ** 4
    return result"
"import math

def main(z, x):
    z.insert(0, 0)
    x.insert(0, 0)
    a = 0
    n = 6
    for i in range(n):
        i = i + 1
        s1 = abs(z[n + 1 - math.ceil(i / 4)] ** 3 + 68 * x[n + 1 - math.ceil(i / 2)] ** 2 + 1)
        s2 = 82 * s1 ** 7
        a = a + s2
    return a"
"import math

def main(*x):
    f = 0
    n = len(*x) - 1
    for i in range(0, n + 1):
        f += math.sin(x[0][n - i] ** 2 / 58 + x[0][n - i] / 75 + 82 * x[0][i] ** 3)
    return f"
"def main(x, z, y):
    n = len(x)
    a = 0
    for i in range(1, n + 1):
        a += 50 * (75 * y[n - i] ** 2 + x[n - i] ** 3 + 60 * z[n - i])
    return 74 * a"
"import math

def main(x, y, z):
    n = len(x) - 1
    res_1 = 0
    res = 0
    for i in range(n + 1):
        res_1 = pow(math.cos(x[i // 3] ** 3 - z[n - i] - y[i] ** 2 / 11), 4)
        res += 52 * res_1
    return res"
"import math

def main(x):
    n = len(x)
    f = 0
    for i in range(1, n + 1):
        f += (15 * x[i - 1] ** 2 - 93 - x[n - math.ceil(i / 4)] ** 3) ** 5
    return f * 38"
"def main(x):
    sum_ = 0
    for i in range(1, len(x) + 1):
        sum_ += pow(29 * x[len(x) - i] - pow(x[len(x) - i], 3) - 91, 3)
    return sum_"
"import math

def main(z, x):
    res = 0
    for i in range(1, len(x) + 1):
        a = 96 + x[len(x) - i] ** 2
        b = z[len(z) - math.ceil(i / 3)] ** 3 / 87
        res = res + a + b
    return 44 * res"
"import math

def main(z, y):
    n = len(y)
    sum = 0
    for i in range(1, n + 1):
        sum += 58 * (y[n - 1 + 1 - i] ** 2 - y[n - 1 + 1 - i] ** 3 - z[n - 1 + 1 - i]) ** 5
    return 84 * sum"
"from math import pow, ceil

def f(y: list[float], x: list[float]) -> float:
    if x.__len__() != y.__len__():
        return 0
    n = x.__len__()
    result = 0
    for i in range(1, n + 1):
        result += 18 * pow(y[i - 1] - 97 - pow(x[n + 1 - ceil(i / 3) - 1], 2) / 97, 5)
    result *= 2
    return float('{:.2e}'.format(result))
main = f"
"import math

def main(y, z, x):
    result = 0
    n = len(y)
    for i in range(1, n + 1):
        b = 95 * y[math.ceil(i / 3) - 1] ** 3
        a = z[n + 1 - i - 1] ** 2 + x[n + 1 - i - 1] / 36 + b
        result += 96 * math.log(a, 2) ** 7
    return result * 38"
"import math

def main(y, z, x):
    y.insert(0, 0)
    z.insert(0, 0)
    x.insert(0, 0)
    n = 7
    suma = 0
    for i in range(1, n + 1):
        a = y[n + 1 - math.ceil(i / 4)] ** 3
        b = x[n + 1 - i]
        c = 94 * z[math.ceil(i / 4)] ** 2
        suma += (a + b + c) ** 2
    return suma"
"import math

def main(z, y, x):
    s = 0
    n = len(y)
    for i in range(1, n + 1):
        s = s + (z[n + 1 - math.ceil(i / 3) - 1] ** 2 + y[n + 1 - math.ceil(i / 3) - 1] + x[math.ceil(i / 2) - 1] ** 3) ** 2
    return 90 * s"
"import math

def main(z, y, x):
    s = 0
    n = len(y)
    for i in range(1, n + 1):
        s = s + (y[math.ceil(i / 2) - 1] / 56 - 13 * z[n + 1 - i - 1] ** 2 - 30 * x[n + 1 - math.ceil(i / 2) - 1] ** 3) ** 4
    return 76 * s"
"import math

def main(x, z):
    f = 0.0
    for i in range(len(x)):
        f += 27 * (x[i] ** 2 + 1 + z[math.ceil((i + 1) / 2 - 1)])
    f *= 63
    return f"
"import math

def main(x, y):
    q = 0
    n = len(x)
    for i in range(1, n + 1):
        q += (x[n - math.ceil(i / 4)] - y[n - i] ** 3 - 1) ** 6 / 6
    return 54 * q"
"import math

def main(*args):
    y = args[0]
    x = args[1]
    z = args[2]
    f = 0
    n = len(x)
    for i in range(0, n):
        f += (77 * z[i] ** 2 + x[i] + 53 * y[math.floor(i / 3)] ** 3) ** 5
    return f * 18"
"from math import *

def main(y):
    ans = 0
    for i in range(1, 4):
        ans += 14 * (y[i - 1] ** 2 + y[ceil(i / 3 - 1)] + y[ceil(i / 2 - 1)] ** 3 / 73) ** 7
    return 9 * ans"
"import math

def main(z, y, x):
    result = 0
    n = len(z)
    for i in range(1, n + 1):
        var1 = 80 * y[n - i] ** 2
        var2 = 72 * x[math.ceil(i / 2) - 1] ** 3
        var3 = z[n - i] / 44
        result += (var1 + var2 + var3) ** 6
    return 8 * result"
"import math

def main(z, y, x):
    sum = 0
    for i in range(1, len(y) + 1):
        sum += pow(pow(z[i - 1], 3) + pow(x[len(x) - i], 2) + y[len(y) - math.ceil(i / 3)], 2)
    return 72 * sum"
"import math

def main(y, x, z):
    n = len(y)
    tmp = 0
    for i in range(1, n + 1):
        tmp += 2 * (y[n - math.ceil(i / 4)] + x[n - i] ** 3 + z[n - i] ** 2) ** 3
    return tmp"
"from math import ceil

def main(x):
    n = len(x)
    res = 0
    for i in range(1, n + 1):
        res += 82 * pow(1 + 59 * x[n - i] ** 2 + x[n - ceil(i / 3)] / 67, 6)
    return res"
"from math import tan, ceil

def main(z, y):
    n = len(z)
    s = 0
    for i in range(1, n + 1):
        s += pow(tan(23 * z[ceil(i / 4) - 1] - 1 - pow(y[n - ceil(i / 4)], 3)), 7)
    return s"
"import math

def main(list):
    return float('%.2e' % vctSum(list))

def vctSum(x):
    res = 0
    n = len(x)
    x.insert(0, 1)
    for i in range(1, n + 1):
        res += 80 * (37 * x[n + 1 - math.ceil(i / 4)] - 1 - x[math.ceil(i / 4)] ** 3) ** 2
    return 11 * res"
"from math import ceil

def main(x, y):
    sum1 = 0
    n = len(y)
    for i in range(1, n + 1):
        sum1 += y[n - ceil(i / 3)] - x[n - ceil(i / 4)] ** 2
    return sum1
    return sum"
"import math

def main(z):
    sum = 0
    for i in range(len(z)):
        difficult1 = pow(z[math.trunc(i / 3)], 3)
        difficult2 = pow(z[math.trunc(i / 3)], 2)
        substraction_result = difficult1 - 8 * difficult2
        sum += 66 * pow(substraction_result, 2)
    return sum"
"import math

def main(x, y):
    n = len(x)
    res = 0
    for i in range(1, n + 1):
        res += math.atan(38 * y[n - math.ceil(i / 3)] ** 2 + x[n - math.ceil(i / 3)] ** 3 / 88 + 1) ** 4 / 88
    return res"
"def main(x):
    n = len(x)
    result = 0
    for i in range(1, n + 1):
        result += (x[n - i] ** 3 - 80 - 45 * x[n - i]) ** 3
    return 64 * result"
"def main(x, z):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res += (91 * z[i - 1] + 71 * x[n - i] ** 2 + z[n - i] ** 3) ** 3
    return res"
"import math

def main(y, z, x):
    s = 0
    for i in range(1, len(y) + 1):
        s += (6 * y[len(y) - i] ** 3 - z[math.ceil(i / 4) - 1] ** 2 - x[i - 1]) ** 2 / 87
    return 11 * s"
"from math import ceil

def main(z, x):
    result = 0
    length = len(z) + 1
    for i in range(1, length):
        result += 29 * (x[i - 1] ** 3 - 99 * z[length - ceil(i / 4) - 1] ** 2) ** 4
    return result"
"from math import ceil

def main(x, z, y):
    res = 0
    le = len(x)
    for i in range(1, le + 1):
        ge = z[le - ceil(i / 2)] / 50
        ze = y[le - ceil(i / 4)] ** 2 / 86
        res += 11 * (ge - x[le - i] ** 3 - ze) ** 2
    res *= 86
    return res"
"import math

def main(x, y, z):
    s = 0
    n = 1
    for i in range(0, len(y)):
        xi = x[n + 1 - int(i)]
        zi = z[n + 1 - int(i)] ** 2
        yi = y[int(i / 2)] ** 3
        s = s + math.sqrt(xi + 97 * zi + yi / 28) ** 3
    return 21 * s"
"import math

def main(x):
    n = len(x)
    answer = 0
    for i in range(0, n):
        answer += (x[n - 1 - i // 3] - 94 * x[i] ** 2 - 91) ** 4
    return 3 * answer"
"from math import atan

def main(z):
    f = 0
    for i in range(0, len(z)):
        f += atan(30 * z[len(z) - 1 - i] ** 2 + 53 * z[len(z) - 1 - i] ** 3) ** 2
    return f"
"import math

def main(xx, zz, yy):
    s = 0
    x = [''] + xx
    z = [''] + zz
    y = [''] + yy
    n = len(x) - 1
    for i in range(1, n + 1):
        s += pow(math.ceil(pow(z[n + 1 - i], 3) / 33 + 77 * pow(x[i], 2) + 36 * y[n + 1 - i]), 3) / 3
    s = s * 20
    return s"
"from math import ceil

def main(y, x, z):
    n = len(x)
    w = 0
    for i in range(n):
        w += (42 * y[n - (i + 1)] ** 2 + z[i] + 66 * x[ceil((i + 1) / 2) - 1] ** 3) ** 2
    return w * 44"
"import math

def main(x, z):
    n = len(x)
    a = 0
    for i in range(1, n + 1):
        a += 5 * (0.09 + z[n + 1 - math.ceil(i / 4) - 1] + 79 * x[i - 1] ** 2) ** 2
    return 3 * a"
"import math

def main(z, y):
    sum = 0
    for i in range(len(z)):
        sum += math.exp(43 - z[len(z) - i - 1] ** 3 - y[i]) ** 3 / 42.0
    sum *= 97
    return sum"
"def main(x, y):
    comp = 0
    n = len(x)
    for i in range(0, n):
        comp += (y[i] + 80 * y[i] ** 3 + x[int(i / 4)] ** 2) ** 3
    comp *= 96
    return comp"
"import math

def main(y, z, x):
    r1 = 0
    n = len(x)
    y.insert(0, 0)
    z.insert(0, 0)
    x.insert(0, 0)
    for i in range(1, len(x)):
        r1 += 44 * math.floor(8 * z[math.ceil(i / 4)] ** 2 - 97 * x[n + 1 - math.ceil(i / 2)] - y[n + 1 - i] ** 3 / 42) ** 3
    return 58 * r1
main([-0.47, -0.62, -0.11, -0.22, -0.66, -0.38, -0.63, 0.68], [-0.86, -0.67, -0.16, -0.32, -0.42, 0.81, -0.06, 0.25], [0.04, 0.56, -0.45, 0.56, 0.26, -0.53, -0.82, -0.07])"
"import math

def main(x, y, z):
    r1 = 0
    n = len(x)
    x.insert(0, 0)
    y.insert(0, 0)
    z.insert(0, 0)
    for i in range(1, len(x)):
        r1 += 80 * math.log(y[n + 1 - i] ** 3 + 61 * z[n + 1 - i] ** 2 + x[math.ceil(i / 4)]) ** 3
    return 88 * r1
main([0.95, -0.81, -0.31, -0.36, 0.38], [0.7, 0.22, 0.73, -0.34, -0.14], [-0.54, 0.13, 0.86, 0.88, 0.98])"
"import math

def main(y, z):
    vctr = 0
    for i in range(0, len(y)):
        a = y[len(y) - 1 - int(i / 2)]
        b = z[int(i / 4)]
        vctr += (a - 1 - b ** 3) ** 6
    return 93 * vctr"
"import math

def main(y):
    n = len(y)
    result = 0
    for i in range(1, len(y) + 1):
        section1 = y[n - math.ceil(i / 4)]
        section2 = 64 * y[n - math.ceil(i / 4)] ** 3
        result = result + 83 * math.ceil(section1 - section2 - 1)
    return result"
"from math import ceil

def main(z, y, x):
    n = len(z)
    result = 0
    for i in range(1, n + 1):
        result += 65 * (z[i - 1] ** 3 - y[n - ceil(i / 4)] - x[n - i] ** 2) ** 2
    return result * 89"
"def main(z, x):
    a = 0
    n = len(z)
    for i in range(0, n):
        a += (x[n - 1 - i // 2] ** 2 + 3 * z[n - 1 - i] ** 3 + 44 * x[n - 1 - i // 4]) ** 6
    a = a * 20
    return a"
"def main(n):
    result = 0
    for i in n:
        result += pow(i ** 2 + 72 * i ** 3 + 32 * i, 5)
    return result"
"from math import exp

def main(n):
    result = 0
    for i in n:
        result += 70 * pow(exp(0.03 - 57 * i - pow(i, 2)), 6)
    return result * 12"
"import math

def f(y, x):
    res = 0
    n = max(len(y), len(x)) - 1
    for i in range(n + 1):
        res += math.log10(y[n - i] ** 2 / 10 - x[i] ** 3) ** 4 / 95
    return 72 * res

def main(y, x):
    return f(y, x)"
"import math

def main(z):
    n = len(z)
    f = 0
    for i in range(0, n):
        f = f + (z[n - 1 - i // 4] ** 2 + 57 * z[n - 1 - i // 4]) ** 2
    return f * 44"
"import math

def main(z):
    return f(z)

def f(z):
    f = 0
    n = len(z)
    for i in range(1, n + 1):
        f += 34 * (z[math.ceil(i / 2) - 1] + z[i - 1] ** 3 + z[math.ceil(i / 2) - 1] ** 2) ** 5
    f *= 37
    return f"
"def main(y, x, z):
    import math
    s = 0
    n = len(y)
    for i in range(n):
        a = y[i] / 74
        b = x[i // 2] ** 3
        c = z[n - i - 1] ** 2
        s = s + math.fabs(a - b - c) ** 3
    return 184 * s"
"import math

def main(x, y, z):
    ans = 0
    n = len(x)
    for i in range(1, n + 1):
        ans1 = z[math.ceil(i / 2) - 1]
        ans2 = pow(y[math.ceil(i / 4) - 1], 3)
        ans3 = pow(x[i - 1], 2)
        ans += ans1 - ans2 - ans3
    return 98 * ans"
"import array

def main(z):
    n = len(z)
    result = 0
    for i in range(0, n):
        result += (z[i] * z[i] + z[i // 2] / 5) ** 2
    return 45 * result"
"from array import array

def main(z):
    n = len(z)
    result = 0
    for i in range(1, n + 1):
        result += (71 * z[n - i] - 62 * z[n - i] ** 2) ** 6
    return result"
"import math

def main(y, z):
    res = 0
    n = len(y)
    for i in range(1, len(y) + 1):
        first = y[n + 1 - i - 1] / 80
        second = 97 * z[i - 1] ** 2
        res += 83 * math.floor(first - second - 97) ** 3
    return 14 * res"
"import math

def main(x, z, y):
    count = 0.0
    for i in range(1, 4):
        count += 19 * (x[i - 1] ** 2 + y[math.ceil(i / 2) - 1] ** 3 + 83 * z[3 - math.ceil(i / 3)]) ** 3
    return 8 * count"
"from math import ceil as ceil

def main(z, y):
    s = 0
    n = len(z)
    for i in range(1, n + 1):
        s += y[ceil(i / 3) - 1] ** 2 + 1
        s += z[n + 1 - ceil(i / 2) - 1]
    return 83 * 54 * s"
"import math

def main(z):
    n = len(z)
    res = 0
    for i in range(1, n + 1):
        res += 3 * (24 + z[math.ceil(i / 4) - 1] + pow(z[i - 1], 3))
    return res"
"import math

def main(z, x, y):
    a = 0
    for i in range(1, len(x) + 1):
        a += math.tan(22 * x[i - 1] + 31 * y[len(x) - math.ceil(i / 4)] ** 2 + z[math.ceil(i / 2) - 1] ** 3) ** 3
    return 35 * a"
"from math import ceil

def main(x, z):
    n = len(x)
    s = 0
    for i in range(1, n + 1):
        s += (z[i - 1] ** 3 - x[n - ceil(i / 4)]) ** 4
    return s * 73"
"import math

def main(z):
    a = 0
    z.insert(0, 0)
    for i in range(1, len(z)):
        a += 36 * math.log(56 * z[i] - 97 * z[i] ** 3, 10) ** 3
    return a"
"import math

def main(z, y):
    n1 = math.ceil((z[0] ** 2 + z[1] ** 2) ** 0.5)
    n2 = math.ceil((y[0] ** 2 + y[1] ** 2) ** 0.5)
    if int(n1) >= n2:
        n = n2
    else:
        n = n1
    f = 0
    for i in range(int(n) + 1):
        f += 79 * (z[int(n) - math.floor(i / 3)] ** 2 - y[i] ** 3 - 1) ** 3
    f = f * 27
    return f"
"import math

def main(y, x):
    result = 0
    n = len(x)
    for i in range(0, n):
        result += pow(x[i] ** 3 / 13 + 34 * y[n - math.ceil((i + 1) / 3)] ** 2 + 86, 4) / 98
    result *= 82
    return result"
"from math import ceil

def main(x):
    value = 0
    n = len(x) + 1
    for i in range(1, n):
        value += 31 * (x[n - 1 - ceil(i / 4)] ** 3 + x[n - 1 - ceil(i / 4)] ** 2) ** 6
    return 40 * value"
"def main(y, z):
    n = 3
    output = 0
    for i in range(n):
        y_i = y[n - (i + 1)] ** 3
        z_i = 34 * z[n - (i + 1)] ** 2
        output += 34 * (y_i + 1 + z_i) ** 3
    return 45 * output"
"from math import log10, ceil

def main(y, z, x):
    result = 0
    n = len(y)
    for i in range(1, n + 1):
        result += (y[n - ceil(i / 4)] + x[n - i] ** 3 + 80 * z[ceil(i / 2) - 1] ** 2) ** 6
    return result"
"def main(x, z, y):
    n = 3
    output = 0
    for i in range(n):
        x_i = 75 * x[i]
        z_i = -80 * z[int(round(i / 4))] ** 2
        y_i = -1 * y[int(round(i / 4))] ** 3
        output += (x_i + z_i + y_i) ** 5
    return 91 * output"
"def main(z, y, x):
    n = 7
    output = 0
    for i in range(n):
        z_i = 47 * z[n - (i + 1)]
        x_i = x[round(int(i / 3))] ** 3
        y_i = 92 * y[n - (i + 1)] ** 2
        output += abs(z_i - x_i - y_i) ** 5
    return output"
"import math

def main(z, x):
    s = 0
    n = len(z)
    for i in range(1, n + 1):
        a = z[n - abs(math.ceil(i / 3))] ** 2 / 81
        b = 71 * x[abs(math.ceil(i / 3)) - 1]
        s = s + (99 + a + b) ** 6
    return 60 * s"
"import math

def main(y):
    s = 0
    n = len(y)
    for i in range(1, n + 1):
        k = n - abs(math.ceil(i / 3))
        a = 17 * y[k] ** 2
        b = 63 * y[k]
        c = y[k] ** 3
        s = s + (a + b + c) ** 2
    return 16 * s"
"import math

def main(x, z):
    n = len(x)
    th = 0
    for i in range(n):
        fi = z[n - 1 - i] / 25 - x[int(i / 4)] ** 3 / 62 - 47
        se = math.sin(fi) ** 4
        th = th + se / 67
    f = 39 * th
    return f"
"import math

def main(y, x):
    sum_i = 0
    n = len(x)
    for i in range(1, n + 1):
        sum_i += 66 * (74 * x[n - math.ceil(i / 3)] ** 2 + y[math.ceil(i / 2 - 1)]) ** 6
    return sum_i"
"import math

def main(z, x):
    sum = 0
    for i in range(0, len(z)):
        sum += math.cos(pow(z[i], 2) - x[i // 3])
    sum *= 58
    return sum"
"import math

def main(y):
    n = len(y)
    result5 = 0
    for i in range(1, n + 1):
        a = (14 * y[n - i] + y[n - i] ** 2 / 6) / 11
        result5 += a
    return result5"
"from math import ceil

def main(z, x):
    sum = 0
    n = len(x)
    for i in range(1, n + 1):
        sum += 48 * x[ceil(i / 3) - 1] ** 2 + 95 * z[n - ceil(i / 4)] + 0.03
    return sum"
"import math

def main(x, y, z):
    result = 0
    n = len(z)
    for i in range(1, n + 1):
        var1 = z[n - math.ceil(i / 2)] ** 2
        var2 = y[i - 1]
        var3 = 6 * x[math.ceil(i / 4) - 1] ** 3
        result += (var1 + var2 + var3) ** 7 / 11
    return 78 * result"
"import math

def main(x, z, y):
    vctr = 0
    for i in range(0, len(y)):
        x1 = x[i] ** 3
        z2 = z[i] / 22
        y3 = y[int(i / 2)] ** 2
        vctr += 93 * (x1 - z2 - y3) ** 7
    return 8 * vctr"
"import math

def main(y, z, x):
    ans = 0
    n = len(x)
    for i in range(1, n + 1):
        ans += 52 * (48 * y[n - math.ceil(i / 2.0)] ** 3 + z[math.ceil(i / 2.0) - 1] ** 2 + x[math.ceil(i / 2.0) - 1] / 56) ** 3
    return ans"
"import math

def main(x, y, z):
    n = len(x)
    z.insert(0, 0)
    y.insert(0, 0)
    x.insert(0, 0)
    summa = 0
    for i in range(1, n + 1):
        e = y[n + 1 - i]
        e1 = z[n + 1 - i]
        e2 = x[n + 1 - i]
        summa += (e ** 2 + 62 * e2 + 2 * e1 ** 3) ** 3
    return summa"
"from math import ceil

def main(y, z, x):
    n = len(y)
    return 1764 * sum(((pow(z[n - ceil(i / 2)], 2) / 33 + x[ceil(i / 2) - 1] + y[n - i] ** 3) ** 3 for i in range(1, n + 1)))"
"def main(x, y, z):
    res = 0
    n = len(x)
    for i in range(n):
        res = res + 29 * (z[n - 1 - int(i / 3)] ** 2 + y[n - 1 - int(i / 2)] ** 3 + 12 * x[int(i / 3)]) ** 2
    return res * 34"
"def main(n):
    sum = 0
    for i in range(len(n)):
        sum += pow(n[len(n) - 1 - int(i / 2)], 6) / 17
    return sum"
"import math

def main(y):
    sum = 0
    n = len(y)
    for i in range(1, n + 1):
        sum += (y[n - math.ceil(i / 2)] - 0.02) ** 2
    return sum"
"from math import *

def main(z):
    summa = 0.0
    for i in range(1, len(z) + 1):
        summa += 52 * pow(pow(z[len(z) - int(ceil(i / 3))], 2) + 1 + 75 * z[i - 1], 2)
    return summa * 91
main([-0.09, 0.39, 0.87, 0.71, -0.21])"
"import math

def main(z, x):
    res = 0
    n = len(z)
    for i in range(1, n + 1):
        res += (46 * z[math.ceil(i / 4) - 1] ** 2 + x[n - i] ** 3 + 41) ** 2
    return res"
"from math import floor

def main(x, y):
    res = 0
    n = 6
    for i in range(len(x)):
        a = pow(x[n + 1 - i], 3)
        b = pow(y[n + 1 - floor(i / 4)], 2)
        res += float(pow(69 + a / 2 + b, 6))
    return float(res)"
"import math

def main(z):
    ans = 0
    n = len(z)
    for i in range(n):
        a = z[math.floor(i / 3)]
        b = z[math.floor(i / 3)] ** 3
        ans += 5 * (1 + a + b) ** 5
    return ans"
"def main(y):
    summ = 0
    for i in range(len(y)):
        summ += 4 * pow(pow(y[i], 3) + y[len(y) - (i + 1)], 4)
    return 38 * summ"
"import math

def main(x, z):
    f = 0
    n = len(x)
    for i in range(1, n + 1):
        f += 69 * math.sin(z[i - 1] ** 3 + 85 * x[math.ceil(i / 2) - 1]) ** 7
    return f"
"import math

def main(y):
    sum = 0
    for i in range(0, len(y)):
        sum += 39 * math.pow(15 * math.pow(y[i + 1 - len(y)], 2) + math.pow(y[i + 1 - len(y)], 3), 7)
    return sum"
"import math
import sys
list = []

def main(list):
    i = 1
    s1 = 0
    s2 = 0
    s3 = 0
    for i in range(-1, len(list) - 1):
        s1 = 78 * list[math.ceil(i / 2)] ** 3
        s2 = list[math.ceil(i / 2)] ** 2
        s3 += (s1 + s2) ** 7
    res = 36 * s3
    return res"
"import math

def main(z, x, y):
    s = 0
    i = 1
    n = len(x)
    while i <= n:
        index = n - math.ceil(i / 3)
        s += (3 * z[math.ceil(i / 4) - 1] ** 2 + y[math.ceil(i / 2) - 1] + 28 * x[index] ** 3) ** 6 / 96
        i += 1
    return s"
"from math import cos
from math import ceil

def main(y):
    n = len(y)
    x = 0
    i = 1
    while i <= n:
        index = n - ceil(i < 3)
        x += 97 * cos(y[n + 1 - ceil(i / 3) - 1]) ** 3
        i += 1
    return x * 33"
"import math

def main(x, z):
    sum = 0
    n = len(x)
    for i in range(1, n + 1):
        sum += 43 * (41 + z[n + 1 - math.ceil(i / 2) - 1] ** 2 + x[i - 1] ** 3) ** 6
    return 78 * sum"
"import math

def main(y, x, z):
    n = 6
    f = 0
    for i in range(1, n + 1):
        a = x[math.ceil(i / 3) - 1]
        b = 43 * y[n + 1 - math.ceil(i / 2) - 1] ** 3
        c = 97 * z[n + 1 - math.ceil(i / 3) - 1] ** 2
        f += (a + b + c) ** 6
    return f"
"from math import *

def main(x, z):
    temp = 52
    res = 0
    for i in range(len(x)):
        res = res + cos(58 * z[int(i / 2)] ** 3 - x[i] ** 2 - x[i])
    result = res * temp
    return result"
"import math

def main(x: [float], y: [float]) -> float:
    res = 0
    for i in range(len(x)):
        res += math.cos(48 * x[len(x) - 1 - i] - y[i] ** 2 - 21) ** 4
    return res
main([0.65, -0.8, -0.41], [0.37, -0.13, 1.0])"
"def main(z, y):
    n = len(y)
    result = 0
    for i in range(1, n + 1):
        result += (0.01 + z[n - i] + 25 * y[n - i] ** 3) ** 6
    return result"
"import math

def main(y, x):
    i = 1
    n = len(y) - 1
    result = 0
    while i <= n + 1:
        result += (y[n + 1 - i] ** 2 - 44 * x[n + 1 - math.ceil(i / 2)] - 8) ** 7
        i += 1
    return result"
"from math import ceil

def main(x):
    S = 0
    for i in range(1, len(x) + 1):
        S += (x[ceil(i / 3) - 1] ** 3 / 51 + x[ceil(i / 3) - 1] ** 2) ** 4
    return 5 * S"
"import math

def main(y):
    s = 0
    for i in range(1, len(y) + 1):
        s += math.exp(64 + y[math.ceil(i / 4) - 1] / 65 + y[math.ceil(i / 4) - 1] ** 2) ** 7
    return 33 * s"
"from math import ceil

def func(x):
    summ = 0
    n = len(x)
    for i in range(1, n + 1):
        summ += (21 * x[n - ceil(i / 2)] + 22 * x[n - ceil(i / 2)] ** 3 + x[n - ceil(i / 2)] ** 2) ** 4
    summ *= 84
    return summ

def main(x):
    res = func(x)
    return res"
"import math

def main(n):
    res = (0.01 - 71 * n[0] * n[0] - 69 * n[7] ** 3) ** 2
    res = res + (0.01 - 71 * n[0] * n[0] - 69 * n[7] ** 3) ** 2
    res = res + (0.01 - 71 * n[0] * n[0] - 69 * n[7] ** 3) ** 2
    res = res + (0.01 - 71 * n[1] * n[1] - 69 * n[6] ** 3) ** 2
    res = res + (0.01 - 71 * n[1] * n[1] - 69 * n[6] ** 3) ** 2
    res = res + (0.01 - 71 * n[1] * n[1] - 69 * n[6] ** 3) ** 2
    res = res + (0.01 - 71 * n[2] * n[2] - 69 * n[5] ** 3) ** 2
    res = res + (0.01 - 71 * n[2] * n[2] - 69 * n[5] ** 3) ** 2
    return 29 * res"
"import math

def main(x, y):
    sum = 0
    n = len(x)
    for i in range(1, n + 1):
        rez1 = x[math.ceil(i) - 1]
        rez2 = y[math.ceil(i / 4) - 1]
        sum += (2 * rez1 ** 2 + 91 * rez2) ** 2
    return sum"
"import math

def main(y, x):
    res = 0
    for i in range(1, len(y) + 1):
        res += math.sin(y[len(y) - math.ceil(i / 2)] ** 3 / 72 - 77 * y[len(y) - math.ceil(i / 3)] - x[len(y) - i] ** 2)
    return 89 * res"
"from math import ceil

def main(x, z, y):
    k = 0
    n = len(x)
    for i in range(1, n + 1):
        k += 44 * (x[n - ceil(i / 3)] - z[n - ceil(i / 2)] ** 2 - 55 * y[ceil(i / 2) - 1] ** 3) ** 2
    return k * 12"
"import math

def main(z, y):
    s = 0
    n = len(z)
    for i in range(0, n):
        s += (76 * z[n - math.ceil((i + 1) / 2)] ** 3 + 48 * y[n - 1 - i]) ** 2
    return 37 * s"
"import math

def main(y):
    n = len(y)
    y.insert(0, 0)
    ans = 0
    for i in range(1, n + 1):
        a = y[math.ceil(i / 2)] ** 2
        b = y[n + 1 - i] / 33
        ans += 72 * (a - b - 1) ** 3
    return ans * 19"
"def main(x, y):
    result = 0
    n = len(y)
    for i in range(1, n + 1):
        result += (x[i - 1] ** 3 + 84 + y[i - 1] ** 2) ** 4 / 27
    return result"
"import math

def main(y, x, z):
    n = len(y)
    result = 0
    for i in range(1, n + 1):
        result += (45 * y[math.ceil(i / 4) - 1] ** 2 + 39 * x[n - math.ceil(i / 2)] + z[n - i] ** 3 / 67) ** 5
    return result * 91"
"import math

def main(x, z, y):
    res = 0
    for i in range(0, len(x)):
        res += math.cos(26 * z[i] ** 2 - 73 * y[i // 3] ** 3 - x[i // 3]) ** 2
    return 20 * res"
"import math

def main(z):
    sum = 0
    n = len(z) - 1
    for i in range(1, n + 2):
        sum += 19 * math.log(z[n + 1 - i] ** 2 / 60) ** 6
    return 45 * sum"
"import math

def main(x, z):
    result = 0
    n = len(x)
    for i in range(1, n + 1):
        result += 16 * (z[n - math.ceil(i / 4)] + x[n - i] ** 3 + z[math.ceil(i / 3 - 1)] ** 2) ** 5
    return result"
"import math

def main(z, x, y):
    result = 0
    for i in range(0, len(z)):
        result = result + 58 * (z[i] + x[i] ** 2 + 17 * y[i] ** 3) ** 4
    return result"
"import math

def main(z, x, y):
    pog = 0
    for i in range(1, len(z) + 1):
        pog += (y[i - 1] - z[len(z) - math.ceil(i / 2)] ** 3 - 78 * x[i - 1] ** 2) ** 3
    return 52 * pog"
"import math as m

def main(z, y, x):
    n = len(z)
    sigma = 0
    for i in range(1, n + 1):
        sigma += (x[n - m.ceil(i / 3)] ** 2 - 82 * z[i - 1] - y[i - 1] ** 3) ** 6 / 72
    return 7 * sigma"
"def main(z, y, x):
    n = len(z)
    a = 0
    for i in range(1, n + 1):
        a += 23 * (34 * y[i - 1] ** 2 + z[i - 1] / 39 + x[i - 1] ** 3) ** 4
    return a"
"import math

def main(z):
    n = len(z)
    ans = 0
    for i in range(1, n + 1):
        a = 0.01
        b = z[0] ** 3
        c = z[i - 1] ** 2
        ans += (a - b - c) ** 6 / 19
    return ans"
"import math

def main(x):
    n = len(x)
    ans = 0
    for i in range(1, n + 1):
        a = 39 * (60 + 27 * x[i - 1] + x[i - 1] ** 3)
        ans += a
    c = ans * 51
    return c"
"import math

def main(z, y):
    result = 0
    n = len(z)
    for i in range(1, n + 1):
        result += (18 * z[math.ceil(i / 4) - 1] ** 3 + 1 + y[n - math.ceil(i / 4)] ** 2) ** 6
    result *= 94
    return result"
"import math

def main(x, y, z):
    n = 2
    num = 0
    for i in range(1, n + 1):
        num += (y[i - 1] ** 3 + 94 * x[math.ceil(i / 4) - 1] ** 2 + 75 * z[n - math.ceil(i / 3)]) ** 3
    result = 74 * num
    return result"
"import math

def main(x):
    result = 0
    n = len(x)
    for i in range(1, n + 1):
        var1 = x[n + 1 - math.ceil(i / 4) - 1]
        var2 = x[n + 1 - math.ceil(i / 4) - 1] ** 3
        result += math.log10(91 + var1 + var2) ** 7
    return result"
"import math

def main(z, x):
    result = 0
    n = len(z)
    for i in range(1, n + 1):
        var1 = 19
        var3 = 90 * x[n - i] ** 2
        var2 = 18 * z[i - 1] ** 3
        result += math.cos(var1 - var2 - var3) ** 3
    return 32 * result"
"import math

def main(yy, xx, zz):
    x = [''] + xx
    z = [''] + zz
    y = [''] + yy
    n = len(x) - 1
    ans = 0
    for i in range(1, n + 1):
        a1 = z[math.ceil(i / 3)] ** 3
        a2 = x[n + 1 - math.ceil(i / 4)]
        a3 = y[math.ceil(i / 4)] ** 2
        ans += (a1 + a2 + a3) ** 4
    c = ans
    return c"
"from math import *

def main(z):
    n = len(z)
    sum1 = 0
    for i in range(1, n + 1):
        sum1 += 17 * atan(74 * z[n - ceil(i / 2)] + 94) ** 2
    return sum1 * 37"
"from math import log10, ceil, sqrt

def main(x, y, z):
    result = 0
    n = len(x)
    for i in range(1, n + 1):
        result += sqrt(x[n - i] - 55 * y[n - ceil(i / 4)] ** 3 - z[i - 1] ** 2) ** 4
    return 50 * result"
"import math

def main(y):
    res = 0
    n = len(y)
    for i in range(1, n + 1):
        res += 87 * math.atan(y[n - math.ceil(i / 2)]) ** 4
    return 65 * res"
"import math

def main(z, y, x):
    n = len(z) - 1
    S = 0
    for i in range(0, n + 1):
        a = 88 * z[n - i]
        b = 10 * x[math.floor(i / 2)] ** 3
        S += 55 * (a - b - y[n - i] ** 2 / 37) ** 3
    return 50 * S"
"def main(y, z, x):
    lst = []
    for i in range(0, len(x)):
        lst.append((18 * z[i] ** 2 + x[i] ** 3 + y[i]) ** 6)
    return sum(lst)"
"import math as mt

def main(y):
    n = len(y)
    sumV = 0
    for i in range(1, n + 1):
        a = y[n - 1 + 1 - mt.ceil(i / 4)] ** 2 / 7
        b = 21 * y[n - 1 + 1 - i] ** 3
        V = 69 * mt.cos(a + b) ** 3
        sumV = sumV + V
    f = 90 * sumV
    return f"
"import math

def main(y, x):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        i -= 1
        res += math.atan(x[i] ** 2 / 59 + 50 * y[i // 4] + y[3 - (i + 1)] ** 3) ** 5
    return res
main([-0.21, -0.18, 0.22], [0.41, -0.07, -0.92])
'\n'"
"import math

def main(z, x, y):
    n = len(z)
    result = 0
    for i in range(1, n + 1):
        result += 9 * (84 * y[math.ceil(i / 3) - 1] - 70 * x[n - math.ceil(i / 2)] ** 2 - z[math.ceil(i / 4) - 1] ** 3) ** 5
    return result"
"import math

def main(y, z, x):
    n = len(y)
    c = 0.0
    for i in range(1, n + 1):
        b = 76 * pow(x[math.ceil(i / 4) - 1], 2)
        a = pow(z[n - math.ceil(i / 3)], 3)
        c += 68 * pow(a + b + 56 * y[i - 1], 5)
    return c"
"import math

def main(x, y):
    n = len(x)
    func = 0
    for i in range(0, n):
        func += (x[i // 2] + 66 * y[n - 1 - i // 4] ** 2) ** 5
    return func"
"def main(y):
    summary = 0
    for i in range(0, len(y), 1):
        summary += y[len(y) - 1] ** 5 / 21
    return summary * 97"
"import math

def main(y: list):
    y.insert(0, 0)
    result = 0
    for i in range(1, 4):
        result += 38 * (1 - y[math.ceil(i / 3)] ** 3 / 25) ** 3
    return result"
"import math

def main(z, x):
    result = 0
    n = len(z)
    for i in range(0, n):
        result += 50 * math.cos(55 * x[n - 1 - i] - 1 - 34 * z[i] ** 2) ** 6
    return result"
"import math

def main(x):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res += 67 * (x[n - math.ceil(i / 4)] ** 3 + 0.01) ** 3
    return res"
"def main(x):
    q = 0
    for i in range(0, len(x)):
        q = q + 66 * (x[i] ** 3 / 38 + x[i] + 69) ** 3
    return q"
"import math

def main(z):
    s = 0
    for i in range(1, len(z) + 1):
        s = s + (z[len(z) - math.ceil(i / 4)] ** 3 - 1) ** 2
    return s"
"import math

def main(x, y, z):
    n = len(x)
    result = 0
    for i in range(1, n + 1):
        result += (z[math.ceil(i / 3) - 1] ** 2 + y[math.ceil(i / 4) - 1] ** 3 + x[math.ceil(i) - 1]) ** 2
    return result"
"import math

def main(y):
    n = len(y)
    result = 0
    for i in range(1, n + 1):
        result += (35 * y[n - i] + y[n - math.ceil(i / 3)] ** 2 + 1) ** 3
    return 66 * result"
"import math

def main(y, x, z):
    result = 0
    n = len(z)
    for i in range(1, n + 1):
        var1 = 72 * y[math.ceil(i / 4) - 1] ** 2
        var2 = z[i - 1] ** 3
        var3 = 55 * x[i - 1]
        result += (var1 - var2 - var3) ** 2 * 13
    return 84 * result"
"from math import *
n = 2

def main(y, x, z):
    value = 0
    for i in range(1, n + 1):
        y_value = y[n + 1 - i - 1]
        z_value = z[n + 1 - ceil(i / 4) - 1]
        x_value = x[ceil(i / 3) - 1]
        value += 7 * y_value ** 2 + z_value ** 3 + 67 * x_value
    return value"
"from math import *
n = 6

def main(z, y):
    value = 0
    for i in range(1, n + 1):
        z_value = z[n + 1 - ceil(i / 3) - 1]
        y_value = y[ceil(i / 2) - 1] ** 3
        value += 42 * (z_value - y_value) ** 5
    return value"
"import math

def main(x, y):
    n = len(x)
    sum = 0
    i = 0
    for i in range(n):
        ii = n - 1 - i // 2
        rab = y[ii]
        rab = 60 * pow(rab, 2) - 3 * x[i]
        rab = math.atan(rab)
        sum = sum + pow(rab, 7)
    return sum"
"import math

def main(n):
    res = 0
    for i in range(1, len(n) + 1):
        res += math.atan(n[len(n) - i] + 50 * n[len(n) - math.ceil(i / 2)] ** 2) ** 7
    return res"
"import math

def main(x):
    n = len(x)
    sm = 0
    for i in range(1, n + 1):
        sm += (x[n - math.ceil(i / 4)] ** 3 / 20) ** 6
    return 88 * sm"
"import math

def main(y):
    res = 0
    for i in range(1, len(y) + 1):
        res += 16 * (62 * y[int((i - 1) / 3)] ** 3 - 35 * y[len(y) - i]) ** 5
    return 83 * res"
"def main(z, y):
    itog = 0
    n = len(z) - 1
    for i in range(1, n + 2):
        chisl1 = y[n + 1 - i] ** 2
        chisl2 = z[n + 1 - i]
        chast1 = chisl1 / 27
        chast2 = chisl2 / 12
        itog = itog + abs(chast1 + chast2) ** 5
    return itog"
"import math

def main(y):
    res = 0
    for i in range(1, len(y) + 1):
        res += 18 * math.exp(92 * y[len(y) - math.ceil(i / 4)]) ** 6
    return 22 * res"
"from math import sin

def main(z):
    i = 0
    a = 0
    while i < 6:
        a = a + 36 * (26 * sin(z[i] - 62 * z[i] ** 3) ** 7)
        i += 1
    return a"
"from math import log, ceil

def main(z: list, x: list, y: list):
    result = 0
    n = len(z)
    for i in range(1, n + 1):
        x_val = 25 * pow(x[ceil(i / 2) - 1], 3)
        y_val = pow(y[ceil(i / 4) - 1], 2)
        z_val = 3 * z[n - ceil(i / 4)]
        result += 4 * 81 * log(x_val + y_val + z_val)
    return result"
"from math import tan, floor

def main(y):
    res = 0
    for i in range(1, len(y) + 1):
        res += tan(y[floor((i - 1) / 4)] ** 3 + 9 + 77 * y[i - 1]) ** 4
    return 14 * res"
"from math import *

def main(z):
    sum_i = 0
    for i in range(1, len(z) + 1):
        sum_i += log(34 * z[floor(i / 3)] + 65 * z[floor(i / 3)] ** 3 + 10) ** 6 / 91
    return sum_i"
"def main(z, x):
    a = 0
    n = len(z) - 1
    for i in range(1, len(z) + 1):
        a = a + (x[n + 1 - i] - z[int(n + 1 - i / 2)] ** 2 - z[n + 1 - i] ** 3)
    return a * 67"
"from math import *

def main(y, z):
    n = len(z)
    sum_i = 0
    for i in range(1, n + 1):
        sum_i += 63 * (y[n - i] ** 3 / 37 + z[n - i] + 43 * z[n - i] ** 2) ** 6
    return sum_i"
"from math import ceil, floor

def main(z, y):
    res = 0
    n = len(z)
    for i in range(1, len(z) + 1):
        res += (3 * z[n - i] ** 2 - z[n - i] ** 3 - 94 * y[n - ceil(i / 3)]) ** 5 / 80
    return 54 * res"
"def main(x, z):
    value = 0
    n = len(x)
    for i in range(1, len(x) + 1):
        value += 88 * (41 * x[n - i] ** 2 + 14 * z[i - 1])
    return 12 * value"
"import math

def main(yy, xx):
    s = 0
    x = [''] + xx
    y = [''] + yy
    n = len(x) - 1
    for i in range(1, n + 1):
        s += 61 * pow(x[i], 2) - pow(y[n + 1 - math.ceil(i / 4)], 3) - 43
    return s"
"import math

def main(y, z, x):
    ans = 0
    n = len(y)
    for i in range(1, n + 1):
        a = 26 * y[n - math.ceil(i / 4)] ** 3
        b = 98 * z[math.ceil(i / 2) - 1] ** 2
        c = 81 * x[math.ceil(i / 4) - 1]
        ans += 60 * math.ceil(a + b + c) ** 3
    return ans"
"import math

def main(x, y, z):
    value = 0
    n = len(y)
    for i in range(0, n):
        a = n - math.ceil((i + 1) / 4)
        temp = 78 * z[a] - 98 * x[n - math.ceil((i + 1) / 3)] ** 3 - 3 * y[i] ** 2
        value += math.pow(math.floor(temp), 3)
    return 83 * value"
"import math

def main(z):
    f = float(0)
    n = len(z)
    for i in range(1, n + 1):
        f += (z[math.ceil(i / 3) - 1] ** 2 - 31 - z[math.ceil(i / 3) - 1] / 86) ** 4
    return f"
"from math import atan

def main(z, x, y):
    n = len(x)
    result = 0
    for i in range(len(x)):
        dif1 = 24 * pow(z[n - i - 1], 2)
        dif2 = x[i // 4]
        dif3 = pow(y[i // 3], 3)
        res_dif = dif1 + dif2 + dif3
        result += 16 * pow(atan(res_dif), 3)
    return result"
"import math

def main(y, z, x):
    ans = 0
    n = len(y)
    for i in range(0, n):
        fun = (y[int(i / 3)] ** 2 - x[n - 1 - i] - z[n - 1 - i] ** 3) ** 4
        ans += fun
    return ans"
"def main(z, y, x):
    res = 0
    for i in range(len(z)):
        res += (y[i] ** 3 + z[i] ** 2 + 85 * x[i]) ** 6
    return res"
"from math import ceil

def main(z):
    res = 0
    n = len(z)
    for i in range(1, len(z) + 1):
        res += (z[n - ceil(i / 4)] ** 2 / 31) ** 5
    return 41 * res"
"def main(z, y):
    s = 0
    n = len(z)
    for i in range(0, n):
        s += (49 * y[i] ** 3 + 14 * y[n - 1 - i] + 60 * z[n - 1 - i] ** 2) ** 5
    return s"
"def main(y, x, z):
    n = len(y)
    result = 0
    for i in range(1, n + 1):
        s = z[i - 1] ** 2 / 52
        m = y[n - i] ** 3
        result += (s - m / 59 - x[i - 1]) ** 7 / 39
    return result"
"import math

def main(y, x):
    n = len(y)
    ans = 0
    for i in range(1, n + 1):
        a = y[math.ceil(i / 2) - 1] ** 2
        b = x[math.ceil(i) - 1] ** 3
        ans += (a - b) ** 3 / 13
    return ans * 45"
"import math

def main(z, x, y):
    res = 0
    for i in range(0, len(x)):
        res += 49 * math.cos(62 * x[i] - y[i] ** 2 - 79 * z[i] ** 3) ** 3
    return res * 16"
"import math

def main(x):
    x = [0] + x
    result = 0
    for i in range(1, len(x)):
        result = result + 93 * math.cos(40 * math.pow(x[len(x) - math.ceil(i / 4)], 2))
    return result * 52"
"import math

def main(z, y):
    result = 0
    for i in range(1, len(z) + 1):
        result += 32 * (1 - 30 * z[math.ceil(i / 3) - 1] - y[len(y) - math.ceil(i / 4)] ** 2) ** 3
    return result"
"import math

def main(y):
    n = len(y)
    s = 0
    for i in range(1, n + 1):
        s += 84 * math.tan(y[n - i] + y[math.ceil(i / 4) - 1] ** 2 + 6 * y[n - math.ceil(i / 3)] ** 3) ** 3
    return s"
"import math

def main(z, x):
    result = 0
    for i in range(0, len(z)):
        result += 23 * (x[i] ** 3 / 16 + z[math.floor(i / 3)] ** 2 + 29 * z[math.floor(i / 3)]) ** 3
    return result * 74"
"import math

def main(x, y):
    result = 0
    n = len(x)
    for i in range(1, n + 1):
        result += (14 * y[math.ceil(i / 4) - 1] + 1 + x[n - i] ** 2) ** 2
    return result"
"import math

def main(x, y):
    s = 0
    for i in range(len(x)):
        s += math.atan(1 + 26 * y[i // 2] ** 3 + x[i] ** 2)
    return s"
"from math import *

def main(x: list, y: list):
    result = 0
    x.append(0)
    y.append(0)
    n = len(y) - 1
    for i in range(0, len(y)):
        result += pow(tan(70 * pow(y[n - ceil(i / 2)], 2) - x[n - ceil(i / 3)]), 7)
    result = 92 * result
    return result"
"import math

def main(x, z):
    ans = 0
    n = len(x)
    for i in range(1, n + 1):
        t1a = pow(x[i - 1], 3)
        t1bind = n + 1 - math.ceil(i / 3)
        t1b = z[t1bind - 1]
        t1c = x[i - 1] * x[i - 1]
        curbody = math.ceil(t1a + t1b + t1c)
        cur = pow(curbody, 4) / 2
        ans += cur
    return ans"
"import math

def main(x):
    sum = 0
    n = len(x)
    for i in range(1, n + 1):
        sum += (x[n - math.ceil(i / 3)] + 6 * x[math.ceil(i / 4) - 1] ** 3 + 0.01) ** 3
    return sum * 18
main([-0.61, 0.44, 0.73, -0.37, -0.59, 0.48, -0.23, -0.43])"
"import math
from math import floor

def main(z, y):
    n = len(z)
    counter = 0
    for i in range(1, n + 1):
        x1 = z[n + 1 - i - 1] ** 2 / 66 + 34 * y[n + 1 - i - 1] ** 3
        x2 = 35 * y[n + 1 - i - 1]
        counter += math.floor(x1 + x2) ** 4 / 88
    return counter"
"from math import ceil

def main(z, x):
    res = 0
    n = len(z)
    for i in range(1, len(z) + 1):
        res += (59 * x[n - ceil(i / 2)] ** 3 - 68 * z[n - ceil(i / 2)] ** 2 - x[n - ceil(i / 2)] / 88) ** 5
    return res / 9"
"from math import exp, ceil

def main(x, z, y):
    res = 0
    n = len(z)
    for i in range(1, len(z) + 1):
        res += 9 * exp(y[n - i] ** 3 + z[ceil(i / 4) - 1] + 41 * x[n - ceil(i / 3)] ** 2) ** 7
    return 17 * res"
"import math

def main(y):
    n = 7
    output = 0
    for i in range(n):
        y_i = math.log(1 + y[i] ** 2 / 74 + y[n - (1 + int(i / 2))] ** 3)
        output += y_i ** 6
    return output"
"import math

def main(y, x, z):
    n = len(y)
    sum = 0
    for i in range(1, n + 1):
        str1 = x[n + 1 - math.ceil(i / 4) - 1] / 95
        str2 = 11 * math.pow(z[i - 1], 2)
        str3 = math.pow(y[math.ceil(i / 3) - 1], 3)
        sum += math.pow(math.sin(str1 - str2 - str3), 5)
    return sum"
"import math

def main(y, x):
    res = 0.0
    for i in range(0, len(x)):
        res += 60 * (1 - x[math.floor(i / 4)] ** 2 / 21 - 27 * y[i]) ** 6
    res *= 93
    return res"
"def main(y, z, x):
    return sum([(z[6 - i] ** 2 / 44 + x[i] + y[6 - i] ** 3) ** 3 for i in range(0, 7)])"
"import math

def main(z):
    sum1 = 0
    n = len(z)
    for i in range(0, n):
        x1 = 1 - z[math.floor(i / 3)]
        x2 = z[math.floor(i / 3)] ** 2 / 29
        sum1 += 59 * (x1 - x2) ** 5
    return sum1"
"import math

def main(x, y):
    n = len(y)
    result = 0
    for i in range(1, n + 1):
        b = y[n - math.ceil(i / 3)] ** 2 + 58 * x[i - 1]
        result += math.sin(b) ** 7
    return 13 * result"
"import math

def main(y):
    s1 = 0.0
    n = len(y) - 1
    for i in range(1, n + 2):
        s1 += 79 * math.tan(y[n + 1 - i] ** 2 - y[n + 1 - i] ** 3) ** 3
    return 68 * s1"
"import math

def main(y):
    sum1 = 0
    n = len(y)
    for i in range(0, n):
        sum1 += (98 * y[n - 1 - i] + y[n - 1 - i] ** 2) ** 3 / 6
    z = 73 * sum1
    return z"
"def main(z):
    n = len(z)
    answer = 0
    for i in range(n):
        answer += (z[i] ** 3 + 1 + z[i] ** 2) ** 3
    return answer"
"import math

def main(x, z, y):
    result = 0
    n = len(x)
    for i in range(n):
        y_i = i // 2
        x_i = i // 2
        z_i = i
        result += series_elem(x[x_i], y[y_i], z[z_i])
    return result * 34 / 8

def series_elem(x, y, z):
    return math.atan(y ** 2 / 55 + x ** 3 / 63 + 42 * z)"
"from math import ceil

def main(y, z):
    n = len(y)
    res = 0
    for i in range(1, len(y) + 1):
        res += abs(7 * z[n - i] ** 3 + 95 * y[n - ceil(i / 4)] + 1) ** 7
    return res"
"import math

def main(z):
    n = len(z)
    result = 0
    for i in range(1, n + 1):
        result += 22 * math.floor(21 * z[n - math.ceil(i / 3)] + 0.01) ** 5
    return result"
"import math

def main(y, z):
    n = len(y)
    result = 0
    for i in range(1, n + 1):
        result += 9 * 17 * (y[n - math.ceil(i / 4)] ** 3 + z[n - i]) ** 3
    return result"
"import math

def main(y, x):
    n = len(y)
    f = 0
    for i in range(n):
        if i == 0:
            f += math.pow(x[math.ceil(i / 4)] + 1 + math.pow(y[n - 1 - i], 3), 2)
        else:
            f += math.pow(x[math.ceil(i / 4) - 1] + 1 + math.pow(y[n - 1 - i], 3), 2)
    return f"
"def main(z, x, y):
    sum = 0
    n = 3
    for i in range(0, n + 1):
        sum += 40 * (77 * y[n - i] ** 2 - z[i] ** 3 - 85 * x[i // 2]) ** 3
    return 43 * sum"
"import math

def main(x, z):
    summ = 0
    n = 5
    for i in range(0, n):
        a = x[n + 1 - math.ceil((i + 1) / 3) - 1] ** 2 / 29
        b = -7 - z[i] ** 3
        summ += (a + b) ** 5
    return summ * 85"
"import math

def main(zz, yy):
    z = [''] + zz
    y = [''] + yy
    n = len(z) - 1
    ans = 0
    for i in range(1, n + 1):
        a = y[n + 1 - math.ceil(i / 3)] ** 3
        b = z[n + 1 - math.ceil(i / 2)] ** 2
        ans += a + b
    c = 10 * ans
    return c"
"import math
from math import ceil

def main(y, z):
    n = len(y)
    result = 0
    for i in range(1, n + 1):
        tmp = 84 * z[i - 1] ** 3 + y[i - 1] ** 2
        result += 74 * (tmp + y[math.ceil(i / 4 - 1)]) ** 6
    return result"
"from math import ceil, atan

def main(z):
    n = [0] * (len(z) + 1)
    answer = 0
    for i in range(len(n)):
        if i != 0:
            n[i] = z[i - 1]
    for i in range(1, len(z) + 1):
        answer += atan(40 - n[len(z) + 1 - i] ** 2 - n[ceil(i / 4)] ** 3) ** 3
    return answer"
"import math

def main(z, x, y):
    n = len(y)
    result = 0
    for i in range(1, n + 1):
        result += 8 * (x[n - i] ** 2 + y[n - math.ceil(i / 2)] ** 3 + z[n - math.ceil(i / 3)])
    return result"
"import math

def main(x, y, z):
    value = 0
    for i in range(0, 7):
        value += 43 * (80 * x[math.ceil(i // 3)] - 90 * z[i] ** 3 - y[math.ceil(i // 2)] ** 2) ** 2
    return value * 84"
"import math

def main(z, x):
    n = len(z)
    result = 0
    for i in range(1, n + 1):
        result += 68 * math.log(x[math.ceil(i / 4) - 1] ** 2 - z[n - math.ceil(i / 2)] ** 3 - z[i - 1]) ** 6
    return result"
"def main(v):
    gs = 0
    for i in range(len(v)):
        s = 0
        s += 0.01 + 69 * v[i] ** 3
        s += 91 * v[i]
        s **= 4
        gs += s
    return gs * 57 * 52"
"def main(z):
    n = len(z)
    return sum((z[n - 1 - i // 4] ** 3 / 76 for i in range(0, n)))"
"def main(x):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res += 35 * (0.02 + x[i - 1] ** 3 + x[i - 1] ** 2) ** 2
    return res"
"import math

def main(z, x):
    num = 0
    for i in range(1, len(x) + 1):
        n = 31 * x[len(x) - i] ** 2 + 5 * x[len(x) - i] + 14 * z[len(z) - math.ceil(i / 4)] ** 3
        num += 12 * n ** 3
    num *= 46
    return num"
"from math import ceil, sqrt

def main(y, z):
    sum_i = 0
    for i in range(1, len(z) + 1):
        a = 74 * y[ceil(i / 2 - 1)] ** 2
        b = 26 * z[ceil(i / 2 - 1)] ** 3
        sum_i += 22 * sqrt(a - b - 0.02) ** 6
    return sum_i"
"from math import ceil

def main(z):
    res = 0
    n = len(z)
    for i in range(1, n + 1):
        res += z[n - ceil(i / 3)] ** 2 - 3 * z[n - ceil(i / 3)]
    return res"
"def main(x):
    res = 0
    n = len(x)
    for i in range(n):
        res += (1 - x[i // 3] ** 2 - x[n - 1 - i // 3]) ** 5
    res1 = 61 * res
    return res1"
"def main(y, x):
    s = 0
    import math
    for i in range(len(x)):
        s = s + math.ceil(y[i] ** 2 + 68 * x[i] ** 3 + 8) ** 2
    return s"
"def main(z):
    res = 0
    n = len(z)
    for i in range(1, n + 1):
        res += (29 * z[n - i] + z[n - i] ** 3) ** 7 / 94
    return res"
"from math import ceil

def main(x, y, z):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res += (x[n - ceil(i / 3)] ** 2 + 22 * y[ceil(i / 2) - 1] ** 3 + z[i - 1]) ** 3
    return 84 * res"
"import math

def main(y, x, z):
    n = 8
    f = 0
    a = 0
    b = 0
    c = 0
    for i in range(1, n + 1):
        a = 23 * z[n + 1 - math.ceil(i / 3) - 1]
        b = x[n + 1 - math.ceil(i / 3) - 1] ** 3 / 65
        c = 80 * y[n + 1 - i - 1] ** 2
        f += a + b + c
    return f
main([-0.58, 0.31, 0.1, -0.87, 0.19, 0.6, 0.27, -0.42], [0.86, 0.56, -0.78, -0.52, -0.56, -0.14, 0.67, 0.89], [-0.52, -0.16, 0.66, 0.17, -0.64, -0.28, -0.46, -0.91])"
"def main(z, y):
    n = len(y)
    return 12 * sum([(z[n - 1 - i] ** 3 + y[int(i / 3)] ** 2 + 58) ** 5 for i in range(0, n)])"
"from math import ceil

def main(z, x):
    n = len(z)
    c = 0
    for i in range(1, n + 1):
        c += 45 * (11 * x[n - ceil(i / 2)] ** 3 + x[n - ceil(i / 2)] ** 2 + z[i - 1]) ** 3
    return 68 * c"
"from math import *
n = 2

def main(y):
    value = 0
    for i in range(1, n + 1):
        y_value = y[ceil(i) - 1]
        value += 43 * (31 + y_value ** 2 / 81 + y_value)
    return value"
"import math

def main(z, x):
    sum = 0
    n = len(x)
    for i in range(n):
        sum += 68 * (82 * x[i] ** 3 - z[i] - 1) ** 4
    return sum"
"import math

def main(x, z):
    n = len(x)
    answer = 0
    for i in range(1, n + 1):
        answer += 49 * math.pow(80 * math.pow(z[n - math.ceil(i / 3)], 2) - math.pow(x[n - i], 3), 4)
    return 76 * answer"
"import math

def main(*x):
    f = 0
    n = len(*x) - 1
    for i in range(0, n + 1):
        f += 7 * (x[0][n - i // 2] + x[0][n - i // 2] ** 2 / 12 + 64) ** 5
    f = 75 * f
    return f"
"import math

def main(z):
    r1 = 0
    n = len(z)
    z.insert(0, 0)
    for i in range(1, len(z)):
        r1 += 4 * (z[math.ceil(i / 2)] ** 3 - z[i] ** 2) ** 4
    return r1
main([-0.31, -0.6, 0.42, -0.98])"
"import math

def main(z, x, y):
    _sum = 0.0
    n = len(z)
    for i in range(1, n + 1):
        first = 92 * z[n - i] ** 2
        second = 95 * y[i - 1]
        third = x[int((i - 1) / 2)] ** 3
        _sum += math.tan(first + second + third) ** 6
    return _sum"
"import math

def main(y):
    n = len(y)
    sum = 0
    for i in range(0, n):
        sum += 76 * math.asin(y[n - 1 - i // 2] + 10 * y[n - 1 - i // 2] ** 3) ** 2
    return sum"
"def main(x, y, z):
    n = len(x)
    ans = 0
    for i in range(0, n):
        ans += (y[i] + z[i // 4] ** 2 / 69 + x[n - 1 - i] ** 3) ** 2
    return ans"
"def main(x, z):
    ans = 0
    for i in range(len(x)):
        a = x[len(x) - i // 4 - 1]
        b = z[len(z) - i - 1]
        ans += (66 + a ** 3 + b / 87) ** 4 / 45
    ans *= 85
    return ans
main([0.45, 0.12, 0.75, -0.64, 0.86, 0.43, 0.7], [-0.57, -0.3, 0.98, 0.23, -0.27, 0.87, -0.98])"
"from math import *

def main(x, y):
    sum2 = 0
    n = len(x)
    for i in range(1, n + 1):
        sum2 += 29 * (x[n - ceil(i / 4)] / 37 + 16 * y[ceil(i / 3) - 1] ** 2 + 54 * y[ceil(i / 3) - 1] ** 3) ** 5
    return 24 * sum2"
"def main(y, x, z):
    summ = 0
    n = len(x)
    for i in range(0, n):
        summ += 79 * (z[0] + y[n - 1 - i] ** 2 + x[n - 1 - i] ** 3)
    return summ * 97"
"import math

def main(z, y):
    n = len(z)
    res = 0
    for i in range(1, n + 1):
        let1 = z[n - i] ** 2 / 64
        let2 = 6 * y[i - 1] ** 3
        res += 31 * math.log(let1 - 1 - let2) ** 7
    return res"
"from math import ceil

def main(Y):
    return sum([100 * (23 * x ** 3 - 89 * x - x ** 2) ** 6 for x in Y[4:]])"
"def main(x, y):
    n = len(x)
    z = 0
    for i in range(1, n + 1):
        z += (y[n + 1 - i - 1] / 92 + x[n + 1 - i - 1] ** 3) ** 4
    return z"
"import math

def main(z, x, y):
    n = len(z)
    a = 0
    for i in range(1, n + 1):
        a += (y[i - 1] ** 3 - z[math.ceil(i / 3) - 1] - x[i - 1] ** 2) ** 3
    return 94 * a"
"from math import ceil

def main(x, y):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res += (y[n - ceil(i / 4)] + x[n - ceil(i / 4)] ** 3) ** 3
    return 86 * res"
"from math import ceil

def main(y):
    f = 0
    n = len(y)
    for i in range(n):
        f += (y[n + 1 - ceil((i + 1) / 3) - 1] ** 3 - y[n + 1 - ceil((i + 1) / 3) - 1]) ** 2
    f *= 76
    return f"
"import math

def main(z):
    sum = 0
    n = len(z)
    for i in range(1, n + 1):
        sum += 69 * math.floor(1 + z[math.ceil(i / 4 - 1)] ** 3 + 41 * z[math.ceil(i / 4 - 1)] ** 2) ** 5
    return 54 * sum"
"import math

def main(y):
    x = 0
    for i in range(1, len(y) + 1):
        x += 58 * (y[math.ceil(i / 3) - 1] ** 2 + y[len(y) - math.ceil(i / 2)] + 59 * y[len(y) - i] ** 3)
    return x"
"from math import ceil

def main(y):
    result = 0
    for i in range(1, len(y) + 1):
        result += (78 * y[ceil(i / 2) - 1] ** 3 - y[ceil(i / 2) - 1] ** 2 / 54) ** 5 / 46
    return 95 * result"
"from math import ceil

def main(y, z, x):
    res = 0
    n = 3
    for i in range(0, n):
        a = 22 * z[i] ** 2
        b = 4 * x[i] ** 3
        c = 44 * y[ceil((i - 1) / 2)]
        res += (a - b - c) ** 2
    res *= 36
    return res"
"def main(z, x):
    import math
    z.insert(0, 0)
    x.insert(0, 0)
    ii = 1
    s = 0
    n = 5
    a = 0
    for i in range(1, n + 1):
        s = abs(x[math.ceil(i / 3)] ** 2 / 93 + z[math.ceil(i / 2)] + 1) ** 2
        a = a + 80 * s
    return a"
"import math

def main(y, x, z):
    res = 0
    for i in range(1, len(y) + 1):
        res += (26 * x[i - 1] ** 2 + 30 * z[len(y) - math.ceil(i / 3)] + y[len(y) - i] ** 3) ** 6
    return 37 * res"
"def main(x):
    a = 0
    for i in range(1, len(x) + 1):
        a = a + (64 * x[len(x) - i] - x[len(x) - i] ** 2) ** 5
    return 15 * a"
"def main(arr):
    funk_rank_high = 0
    for i in arr:
        rank_low = pow(i, 2) + 50
        rank_high = pow(rank_low, 4)
        funk_rank_low = 67 * rank_high
        funk_rank_high += funk_rank_low
    f = 71 * funk_rank_high
    return f"
"import math

def main(xx):
    x = [''] + xx
    n = len(x) - 1
    res = 0
    for i in range(1, n + 1):
        a = 28 * x[n + 1 - i]
        b = x[n + 1 - i] ** 3
        c = 10 * (a + b + 1) ** 5
        res += c
    ans = res
    return ans"
"import math

def main(z):
    n = len(z)
    sum = 0
    for i in range(1, n + 1):
        sum += (1 + 86 * z[math.ceil(i / 3) - 1] ** 3 + z[math.ceil(i / 3) - 1] ** 2 / 67) / 66
    return sum"
"import math

def main(y, x, z):
    f = 0
    n = len(y)
    for i in range(1, n + 1):
        k = y[math.ceil(i / 4) - 1]
        h = 65 * z[math.ceil(i) - 1] ** 2
        u = x[math.ceil(i / 3) - 1] ** 3
        f += (k - h - u) ** 3
    return 73 * f"
"import math

def main(x, y, z):
    n = len(z)
    value = 0
    for i in range(0, n):
        res = math.pow(y[n - (i + 1)], 2)
        res += -z[i] - math.pow(x[n - math.ceil((i + 1) / 4)], 3)
        value += math.pow(res, 5)
    return 70 * value"
"import math

def main(z):
    sum1 = 0
    n = len(z) - 1
    for i in range(1, n + 2):
        sum1 += 35 * (1 - z[n + 1 - i] ** 3 - z[n + 1 - math.ceil(i / 2)]) ** 3
    z = 7 * sum1
    return z"
"import math as m

def main(z):
    result = 0
    n = len(z)
    for i in range(0, n):
        result += 85 * m.log2(z[i] + 1 + z[n - 1 + 1 - (i + 1)] ** 3) ** 6
    return 55 * result"
"import math

def main(arr):
    summary = 0
    indx = 0
    for indx in range(len(arr)):
        indx = math.ceil(indx // 3)
        i = arr[indx]
        pow_low = pow(i, 3)
        stap = pow_low + i
        arctg = math.atan(stap)
        pow_high = pow(arctg, 7)
        summary += pow_high
    f = 96 * summary
    return f"
"from math import sin, ceil

def main(y, x, z):
    res = 0
    n = len(y)
    for i in range(1, n + 1):
        res += 59 * sin(y[n - i] + 18 * x[n - i] ** 2 + z[n - ceil(i / 2)] ** 3) ** 5
    return 86 * res"
"from math import *

def main(y, x):
    n = len(y)
    sum = 0
    for i in range(0, n):
        sum += y[i] - 4 * pow(x[i // 4], 2) - 1
    return 60 * sum"
"from math import *

def main(y, z, x):
    n = len(y)
    a = 0
    for i in range(1, n + 1):
        a = a + (14 * x[i - 1] + 80 * y[ceil(i / 3) - 1] ** 3 + z[n - ceil(i / 3)] ** 2) ** 2
    return a * 17"
"import math

def main(x, y):
    n = len(x)
    a = 0
    for i in range(1, n + 1):
        a += 82 * math.log(y[i - 1] ** 2 + 37 * x[i - 1] ** 3) ** 6
    return a"
"import math

def main(zz, yy, xx):
    x = [''] + xx
    z = [''] + zz
    y = [''] + yy
    n = len(x) - 1
    ans = 0
    for i in range(1, n + 1):
        a1 = 62 * x[math.ceil(i / 3)] ** 2
        a2 = 4 * y[n + 1 - math.ceil(i / 2)] ** 3
        a3 = z[i]
        ans += (a1 - a2 - a3) ** 2
    c = 54 * ans
    return c"
"import math

def main(yy, xx):
    x = [''] + xx
    y = [''] + yy
    n = len(x) - 1
    ans = 0
    for i in range(1, n + 1):
        a1 = 79 * x[n + 1 - i]
        a2 = 77 * y[n + 1 - math.ceil(i / 2)] ** 2
        ans += a1 + a2
    c = 25 * ans
    return c"
"import math

def main(y, x, z):
    b = 0
    for i in range(1, len(z) + 1):
        r = x[len(x) - math.ceil(i / 2)] ** 2
        w = r + z[len(z) - math.ceil(i / 2)] ** 3 + y[len(y) - math.ceil(i / 4)]
        q = 61 * math.floor(w) ** 6
        b = b + q
    return b"
"import math

def f(y, z):
    res = 0
    n = len(y)
    for i in range(2, n + 2):
        res += 58 * (z[n + 1 - i] ** 2 - 1 - y[math.ceil((i - 1) / 2) - 1] / 20) ** 7
    return res

def main(y, z):
    return f(y, z)"
"import math

def main(y, x):
    f = 0
    for i in range(1, len(y) + 1):
        f += (29 - x[i - 1] - 65 * y[len(y) - math.ceil(i / 3)] ** 3) ** 5
    return f * 14"
"import math as m

def main(x):
    A = 0
    n = len(x)
    for i in range(1, n + 1):
        A += 68 * (34 * x[n - m.ceil(i / 4)] ** 2 + 38) ** 7
    return A"
"import math

def main(y):
    n = len(y)
    ans = 0
    for i in range(0, n):
        ans += (y[math.floor(i / 2)] ** 2 + 76 * y[math.floor(i / 2)] ** 3) ** 4 / 39
    return ans"
"import math

def main(x, z):
    sum = 0
    n = 3
    for i in range(3):
        sum += math.cos(68 * z[i // 4] ** 2 - x[2 - i // 2] - 79 * x[2 - i] ** 3) ** 3
    return 28 * sum"
"import math

def main(z, y, x):
    n = 8
    f = 0
    a = 0
    b = 0
    c = 0
    for i in range(1, n + 1):
        a = x[n + 1 - math.ceil(i / 2) - 1] ** 2
        b = y[n + 1 - i - 1] ** 3
        c = 98 * z[n + 1 - math.ceil(i / 2) - 1]
        f += math.ceil(a + b + c)
    f = f * 70
    return f
main([-0.66, -0.44, 0.34, -0.62, 0.58, 0.35, 0.86, -0.77], [-0.25, 0.48, 0.15, -0.23, -0.72, 0.34, -0.61, -0.14], [-0.26, 0.67, -0.7, 0.86, 0.12, 0.39, 0.2, 0.49])"
"from math import ceil

def main(y, z, x):
    res = 0
    n = len(y)
    for i in range(1, n + 1):
        res += 2 * (y[i - 1] ** 2 + z[n - ceil(i / 2)] + x[n - i] ** 3) ** 4
    return 89 * res"
"def main(y):
    res = 0
    n = len(y)
    for i in range(1, n + 1):
        res += 43 * (41 * y[i - 1] + 1 + y[i - 1] ** 2) ** 3
    return 10 * res"
"import math

def main(vector):
    result = 0
    n = len(vector)
    for i in range(1, n + 1):
        temp1 = vector[n - i]
        temp2 = vector[math.floor((i - 1) / 2)]
        result += 64 * pow(temp1 ** 2 / 73 - temp2 / 79 - 1, 4)
    return result
main([-0.46, -0.11, 0.3, -0.12, -0.67])
main([-0.1, 0.05, 0.97, 0.94, 0.15])"
"import math

def main(z, x, y):
    sum1 = 0
    for i in range(1, len(z) + 1):
        sum1 += (z[len(z) - i] ** 2 + y[math.ceil(i / 3) - 1] + x[math.ceil(i / 4) - 1] ** 3) ** 2
    return 19 * sum1"
"import math

def main(x, y):
    res = 0
    for i in range(1, 7):
        res1 = x[math.ceil(i / 3) - 1] / 41
        res2 = pow(y[6 + 1 - math.ceil(i / 2) - 1], 3)
        res += pow(res1 - res2, 6)
    return res"
"import math as m

def main(x, z, y):
    n = len(x)
    x.insert(0, 0)
    z.insert(0, 0)
    y.insert(0, 0)
    A = 0
    for i in range(1, n + 1):
        A += 58 * (45 * y[n + 1 - m.ceil(i / 3)] ** 2 - z[m.ceil(i / 2)] ** 3 - x[i]) ** 2
    return 3 * A"
"import math

def main(*args):
    y = list(args[0])
    n = len(y)
    i = 1
    sum = 0
    while i <= n:
        sub_sum = 99 * math.pow(91 * math.pow(y[n - i], 3) - y[n - math.ceil(i / 2)], 4)
        sum += sub_sum
        i += 1
    return sum * 51
main([-0.03, -0.08])"
"import math

def main(z, y):
    n = len(z)
    s = 0
    z.insert(0, 0)
    y.insert(0, 0)
    for i in range(1, n + 1):
        s += 78 * (y[i] ** 3 - 19 * z[n + 1 - math.ceil(i / 2)] - 53 * z[n + 1 - math.ceil(i / 2)] ** 2) ** 4
    return s"
"import math

def main(z):
    ans = 0
    for i in range(1, len(z) + 1):
        ans += 5 + z[math.ceil(i / 2 - 1)] ** 3 + 46 * z[math.ceil(i / 2 - 1)]
    return ans"
"import math

def main(z, y):
    F = 0
    n = len(y)
    for i in range(1, n + 1):
        F = F + math.pow(math.ceil(math.pow(z[n - i], 3) + y[n - math.ceil(i / 3)] + 64 * math.pow(y[n - math.ceil(i / 2)], 2)), 4)
    return 91 * F"
"import math

def main(x, y, z):
    s = 0
    a = [0]
    a.extend(x)
    b = [0]
    b.extend(y)
    c = [0]
    c.extend(z)
    for i in range(1, len(x) + 1):
        s += 17 * (b[len(x) + 1 - i] ** 2 - a[len(x) + 1 - math.ceil(i / 4)] - c[i] ** 3) ** 3
    return 55 * s"
"from math import ceil

def main(x: list, z: list):
    result = 0
    for i in range(1, len(x) + 1):
        result += 62 * (33 + 80 * z[i - 1] + x[ceil(i / 2) - 1] ** 2) ** 4
    return result * 97"
"from math import sqrt, ceil

def main(y, x, z):
    n = len(y)
    result = 0
    for i in range(1, n + 1):
        result += 73 * sqrt(26 * z[n - ceil(i / 3)] ** 2 + 50 * y[n - ceil(i / 2)] ** 3 + 41 * x[i - 1]) ** 5
    return 14 * result"
"import math

def main(list2, list1, list3):
    summa = 0.0
    for i in range(len(list1)):
        a = pow(pow(list3[i], 2) - 90 * pow(list2[i // 4], 3) - list1[i], 6) / 77
        summa += a
    return summa"
"from math import *

def main(y, z):
    n = len(z)
    ans = 0
    for i in range(1, n + 1):
        a = 9 * y[n + 1 - ceil(i / 4) - 1] ** 3
        b = 35 * z[n + 1 - ceil(i / 3) - 1] ** 2
        ans += 21 * (a - b) ** 6
    return ans"
"def main(x, z):
    n = len(z)
    ans = 0
    for i in range(0, n):
        a = 60 * z[i] ** 3
        b = x[i] ** 2
        ans += (a + b) ** 5
    return ans * 90"
"from math import ceil

def main(y):
    res = 0
    n = len(y)
    for i in range(1, n + 1):
        res += (y[ceil(i / 3) - 1] + y[n - ceil(i / 4)] ** 2 / 37) ** 3 / 29
    return res"
"import math

def main(x, y, z):
    ans = 0
    n = len(x)
    for i in range(1, n + 1):
        a = 18 * z[n - math.ceil(i / 3)] ** 2
        b = y[n - math.ceil(i / 3)] ** 3 / 45
        c = x[math.ceil(i / 2) - 1]
        ans += 76 * (a + b + c) ** 2
    return 9 * ans"
"def main(y):
    n = len(y)
    sum = 0
    for i in range(n):
        inside1 = y[n - int(i / 2) - 1]
        inside2 = -59 * y[i] ** 3 - y[n - int(i / 2) - 1] ** 2
        inside = inside1 + inside2
        sum += 74 * inside ** 2
    answer = 33 * sum
    return answer"
"import math

def main(z, x):
    n = len(z)
    sum1 = 0
    for i in range(n):
        aa = 0.09 + x[i] + z[n - int(i / 2) - 1] ** 2
        sqrtaa = math.sqrt(aa) ** 4
        sum1 += sqrtaa
    return sum1 * 7"
"def main(z):
    n = 7
    value = 0
    for i in range(1, n + 1):
        z_value_1 = 71 * z[n + 1 - i - 1] ** 3 - 34
        z_value_2 = 92 * z[n + 1 - i - 1] ** 2
        value += z_value_1 - z_value_2
    return 43 * value"
"import math

def main(lst):
    res = 0
    for i in range(1, len(lst) + 1):
        res += 60 * pow(math.log(1 + 29 * pow(lst[len(lst) - math.ceil(i / 3)], 2), math.e), 4)
    return res"
"import math

def main(x):
    a = 0
    for i in range(1, len(x) + 1):
        a += math.atan(x[len(x) + 1 - math.ceil(i / 4) - 1] ** 2 / 15) ** 7
    return a"
"from math import ceil

def main(y, x, z):
    n = len(y)
    res = 0
    for i in range(1, n + 1):
        res += (z[i - 1] ** 2 - x[i - 1] - y[ceil(i / 4) - 1] ** 3) ** 2 / 63
    return res"
"from math import ceil

def main(z, y, x):
    n = len(y)
    res = 0
    for i in range(1, n + 1):
        res += (30 * y[n - ceil(i / 3)] ** 2 - z[ceil(i / 3) - 1] ** 3 - x[n - i] / 43) ** 2
    return res"
"from math import cos, ceil

def main(x, z, y):
    n = len(y)
    res = 0
    for i in range(1, n + 1):
        res += 87 * cos(25 * y[ceil(i / 2) - 1] + 64 * x[n - i] ** 3 + 36 * z[n - i] ** 2)
    return res"
"from math import ceil

def main(x, y):
    res = 0
    for i in range(1, len(y) + 1):
        res += 31 * (65 * y[i - 1] ** 2 - x[ceil(i / 3) - 1]) ** 7
    return res"
"import math

def main(*args):
    y = list(args[0])
    n = len(y)
    i = -2
    sum = 0
    while i < n - 2:
        sub_sum = math.pow(y[math.ceil(i / 3)] - 0.2 - 58 * math.pow(y[math.ceil(i / 3)], 2), 2)
        sum += sub_sum
        i += 1
    return sum * 88
main([0.9, 0.37, -0.22, -0.57])"
"def main(x, y, z):
    n = len(x)
    a = 0
    for i in range(1, n + 1):
        a += (76 * z[i - 1] + x[n - i] ** 2 + y[n - i] ** 3) ** 7
    return 67 * a"
"def main(n):
    sm = 0
    for i in range(0, len(n)):
        sm += 2 * (74 * n[i] + 68 + pow(n[i], 2))
    return 64 * sm"
"from math import floor

def main(z, y):
    n = len(z)
    a = 0
    for i in range(1, n + 1):
        a += 34 * (z[floor((i - 1) / 4)] ** 2 + y[n - i]) ** 2
    return 94 * a"
"def main(x):
    n = len(x)
    a = 0
    for i in range(1, n + 1):
        a += (88 * x[i - 1] ** 3 + x[i - 1] + 52) ** 2
    return a"
"import math

def main(z, y, x):
    n = len(z)
    ans = 0
    for i in range(1, n + 1):
        a = 54 * x[n + 1 - math.ceil(i) - 1] ** 2
        b = 92 * y[math.ceil(i / 2) - 1]
        c = z[n + 1 - math.ceil(i) - 1] ** 3
        ans += (a - b - c) ** 5 / 72
    return ans"
"from math import *

def main(x, z, y):
    ans = 0
    n = len(z)
    for i in range(1, n + 1):
        a = 51 * x[i - 1] ** 3
        b = 92 * y[i - 1] ** 2
        c = z[n + 1 - ceil(i / 2) - 1] / 68
        ans += (a + b + c) ** 4
    return ans"
"from math import log

def main(y, z):
    n = len(y)
    a = 0
    for i in range(1, n + 1):
        a += 95 * log(1 + 31 * y[i - 1] ** 2 + 70 * z[n - i] ** 3) ** 4
    return a"
"import math

def main(x, z):
    n = len(x)
    y = [0]
    z = y + z
    x = y + x
    res = 0
    for i in range(1, n + 1):
        res += 91 * math.fabs(z[n + 1 - i] ** 2 - x[math.ceil(i / 4)] ** 3) ** 6
    return 30 * res"
"def main(x, y):
    n = len(x)
    ans = 0
    for i in range(0, n):
        ans += (y[i] + x[i] ** 3 + 1) ** 2
    ans *= 56
    return ans"
"import math

def summ(_y, _x):
    result = 0
    n = len(_x)
    for i in range(1, n + 1):
        interaction = 0
        interaction += _y[n - math.ceil(i / 4)]
        interaction += 44
        interaction += _x[i - 1] ** 2
        result += interaction ** 2
    return result

def main(y, x):
    return 46 * summ(y, x)"
"from math import floor

def main(z):

    def f(i, x):
        return x[len(x) - (floor(i / 2) + 1)] + 90 * x[len(x) - (floor(i / 2) + 1)] ** 3
    res = 66 * sum((18 * (0.01 + f(i, z)) ** 6 for i in range(0, len(z))))
    return float('%.3g' % res)"
"import math

def main(x, z):
    sum = 0
    for i in range(len(x)):
        sum += 84 * (z[i] - 13 * x[i] ** 3 - 1) ** 6
    return sum"
"import math

def main(*x):
    f = 0
    n = len(*x) - 1
    for i in range(1, n + 2):
        f += 42 * (pow(x[0][n + 1 - i], 2) / 73 - x[0][n + 1 - math.ceil(i * 0.25)] - 44) ** 2
    return f"
"def main(y, x):
    return 41 * sum([77 * abs(7 * y[i] + 1 + x[i // 4] ** 3) ** 7 for i in range(0, len(y))])"
"from math import *

def main(z):
    n = len(z)
    ans = 0
    for i in range(1, n + 1):
        a = z[n + 1 - ceil(i) - 1] ** 3
        b = 56 * z[n + 1 - ceil(i) - 1] ** 2
        ans += (a + b) ** 7
    return ans * 48"
"import math

def main(x, y):
    summ = 0
    summ += (x[7 + 1 - math.ceil(1 / 4)] + 3 * y[6 + 1 - 0] ** 3 + 17) ** 3
    summ += (x[7 + 1 - math.ceil(2 / 4)] + 3 * y[6 + 1 - 1] ** 3 + 17) ** 3
    summ += (x[7 + 1 - math.ceil(3 / 4)] + 3 * y[6 + 1 - 2] ** 3 + 17) ** 3
    summ += (x[7 + 1 - math.ceil(4 / 4)] + 3 * y[6 + 1 - 3] ** 3 + 17) ** 3
    summ += (x[7 + 1 - math.ceil(5 / 4)] + 3 * y[6 + 1 - 4] ** 3 + 17) ** 3
    summ += (x[7 + 1 - math.ceil(6 / 4)] + 3 * y[6 + 1 - 5] ** 3 + 17) ** 3
    summ += (x[7 + 1 - math.ceil(7 / 4)] + 3 * y[6 + 1 - 6] ** 3 + 17) ** 3
    summ += (x[7 + 1 - math.ceil(8 / 4)] + 3 * y[6 + 1 - 7] ** 3 + 17) ** 3
    summ *= 13
    return summ"
"def main(z, y, x):
    n = len(z)
    res = 0
    for i in range(1, n + 1):
        res += (x[n - i] ** 2 + 23 * z[n - i] ** 3 + 61 * y[n - i]) ** 2
    res = res * (69 / 87)
    return res"
"from math import *

def main(x, y, z):
    result = 0
    n = len(x)
    for i in range(1, n + 1):
        result += 71 * (z[n - ceil(i / 2)] ** 3 - x[i - 1] ** 2 - 78 * y[ceil(i / 4) - 1]) ** 5
    return result"
"from math import ceil

def main(z, y, x):
    res = 0
    n = len(z)
    for i in range(1, n + 1):
        res += 92 * abs(2 * x[i - 1] ** 2 + z[n - ceil(i / 2)] + y[ceil(i / 4) - 1] ** 3) ** 2
    return res"
"import math

def main(y, z):
    f = 0
    for i in range(7):
        f += 36 * math.pow(y[i] ** 3 - 78 * y[i] ** 2 - 2 * z[i], 4)
    return f"
"def main(y, z):
    return 42 * sum([(z[i] ** 2 + 82 * y[len(y) - 1 - i] + 0.02) ** 7 for i in range(0, len(y))])"
"from math import ceil

def main(y, z):
    n = len(y)
    res = 0
    for i in range(1, n + 1):
        a = 84 * y[n - ceil(i / 4)]
        b = 29 * z[n - ceil(i / 4)] ** 2
        c = z[n - ceil(i / 4)] ** 3
        res += (a + b + c) ** 4
    return 83 * res"
"from math import *

def main(x):
    n = len(x)
    _sum = 0
    for i in range(1, n + 1):
        _sum += 12 * asin(2 * x[n - i] ** 2) ** 5
    return _sum"
"import math

def main(x, y):
    sum1 = 0
    n = len(x)
    for i in range(1, n + 1):
        sum1 += (14 * y[math.ceil(i / 4) - 1] ** 2 + y[math.ceil(i / 3) - 1] + x[n - math.ceil(i / 4)] ** 3) ** 6
    sum1 *= 75
    return sum1
main([-0.74, 0.81, 0.17, 0.43, -0.62], [0.58, -0.75, 0.73, 0.44, 0.87])"
"import math

def main(y, z, x):
    s = 0
    n = len(y)
    for i in range(0, n):
        s = s + 24 * math.floor(z[i] ** 2 / 23 + 99 * x[math.floor(i / 3)] + y[i] ** 3 / 9) ** 3
    return 74 * s"
"from decimal import Decimal

def main(x):
    ans = 0
    for i in range(len(x)):
        ans += 20 * (18 - 56 * x[i] ** 2 - 88 * x[len(x) - 1 - i]) ** 6
    return ans * 28"
"from math import ceil, log2

def main(y, x, z):
    res = 0
    k = [0] * (len(x) + 1)
    t = [0] * (len(x) + 1)
    m = [0] * (len(x) + 1)
    for i in range(len(t)):
        if i != 0:
            k[i] = x[i - 1]
            t[i] = y[i - 1]
            m[i] = z[i - 1]
    for i in range(1, len(y) + 1):
        tmp = 5 * t[len(y) + 1 - i] ** 3
        res += log2(m[ceil(i / 3)] ** 2 + k[i] / 37 + tmp)
    return res"
"from math import ceil

def main(z, x):
    my_sum = 0
    n = len(z) - 1
    for i in range(1, len(z) + 1):
        my_sum += 5 * pow(pow(x[n + 1 - ceil(i / 2)], 3) / 15 - z[n + 1 - i], 2)
    return 69 * my_sum"
"import math

def main(y, x, z):
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 2 * y[math.ceil(i / 2)]
        middle = 17 * x[n + 1 - math.ceil(i / 4)] ** 2
        right = 56 * z[math.ceil(i / 2)] ** 3
        total += 88 * (left + middle + right) ** 6
    return 69 * total"
"import math

def main(z, y, x):
    n = len(z)
    y.insert(0, 0)
    x.insert(0, 0)
    z.insert(0, 0)
    sum = 0
    for i in range(1, n + 1):
        a = 34 * z[n + 1 - i] ** 3
        b = y[math.ceil(i / 2)] ** 2
        c = x[n + 1 - math.ceil(i / 3)]
        sum += (a + b + c) ** 6 / 17
    return sum"
"from math import ceil

def main(x):
    res = 0
    for i in range(1, len(x) + 1):
        res += 27 * (67 * x[ceil(i / 2) - 1] - x[ceil(i / 4) - 1] ** 2 - 38 * x[ceil(i / 2) - 1] ** 3) ** 3
    return 90 * res"
"from math import ceil, log2

def main(x):
    n = len(x)
    a = 0
    for i in range(1, n + 1):
        a += (30 + x[n - i] ** 2 + x[ceil(i / 2) - 1] ** 3) ** 6
    return a"
"import math

def main(z):
    n = len(z)
    summa = 0
    for i in range(0, n):
        e = z[n + 1 - abs(i // 3) - 2]
        summa += 51 * math.pow(math.asin(e / 39), 4)
    return 91 * summa"
"import math

def main(x, z, y):
    n = len(x)
    x.insert(0, 0)
    z.insert(0, 0)
    y.insert(0, 0)
    summa = 0
    for i in range(1, n + 1):
        e1 = z[n + 1 - i]
        e2 = x[i]
        e3 = y[i]
        a = 88 * math.pow(9 * e1 ** 3 - 9 * e2 - e3 ** 2, 7)
        summa += a
    return summa"
"import math

def main(z):
    ans = 0
    n = len(z)
    for i in range(1, n + 1):
        ans += (z[math.ceil(i / 2) - 1] + z[math.ceil(i / 2) - 1] ** 3 + 27) ** 7
    return 25 * ans"
"def main(z, x, y):
    ans = 0
    n = len(z)
    for i in range(1, n + 1):
        ans += 32 * (86 * x[i - 1] - y[n - i] ** 2 - 46 * z[n - i] ** 3) ** 2
    return 50 * ans"
"import math

def main(z):
    ans = 0
    n = len(z)
    for i in range(1, n + 1):
        ans += 59 * (z[n - i] ** 3 - 28 * z[n - math.ceil(i / 4)] ** 2) ** 6
    return 99 * ans"
"import math

def main(y, x, z):
    ans = 0
    n = len(z)
    for i in range(1, n + 1):
        ans += 57 * (45 * y[i - 1] ** 3 - 88 * x[n - math.ceil(i / 4)] - 16 * z[math.ceil(i / 2) - 1] ** 2) ** 6
    return 97 * ans"
"from math import ceil

def main(y, x):
    sum = 0
    n = len(y)
    for i in range(1, n + 1):
        sum += (35 + x[n - ceil(i / 4)] ** 2 + 79 * y[ceil(i / 4) - 1] ** 3) ** 4 / 93
    return 22 * sum"
"from math import ceil

def main(y, x):
    f = 0
    n = len(y)
    for i in range(1, n + 1):
        f += 19 * (61 * y[n + 1 - ceil(i / 4) - 1] + x[n + 1 - ceil(i / 3) - 1] ** 2 + 76) ** 4
    return f"
"import math

def main(z):
    n = len(z)
    z.insert(0, 0)
    t = 0
    for i in range(1, n + 1):
        f1 = z[math.ceil(i / 2)] ** 3
        f2 = -z[math.ceil(i / 2)] ** 2
        t += 61 * math.exp(f1 + f2) ** 4
    return 59 * t"
"import math

def main(y):
    f = 0
    n = len(y)
    for i in range(0, n):
        f += 85 * abs(y[n - 1 - int(i / 3)]) ** 5
    return f"
"from math import ceil

def main(y, x, z):
    a = 0
    n = len(y)
    for i in range(1, n + 1):
        b = 94 * z[n - ceil(i / 2)] ** 3
        c = y[ceil(i / 3) - 1] / 45
        d = x[i - 1] ** 2
        a += 56 * (b + c + d) ** 7
    return 20 * a"
"import math

def main(z, y, x):
    ans = 0
    n = len(z) - 1
    for i in range(1, n + 2):
        ans += math.cos(y[n + 1 - i] ** 3 + 6 * x[n + 1 - math.ceil(i / 2)] + z[n + 1 - math.ceil(i / 2)] ** 2) ** 4
    return 12 * ans"
"import math

def main(y, z):
    n = len(y)
    y.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = y[n + 1 - math.ceil(i / 4)] ** 3
        right = -(z[i] / 29)
        total += (left + right) ** 4
    return 78 * total"
"import math

def main(z):
    res = 0
    for i in range(1, len(z) + 1):
        a = math.sin(z[len(z) - math.ceil(i / 2)]) ** 7
        res += a / 52
    return 83 * res"
"from math import ceil

def main(x, z):
    n = len(x)
    tmp = 0
    for i in range(1, n + 1):
        tmp += 17 * pow(pow(x[n + 1 - i - 1], 2) - z[n + 1 - ceil(i / 4) - 1], 2)
    return 7 * tmp"
"from math import *

def main(z, y, x):
    _sum = 0
    n = len(z)
    for i in range(1, n + 1):
        _sum += exp(y[int((i - 1) / 4)] ** 3 - x[i - 1] ** 2 - z[i - 1]) ** 6 / 36
    return 29 * _sum"
"from math import pow, ceil

def main(y, z):
    n = len(y)
    sum_ = 0
    for i in range(1, n + 1):
        sum_ += 14 * (52 * z[ceil(i / 3) - 1] + 4 * pow(y[n - i], 3) + pow(z[n - ceil(i / 2)], 2))
    return 12 * sum_"
"from math import ceil

def main(x):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res += (97 * x[n - ceil(i / 4)] ** 3 - x[n - ceil(i / 4)] ** 2 - 1) ** 4
    return res"
"from math import ceil

def main(y, z):
    res = 0
    n = len(y)
    for i in range(1, n + 1):
        res += 68 * (z[n - i] ** 3 / 27 - y[ceil(i / 4) - 1] ** 2) ** 3
    return res"
"import math

def main(z, y, x):
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = y[n + 1 - i] ** 3 / 70
        middle = 21 * x[n + 1 - i]
        right = z[n + 1 - i] ** 2 / 90
        total += 26 * abs(left + middle + right) ** 5
    return total"
"from math import ceil

def main(z, y, x):
    res = 0
    n = len(z)
    for i in range(1, n + 1):
        res += (z[ceil(i / 4) - 1] + y[n - i] ** 2 + x[n - i] ** 3) ** 5
    return 41 * res"
"import math

def main(z, y):
    n = len(z)
    y.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        value = y[n + 1 - i]
        value_1 = 72 * y[math.ceil(i / 4)] ** 3
        value_2 = z[math.ceil(i / 2)] ** 2
        total += math.log10(value + value_1 + value_2) ** 3 / 53
    return 18 * total"
"import math

def main(x, z):
    n = len(x)
    x.insert(0, 0)
    z.insert(0, 0)
    result = 0
    for i in range(1, n + 1):
        middle = 37 * z[i]
        right = 53 * x[i] ** 3
        result += 31 * (86 + middle + right) ** 5
    return result"
"import math

def main(z):
    n = len(z)
    result = 0
    for i in range(1, n + 1):
        p_1 = z[math.ceil(i / 2 - 1)] ** 2
        p_2 = z[math.ceil(i / 2 - 1)] / 61
        result += 38 * pow(p_1 - p_2, 6)
    return result"
"import math

def main(y):
    _sum = 0
    n = len(y)
    for i in range(1, n + 1):
        _sum += (90 * y[i - 1] ** 2 - y[i - 1] ** 3 - 98) ** 6
    return _sum"
"import math

def main(z, x, y):
    _sum = 0
    n = len(y)
    for i in range(1, n + 1):
        v1 = y[math.ceil(i / 3) - 1] ** 3 + x[n - i] + 48 * z[math.ceil(i / 2) - 1] ** 2
        _sum += v1 ** 4 / 84
    return _sum"
"import math

def main(x, y, z):
    n = len(x)
    x.insert(0, 0)
    y.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 37 * x[n + 1 - i] ** 3
        middle = 60 * y[n + 1 - math.ceil(i / 3)] ** 2
        right = z[i]
        total += 96 * (left - middle - right) ** 6
    return 40 * total"
"import math

def main(z, y):
    n = len(z)
    result = 0
    for i in range(1, n + 1):
        result += z[i - 1] ** 3 + 65 * y[n - math.ceil(i / 2)] ** 2
    return result * 74"
"def main(x, y, z):
    n = len(x)
    result = 0
    for i in range(1, n + 1):
        y1 = y[n + 1 - i - 1] / 32
        z1 = 26 * z[abs((i - 1) // 2)] ** 3
        x1 = x[abs((i - 1) // 4)] ** 2 / 49
        result += 35 * (y1 + z1 + x1) ** 5 / 22
    return result"
"from cmath import log
from math import ceil

def main(y):
    res = 0
    n = len(y)
    for i in range(n):
        res += 7 * log(y[ceil(i // 3)] + 1 + 10 * y[i] ** 3, 2) ** 7
    result = res * 59
    return result.real"
"import math

def main(x, z):
    n = len(z)
    f = 0
    for i in range(1, n + 1):
        p = 42 * (z[n - math.ceil(i / 3)] / 24 + z[n - i] ** 2 + 77 * x[i - 1] ** 3) ** 4
        f += p
    return f * 90"
"import math

def main(x, z, y):
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = y[n + 1 - math.ceil(i / 4)] ** 3
        middle = z[math.ceil(i / 4)] ** 2
        right = x[math.ceil(i / 2)] / 39
        total += 1 * (left - middle - right) ** 2
    return 71 * total"
"import math
y = []

def main(y):
    temp1 = 0
    i = 1
    n = len(y)
    for i in range(n):
        temp1 += 47 * (52 * y[i] + 1 + y[math.floor(i / 2)] ** 3) ** 3
    return 76 * temp1"
"from math import ceil

def main(x, y, z):
    sum = 0
    n = len(x)
    for i in range(1, n + 1):
        sum += 28 * (83 * x[ceil(i / 4 - 1)] ** 2 + y[ceil(i - 1)] ** 3 + z[ceil(i / 2 - 1)] / 34) ** 5
    return sum
main([-0.04, 0.15, -0.46, 0.59, 0.81, -0.03], [0.06, 0.88, 0.72, -0.75, -0.51, -0.63], [0.57, -0.01, -0.23, 0.76, 0.03, 0.19])"
"from math import *

def main(x):
    n = len(x)
    ans = 0
    for i in range(1, n + 1):
        a = 92 * x[ceil(i / 4) - 1] ** 3
        b = 66 * x[ceil(i / 4) - 1] ** 2
        c = x[ceil(i / 3) - 1]
        ans += 66 * (a - b - c / 80) ** 3
    return ans * 49"
"import math

def main(y, z):
    n = len(y)
    ans = 0
    for i in range(1, n + 1):
        a = math.ceil(i / 3)
        ans += 51 * (z[n - a] ** 3 - 78 * y[n - i] ** 2 - 69) ** 6
    return ans"
"import math

def main(x, y):
    n = len(x)
    y.insert(0, 0)
    x.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 80 * x[n + 1 - i] ** 2
        middle = 27 * y[n + 1 - math.ceil(i / 4)] ** 3
        right = x[n + 1 - i] / 45
        total += (left + middle + right) ** 5
    return 23 * total"
"def main(y, z):
    rez = 0
    n = len(y)
    for i in range(n):
        a = 93 * y[i]
        b = 13 * z[n - i // 2 - 1] ** 3
        rez += 55 * (a + b + 1) ** 7
    return rez.real"
"import math

def main(y, z, x):
    n = len(x)
    f = 0.0
    for i in range(1, n + 1):
        p1 = 19 * z[int(math.ceil(i / 3.0)) - 1] + x[n + 1 - i - 1] ** 2
        p2 = 10 * y[n + 1 - int(math.ceil(i / 4)) - 1] ** 3
        f = f + (p1 + p2) ** 7
    return f"
"import math

def main(y, x, z):
    s = 0
    i = 1
    n = len(x)
    while i <= n:
        index = n - math.ceil(i / 4)
        s += 19 * x[index] ** 2 - y[math.ceil(i / 4) - 1] - z[math.ceil(i) - 1] ** 3
        i += 1
    return s"
"def main(y):
    f = 0
    n = len(y)
    for i in range(1, n + 1):
        f += (y[i - 1] - 65 - 97 * y[i - 1] ** 3) ** 4
    return 47 * f"
"from math import ceil

def main(z, y, x):
    f = 0
    n = len(z)
    for i in range(1, n + 1):
        f += 74 * (x[ceil(i / 2) - 1] ** 3 - z[n + 1 - ceil(i / 4) - 1] ** 2 / 52 - y[n + 1 - i - 1]) ** 4
    return f"
"import math

def main(z, x):
    summa = 0
    for i in range(0, 3):
        summa += (z[i // 3] - 18 * x[2 - i // 3] ** 3 - 74) ** 5
    return summa"
"import math

def main(z, y):
    result = 0
    n = len(z)
    for i in range(1, n + 1):
        var1 = z[math.ceil(i / 2) - 1]
        var2 = y[math.ceil(i / 3) - 1] ** 3
        result += var1 - 1 - var2
    return 42 * result"
"import math

def main(y, x, z):
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 2 * y[math.ceil(i / 2)]
        middle = 17 * x[n + 1 - math.ceil(i / 4)] ** 2
        right = 56 * z[math.ceil(i / 2)] ** 3
        total += 88 * (left + middle + right) ** 6
    return 69 * total"
"import math

def main(y):
    n = len(y)
    y.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = y[n + 1 - math.ceil(i / 3)] ** 2 / 55
        middle = 93 * y[math.ceil(i / 4)]
        right = y[math.ceil(i / 4)] ** 3
        total += (left - middle - right) ** 4
    return 28 * total"
"import math

def main(z, x):
    n = len(z)
    result = 0
    for i in range(1, n + 1):
        result += 28 * (x[n - math.ceil(i / 2)] ** 2 - 18 * z[i - 1]) ** 7
    return result"
"from math import floor

def main(vector):
    result = 0
    n = len(vector)
    for i in range(1, n + 1):
        result += floor(64 + 67 * vector[n - i] ** 3) ** 5
    return 87 * result"
"from math import ceil, pow

def main(vectorX, vectorZ):
    result = 0
    n = len(vectorX)
    for i in range(1, n + 1):
        result += 54 * pow(pow(vectorZ[i - 1], 2) - 67 * pow(vectorX[n - ceil(i / 3)], 3), 4)
    return result"
"def main(y, z, x):
    n = len(y)
    sum = 0
    for i in range(0, n):
        sum += 40 * (z[int(i / 2)] ** 3 + y[n - 1 - i] ** 2 + x[int(i / 3)]) ** 2
    return sum"
"import math

def main(y, x, z):
    ans = 0
    n = len(z)
    for i in range(1, n + 1):
        ans += abs(30 * z[n - i] + y[n - math.ceil(i / 2)] ** 3 + 68 * x[n - i] ** 2) ** 7
    return ans"
"from math import log10, ceil

def main(x):
    n = len(x)
    sum = 0
    for i in range(1, n + 1):
        sum += 56 * log10(0.01 + 6 * x[ceil(i / 4) - 1]) ** 3
    return sum"
"from math import exp, ceil

def main(x, y):
    n = len(y)
    result = 0
    for i in range(1, n + 1):
        s = 0
        s += 67 * x[ceil(i / 4) - 1]
        s += 34 * x[ceil(i / 4) - 1] ** 2
        s += 2 * y[n - ceil(i / 4)] ** 3
        result += exp(s)
    return 88 * 95 * result"
"from math import *

def main(x: list):
    result = 0
    n = len(x) - 1
    for i in range(1, n + 2):
        result += 95 * (x[n + 1 - ceil(i / 4)] ** 2 + 7) ** 6
    return result
main([-0.63, -0.5, -0.86, 0.01])"
"import math as m

def main(z, y):
    n = len(y)
    y.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        first = 51 + z[m.ceil(n + 1 - i)]
        second = m.pow(y[m.ceil(n + 1 - i)], 3)
        total += 91 * m.pow(first + second, 6)
    return 56 * total"
"import math

def main(y, z, x):
    ans = 0
    n = len(z)
    for i in range(1, n + 1):
        ans += (y[math.ceil(i / 3) - 1] + x[math.ceil(i / 2) - 1] ** 3 + z[math.ceil(i / 4) - 1] ** 2) / 8
    return 96 * ans"
"def main(x, z, y):
    ans = 0
    for i in range(len(x)):
        anx = z[len(x) - 1 - i] ** 3 - 53 * x[len(x) - 1 - i // 4] ** 2 - y[len(x) - 1 - i]
        ans += 32 * anx
    ans *= 22
    return ans"
"import math

def main(listx, listy):
    res = 0
    for i in range(1, 3):
        res += 38 * (listy[2 - math.ceil(i / 4)] ** 3 / 91 - 1 - listx[2 - math.ceil(i / 2)] ** 2) ** 7
    return res"
"import math

def main(y, z, x):
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = y[n + 1 - math.ceil(i / 4)] ** 2 / 8
        middle = 21 * x[n + 1 - i] ** 3
        right = 93 * z[math.ceil(i / 4)]
        total += (left + middle + right) ** 5
    return total"
"import math

def main(x, y):
    n = len(x)
    y.insert(0, 0)
    x.insert(0, 0)
    sum = 0
    for i in range(1, n + 1):
        sum += math.exp(96 * x[math.ceil(i / 2)] ** 3 - y[i] ** 2) ** 5
    return sum"
"from math import *

def main(x, y):
    n = len(x)
    f = 0
    for i in range(1, n + 1):
        f += acos(pow(y[n + 1 - i - 1], 2) - pow(x[ceil(i / 2) - 1], 3) - 1)
    return f"
"import math

def main(x, z):
    sum = 0
    v = len(x)
    i = 1
    for i in range(i, v + 1):
        sum += 60 * math.atan(z[v - i] ** 2 - 1 - x[i - 1] ** 3) ** 7
    return sum"
"from math import ceil

def main(x):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res += abs(x[n - ceil(i / 4)]) ** 2 / 13
    return res"
"import math

def main(y, z):
    n = len(y)
    y.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 78 * z[n + 1 - math.ceil(i / 3)]
        middle = y[math.ceil(i / 4)] ** 3
        right = 48 * y[i] ** 2
        total += (left + middle + right) ** 7
    return total"
"from math import ceil

def main(vector):
    result = 0
    n = len(vector)
    for i in range(1, n + 1):
        result += (1 - 41 * vector[ceil(i / 4) - 1] ** 2 - vector[ceil(i / 4) - 1] ** 3) ** 2
    return result"
"import math

def main(y, x):
    n = len(y)
    result = 0
    for i in range(1, n + 1):
        result += 10 * (51 * x[n - math.ceil(i / 4)] - y[n - math.ceil(i / 2)] ** 3 - 18) ** 3
    return result"
"def main(x, y):
    n = len(x)
    a = 0
    for i in range(1, n + 1):
        a += 56 * (87 * x[i - 1] ** 2 + 1 + y[n - i] ** 3 / 29) ** 4
    return 7 * a"
"import math

def main(z, x):
    n = len(x)
    z.insert(0, 0)
    x.insert(0, 0)
    result = 0
    for i in range(1, n + 1):
        left = 63 * x[i] ** 3
        middle = 47 * z[i]
        right = x[math.ceil(i / 4)] ** 2
        result += left - middle - right
    return 7 * result"
"from math import *

def main(x, z):
    result = 0
    n = len(x)
    for i in range(1, n + 1):
        result += 35 * (75 * x[n - i] ** 3 - 49 * z[ceil(i / 2) - 1] ** 2 - z[ceil(i / 2) - 1]) ** 3
    return result * 24"
"import math

def main(x):
    summ = 0
    for oi in range(len(x)):
        i = oi + 1
        summ += 97 * (x[len(x) - math.ceil(i / 2)] + 1) ** 6
    return summ"
"import math

def main(x, y):
    sum = 0
    n = len(x)
    for i in range(1, n + 1):
        a = 34 * y[n - math.ceil(i / 2)] ** 3
        b = 86 * y[n - math.ceil(i / 2)] ** 2
        sum += (a - b - x[math.ceil(i / 2) - 1]) ** 5
    return sum * 86"
"import math

def main(y, z, x):
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    z.insert(0, 0)
    res = 0
    for i in range(1, n + 1):
        right = z[math.ceil(i / 4)]
        res += math.cos(y[i] - x[i] ** 3 - right ** 2) ** 2
    return 43 * res"
"from math import *

def main(z, y, x):
    f = 0
    n = len(z)
    for i in range(1, n + 1):
        f += 42 * (y[ceil(i / 2 - 1)] ** 3 - x[ceil(i / 4 - 1)] - z[i - 1] ** 2)
    return f"
"def main(x):
    sum = 0
    for i in range(0, len(x)):
        sum += (x[i] ** 3 + 60 + 3 * x[i]) ** 6
    return 57 * sum"
"import math

def main(z, x, y):
    n = len(z)
    res = 0
    for i in range(0, n):
        a = z[n - 1 - math.floor(i / 3)]
        b = x[n - 1 - i] ** 3
        c = y[n - 1 - math.floor(i / 4)] ** 2
        res += (a + b + c) ** 3
    return res"
"from math import ceil

def main(y, z, x):
    res = 0
    n = len(z)
    for i in range(1, n + 1):
        res += (y[i - 1] ** 3 - 57 * z[n - ceil(i / 2)] ** 2 - x[n - ceil(i / 4)]) ** 3
    return res"
"import math

def main(z, y):
    n = len(z)
    z.insert(0, 0)
    y.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 17
        mid = y[n + 1 - i] ** 2 / 85
        right = z[i] ** 3
        total += 63 * abs(left - mid - right)
    return total"
"import math

def main(z, x):
    n = len(z)
    y = 0
    for i in range(1, n + 1):
        y += 93 * abs(x[i - 1] - 10 - 39 * z[math.ceil(i / 2 - 1)] ** 3) ** 4
    return y"
"import math

def main(x, z):
    n = len(x)
    x.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = x[math.ceil(i)]
        middle = z[math.ceil(i / 3)] ** 2
        right = x[math.ceil(i)] ** 3 / 92
        total += (left + middle + right) ** 2
    return 55 * total"
"def main(x, y):
    res = 0
    for i in range(len(x)):
        result1 = 74 * pow(y[i], 3)
        result2 = 73
        result3 = 86 * pow(x[i // 2], 2)
        res += pow(result1 - result2 - result3, 5)
    return res"
"import math

def main(z, y, x):
    A = 0
    for i in range(1, len(x) + 1):
        y1 = y[math.ceil(i / 2) - 1] ** 3 / 62
        z1 = 85 * z[len(x) - math.ceil(i / 4)]
        x1 = 9 * x[math.ceil(i / 2) - 1] ** 2
        m = math.log2(y1 + z1 + x1)
        A += 46 * m ** 7
    return 59 * A"
"from math import floor

def main(z, y, x):
    sum = 0
    n = len(x)
    for i in range(0, n):
        sum += floor(97 * z[i] ** 2 + x[i] + y[i] ** 3) ** 4
    return 19 * sum"
"import math

def main(x, z):
    sum = 0
    n = len(x)
    for i in range(1, n + 1):
        sum += 99 * (z[i - 1] / 87 + x[n - math.ceil(i / 3)] ** 3 + 1) ** 4
    return sum"
"import math

def main(x, z):
    n = len(x)
    x.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 83 * z[n + 1 - i] ** 2
        right = 94 * x[math.ceil(i / 2)]
        total += (left + right) ** 4
    return total"
"import math

def main(z, y):
    n = len(y)
    y.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 65 * y[math.ceil(i / 2)] ** 2
        right = z[i] / 14
        total += 85 * (left + right) ** 5
    return total"
"import math

def main(z, x, y):
    n = len(z)
    a = 0
    for i in range(1, n + 1):
        a += math.ceil(x[n + 1 - math.ceil(i / 4) - 1] ** 2 - 12 * y[n + 1 - math.ceil(i / 2) - 1] ** 3 - 44 * z[n + 1 - math.ceil(i / 2) - 1]) ** 7
    return a"
"from math import *

def main(y, x):
    f = 0
    n = len(y)
    for i in range(1, n + 1):
        f += (71 * x[n - i] ** 3 - y[ceil(i / 3) - 1] - 0.04) ** 4
    return 24 * f"
"def main(x, z, y):
    n = len(x)
    _sum = 0
    for i in range(1, n + 1):
        _sum += 71 * (41 * z[n - i] ** 3 - 92 * y[i - 1] ** 2 - 27 * x[i - 1]) ** 7
    return _sum"
"def main(y):
    n = len(y)
    a = 0
    for i in range(1, n + 1):
        a += 94 * (0.02 + 42 * y[n - i] ** 2)
    return 66 * a"
"import math

def main(z, y):
    ans = 0
    n = len(z)
    for i in range(1, n + 1):
        a = 17 * z[n - i] ** 2 + 5 * z[n - math.ceil(i / 3)] + y[i - 1] ** 3
        ans += 47 * math.sin(a) ** 2
    return 66 * ans"
"from math import ceil, sqrt

def main(z, x, y):
    n = len(z)
    sum = 0
    for i in range(n):
        sum += sqrt(y[i] ** 2 - x[ceil((i + 1) / 3) - 1] - 6 * z[i] ** 3) ** 6
    return 41 * sum"
"import math

def main(z, x, y):
    n = len(z)
    z.insert(0, 0)
    x.insert(0, 0)
    y.insert(0, 0)
    fin = 0
    for i in range(1, n + 1):
        first = 14 * y[math.ceil(i / 4)]
        second = 98 * x[n + 1 - math.ceil(i / 2)] ** 3
        third = z[n + 1 - math.ceil(i)] ** 2
        fin += (first - second - third) ** 2
    return fin"
"import math

def main(a):
    result = 0
    n = len(a)
    a.insert(0, 0)
    for i in range(1, n + 1):
        left = 95 * a[math.ceil(i / 3)] ** 3
        middle = 31 * a[math.ceil(i / 3)] ** 2
        right = 74 * a[n + 1 - math.ceil(i / 2)]
        result += (left - middle - right) ** 3 / 74
    return result"
"import math

def main(x, z):
    n = len(x)
    x.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        middle = x[math.ceil(i / 3)] ** 2
        right = z[math.ceil(i / 4)] ** 3
        total += right - 43 - middle
    return total"
"import math

def main(x, y):
    n = len(x)
    res = 0
    for i in range(0, n):
        res += 55 * math.sqrt(94 * x[n - 1 - i // 3] ** 2 - y[n - 1 - i // 3] - x[n - 1 - i // 3] ** 3) ** 4
    return res"
"def main(y):
    n = len(y)
    a = 0
    for i in range(0, n):
        a += 58 * (20 * y[n - 1 - i] + 51 + 66 * y[i // 4] ** 2)
    return 32 * a"
"from math import ceil

def main(z, y, x):
    n = 2
    res = 0
    for i in range(1, n + 1):
        res += (74 * x[n - i] ** 2 + z[ceil(i / 2 - 1)] + 92 * y[n - ceil(i / 4)] ** 3) ** 5
    return 47 * res"
"import math

def main(z):
    res = 0
    for i in range(1, len(z) + 1):
        res += (56 * z[len(z) - math.ceil(i / 2)] ** 2 + 26 + 60 * z[len(z) - i] ** 3) ** 7
    return res * 73"
"import math

def main(y, z):
    n = len(y)
    y.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 2 * y[i]
        right = z[n + 1 - i] ** 3
        total += 7 * (left + right) ** 6
    return 58 * total"
"import math

def func1(x, y, i):
    return 14 * y[int(math.ceil(float(i) / 4))] ** 2 - 45 * x[int(len(x) - 1 - math.ceil(float(i) / 4))] ** 3

def main(x, y):
    result = 0
    for i in range(0, len(x)):
        result += 64 * math.acos(func1(x, y, i - 1))
    return 83 * result"
"def main(x, y, z):
    res = 0
    for i in range(len(x)):
        result1 = y[i] ** 2 - z[i] - 95 * x[i // 3] ** 3
        res += 62 * result1 ** 4
    return res"
"import math

def main(x, z, y):
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = x[n + 1 - i]
        middle = z[n + 1 - math.ceil(i / 2)] ** 2
        right = y[n + 1 - math.ceil(i / 2)] ** 3
        total += 7 * (left + middle + right) ** 4
    return 29 * total"
"from math import *

def main(y):
    n = len(y)
    ans = 0
    for i in range(1, n + 1):
        a = 82 * y[ceil(i / 2) - 1] ** 2
        b = y[ceil(i / 2) - 1]
        c = 1
        ans += atan(a - b - c) ** 4
    return ans"
"def main(x, y):
    n = len(x)
    _sum = 0
    for i in range(1, n + 1):
        _sum += (14 * x[int((i - 1) / 3)] ** 3 - y[i - 1] ** 2 - 1) ** 4
    return _sum"
"def main(vector):
    result = 0
    count = len(vector)
    for i in range(1, count + 1):
        result += (vector[i - 1] + vector[count - i] ** 2) ** 5
    return result"
"def main(x, z):
    sum = 0
    n = len(x) - 1
    for i in range(0, n + 1):
        sum += (x[i // 4] + 78 * z[n + 1 - (i + 1)] ** 2) ** 4
    return sum"
"def main(x, y, z):
    n = len(x)
    result = 0
    for i in range(1, n + 1):
        s = 0
        s += y[i - 1] ** 2
        s += -z[n - i] ** 3 / 9
        s += -2 * x[n - i]
        result += s
    return result"
"from math import pow, ceil

def main(array):
    n = len(array)
    summ = 0
    for i in range(1, n + 1):
        summ += pow(pow(array[ceil(i / 2) - 1], 3) - 64 - array[n - ceil(i / 4)], 7) / 75
    return summ"
"import math

def main(x, z, y):
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = y[math.ceil(i)] ** 3
        middle = 45 * x[math.ceil(i)]
        right = z[math.ceil(i / 3)] ** 2
        total += (left + middle + right) / 7
    return total"
"def main(x):
    res = 0
    for i in range(len(x)):
        result1 = x[i // 4]
        result2 = 4
        result3 = x[i // 4] ** 2
        res += (result1 / result2 - result3) ** 5
    return res"
"import math

def main(z, x):
    n = len(z)
    z.insert(0, 0)
    x.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 69 * z[n + 1 - i]
        middle = x[n + 1 - math.ceil(i / 4)] ** 2
        right = z[math.ceil(i / 4)] ** 3
        total += math.sqrt(left - middle - right)
    return total"
"from math import tan, ceil

def main(y):
    result = 0
    n = len(y)
    for i in range(1, n + 1):
        result += tan(5 * y[n - i] ** 3 + y[n - ceil(i / 3)] ** 2 / 60) ** 6
    return result"
"from math import ceil

def main(z, x, y):
    result = 0
    n = len(x)
    for i in range(0, n):
        first_term = 86 * x[i] ** 3
        second_term = z[n - 1 - ceil(i // 4)]
        third_term = 17 * y[n - 1 - i] ** 2
        result += ceil(first_term - second_term - third_term) ** 6
    return result"
"from math import ceil

def main(z):
    res = 0
    n = len(z)
    for i in range(1, n + 1):
        res += (z[n - ceil(i / 2)] ** 3 / 61) ** 2
    return res * 75"
"import math

def main(z, x):
    ans = 0
    n = len(x)
    for i in range(1, n + 1):
        ans += 37 * math.log(x[math.ceil(i / 4) - 1] + z[n - i] ** 2 / 60 + z[n - i] ** 3) ** 7
    return ans"
"from math import *

def main(y, z):
    sum = 0.0
    n = len(y)
    pt1 = 0.0
    pt2 = 0.0
    y.insert(0, 0)
    z.insert(0, 0)
    for i in range(1, n + 1):
        pt1 = 70 * pow(y[ceil(i / 4)], 2)
        pt2 = z[n + 1 - ceil(i / 3)]
        sum += pow(pt1 + pt2, 5)
    return sum"
"import math

def main(y):
    s = 0
    n = len(y)
    for i in range(1, n + 1):
        x1 = 85 * y[n + 1 - math.ceil(i / 2) - 1]
        x2 = 74 * y[n + 1 - math.ceil(i / 2) - 1] ** 3
        s += math.log(x1 + 62 + x2, 2) / 92
    return s"
"from math import *

def main(x, z, y):
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 57 * z[ceil(i / 4)]
        middle = x[ceil(i / 2)] ** 3 / 25
        right = y[n + 1 - i] ** 2
        total += (left + middle + right) ** 6
    return 29 * total"
"from math import pow, ceil

def main(y, x):
    result = 0
    n = len(x)
    for i in range(1, n + 1):
        result += 66 * pow(86 * pow(x[n - i], 2) + 60 * pow(y[n - ceil(i / 3)], 3) + 1, 3)
    return result"
"def main(x, z, y):
    res = 0
    for i in range(0, len(x)):
        res += (54 * y[i] ** 3 - 38 * z[i] ** 2 - x[int(i / 2)]) ** 6
    return float('%.2e' % res)
assert main([0.59, 0.43, -0.09, -0.05, 0.09, 0.04, -0.91, -0.08], [0.83, 0.22, 0.51, 0.55, -0.45, -0.78, -0.15, 0.45], [-0.08, -0.65, 0.96, -0.99, 0.8, 0.74, -0.69, 0.52]) == 74100000000.0
assert main([0.98, -0.57, -0.3, -0.76, 0.35, 0.94, 0.47, -0.1], [-0.83, 0.23, 0.65, -0.52, 0.51, 0.75, 0.5, -0.87], [0.56, 0.2, 0.25, 0.2, 0.26, -0.15, 0.89, -0.73]) == 14600000000.0"
"import math

def main(y, x):
    result = 0
    n = len(y)
    for i in range(1, n + 1):
        var1 = x[math.ceil(i / 4) - 1] ** 3
        var2 = 47 * x[math.ceil(i / 4) - 1] ** 2
        var3 = 97 * y[math.ceil(i / 2) - 1]
        result += (var1 - var2 - var3) ** 5 / 77
    return 91 * result"
"import math

def main(y, x):
    result = 0
    n = len(y)
    for i in range(1, n + 1):
        var1 = x[math.ceil(i / 4) - 1] ** 3
        var2 = 47 * x[math.ceil(i / 4) - 1] ** 2
        var3 = 97 * y[math.ceil(i / 2) - 1]
        result += 91 * (var1 - var2 - var3) ** 5 / 77
    return result"
"import math

def main(x):
    n = len(x)
    answer = 0
    for i in range(n):
        part_1 = 39 * x[int(i / 4)] + 78 + 38 * x[i] ** 2
        answer = answer + part_1 ** 2
    return answer * 73"
"from math import ceil

def main(x):
    n = len(x)
    a = 0
    for i in range(1, n + 1):
        a += 1 + 6 * x[ceil(i / 2) - 1] ** 3 + 59 * x[n - i]
    return 10 * a"
"def main(y):
    n = len(y)
    answer = 0
    for i in range(n):
        part1 = 1 + y[int(i / 2)] ** 2 + 78 * y[n - 1 - int(i / 3)] ** 3
        answer = answer + 29 * part1 ** 4
    return answer * 92"
"from math import sin

def main(z):
    return sum([sin(z[3 - i] ** 3 - 6 * z[i // 4] ** 2 - z[i // 4]) ** 5 for i in range(0, 4)])"
"def main(z):
    ans = 0
    n = len(z)
    for i in range(1, n + 1):
        ans += 33 * (6 * z[i - 1] + 19 * z[i - 1] ** 3 + 65) ** 5
    return ans"
"import math

def main(y, x, z):
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    z.insert(0, 0)
    d = 0
    for i in range(1, n + 1):
        a = x[math.ceil(i / 3)]
        b = z[n + 1 - i] ** 2
        c = y[n + 1 - i] ** 3
        d += math.sin(a - b - c) ** 6
    return d"
"import math

def main(z, y):
    n = len(y)
    z.insert(0, 0)
    y.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = z[math.ceil(i / 3)] ** 2
        middle = 44
        right = y[n + 1 - i] ** 3
        total += (left - middle - right) ** 2
    return 30 * total"
"def main(y, x):
    n = len(y)
    a = 0
    for i in range(1, n + 1):
        a += 74 * (85 + x[i - 1] ** 3 + y[i - 3] ** 2 / 34) ** 7
    return 41 * a"
"def main(z, x, y):
    result = 0
    for i in range(0, len(x)):
        result += 25 * (7 * z[i] - 29 * y[i] ** 2 - 51 * x[i] ** 3) ** 5
    return result"
"import math

def main(z):
    S = 0
    n = len(z)
    for i in range(1, n + 1):
        S += 5 * (z[n - i] / 57 - z[math.ceil(i / 3) - 1] ** 2 - z[i - 1] ** 3) ** 2
    return S"
"import math

def main(z):
    n = len(z)
    z.insert(0, 0)
    x = 0
    for i in range(1, n + 1):
        x = x + math.exp(z[n + 1 - math.ceil(i / 3)]) ** 7 / 86
    return x"
"from math import ceil

def main(y, z, x):
    res = 0
    for i in range(1, len(y) + 1):
        first = 99 * z[len(y) - ceil(i / 4)] ** 2
        second = y[i - 1]
        third = x[ceil(i / 2) - 1] ** 3 / 25
        res += (first + second + third) ** 4 / 34
    return res"
"from math import ceil

def main(z, x, y):
    n = len(y)
    a = 0
    for i in range(1, n + 1):
        a += 36 * (z[ceil(i / 4) - 1] ** 3 + 87 * y[i - 1] ** 2 + 68 * x[n - ceil(i / 4)]) ** 7
    return 66 * a"
"import math

def main(x, z):
    n = len(x)
    x.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        middle = 13 * x[n + 1 - i]
        right = z[math.ceil(i / 2)] ** 2
        total += 93 * math.log10(middle - right) ** 7
    return 55 * total"
"import math

def main(z, y, x):
    n = len(z)
    f_sum = 0
    for i in range(1, n + 1):
        idx = n - math.ceil(i / 3)
        f_sum += y[idx] ** 3 + z[idx] / 58 + 51 * x[idx] ** 2
    return f_sum"
"import math
a = [0.03, 0.0]
b = [-0.07, 0.15]

def main(x, y):
    n = len(y)
    x.insert(0, 0)
    y.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = x[math.ceil(i)] ** 2
        foo1 = -1 * y[n + 1 - math.ceil(i / 4)]
        foo2 = 27 * y[n + 1 - math.ceil(i / 4)] ** 3
        middle = foo1 - foo2
        total += 41 * (left + middle) ** 3
    return total
main(a, b)"
"from math import *

def main(y, z, x):
    value = 0
    n = len(y)
    for i in range(1, n + 1):
        value += (19 * y[ceil(i / 4) - 1] + 20 * z[ceil(i / 3) - 1] ** 2 + 71 * x[i - 1] ** 3) ** 4
    return value * 5"
"import math

def main(y=[], x=[]):
    n = len(y)
    return sum((math.ceil(y[math.ceil(i / 2 - 0.5)] ** 2 + 82 * x[n - 1 - i] + 27) ** 6 / 51 for i in range(0, n)))"
"from math import pow, log10

def main(y, x, z):
    n = len(y)
    result = 0
    for i in range(0, n):
        first = pow(y[i], 2)
        second = z[i]
        third = pow(x[i], 3)
        result += 84 * log10(first + second + third)
    return result"
"from math import sin, ceil

def main(z, y):
    result = 0
    n = len(y)
    for i in range(1, n + 1):
        result += sin(y[ceil(i / 3) - 1] - 44 * z[n - ceil(i / 4)] ** 3) ** 6
    return result"
"import math

def main(y, z, x):
    n = len(y)
    y.insert(0, 0)
    z.insert(0, 0)
    x.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = z[n + 1 - math.ceil(i / 4)] ** 2
        right = y[math.ceil(i / 4)] + 16 * x[i] ** 3
        total += left + right
    return total"
"import math

def main(x, z):
    s = 0
    i = 1
    n = len(x)
    while i <= n:
        index = n - i - 1
        s += math.exp(25 * x[index] ** 3 - 1 - 40 * z[index]) ** 4 / 79
        i += 1
    s *= 63
    return s"
"from math import log10
from math import ceil

def main(z, x, y):
    n = len(z)
    f = 0
    for i in range(1, n + 1):
        f1 = 40 * x[ceil(i / 3 - 1)] ** 3 - 51 * z[ceil(i / 4 - 1)] - 47 * y[n - ceil(i / 2)] ** 2
        f += log10(f1) ** 6
    return f"
"import math

def main(y, z, x):
    res = float(0)
    n = len(y)
    for i in range(1, n + 1):
        p = math.ceil(i / 2) - 1
        o = n + 1 - i - 1
        k = n + 1 - math.ceil(i / 4) - 1
        res_p = z[p] ** 2
        res_o = x[o] ** 3
        res_k = y[k]
        res += (res_p - res_o - res_k) ** 3
    return 87 * res"
"from math import tan

def main(x, y):
    n = len(x)
    fs = 0
    for i in range(1, n + 1):
        fi = tan(64 * x[n - i] + 35 * y[i - 1] ** 3 + 1) ** 4
        fs = fs + fi
    return fs * 9"
"from math import ceil

def main(z):
    n = len(z)
    sum_i = 0
    for i in range(1, n + 1):
        sum_i += (z[n - ceil(i / 2)] ** 3 + z[i - 1] / 31) ** 6
    return sum_i"
"import math as m

def main(y, x, z):
    n = len(y)
    result = 0
    for i in range(1, n + 1):
        result += 47 * m.sin(y[n - m.ceil(i / 2)] - z[i - 1] ** 3 - x[n - i] ** 2) ** 5
    return result"
"import math

def main(y):
    n = len(y)
    y.insert(0, 0)
    answer = 0
    for i in range(1, n + 1):
        part_1 = y[n + 1 - math.ceil(i / 3)] - 74 - 11 * y[math.ceil(i / 4)] ** 3
        answer += part_1 ** 5
    return answer"
"import math

def main(x, z, y):
    n = len(z)
    s = 0
    z.insert(0, 0)
    y.insert(0, 0)
    x.insert(0, 0)
    for i in range(1, n + 1):
        s += 86 * (65 * y[i] + z[math.ceil(i / 2)] ** 2 + 49 * x[math.ceil(i / 4)] ** 3) ** 3
    return s"
"import math

def main(z, x):
    n = len(z)
    s = 0
    for i in range(1, n + 1):
        s += 56 * (x[n - i] ** 3 / 59 - z[n - math.ceil(i / 4)] - x[i - 1] ** 2)
    return s"
"def main(z, y, x):
    n = len(z)
    result = 0
    for i in range(n):
        dif1 = y[i]
        dif2 = 14 * x[i] ** 2
        dif3 = z[n - 1 - i // 4] ** 3
        res_dif = (dif1 + dif2 + dif3) ** 6
        result += res_dif
    return 27 * result"
"from math import ceil

def main(x, y, z):
    n = len(x)
    result = 0
    for i in range(1, n + 1):
        result1 = 54 * x[n - ceil(i / 3)] - y[n - i] ** 2
        result2 = z[n - ceil(i / 4)] ** 3 / 73
        result += 13 * (result1 - result2)
    return result"
"import math

def main(y, x):
    n = len(y)
    sum_i = 0
    for i in range(1, n + 1):
        sum_i += math.log(y[math.ceil(i / 4) - 1] ** 2 / 36 + x[n + 1 - math.ceil(i / 3) - 1] / 3 + 20, math.e) ** 4
    return 6 * sum_i"
"from math import *

def main(z, y):
    f = 0
    n = len(z)
    for i in range(1, n + 1):
        f += 4 * sin(90 * y[n + 1 - ceil(i / 4) - 1] ** 2 - z[n + 1 - ceil(i / 4) - 1] / 15 - 1) ** 7
    return 73 * f"
"import math

def main(z, x):
    n = len(z)
    z.insert(0, 0)
    x.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = z[n + 1 - math.ceil(i / 3)] ** 2
        middle = 85 * x[i]
        right = 1
        total += (left + middle + right) ** 6
    return total"
"def main(y, z):
    n = len(y)
    sum_i = 0
    for i in range(n):
        sum_i += (89 * y[i] ** 3 - 12 * y[i] - 57 * z[i] ** 2) ** 2 / 90
    return sum_i"
"import math

def main(x):
    n = len(x)
    x.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        total += (x[math.ceil(i / 3)] ** 2 + x[math.ceil(i / 3)] ** 3) ** 4
    return total"
"from math import ceil

def main(y, z):
    n = len(y)
    f = 0
    for i in range(1, n + 1):
        f += 53 * (86 + y[ceil(i / 4) - 1] ** 2 + z[n - ceil(i / 4)] ** 3 / 81) ** 3
    return f"
"import math

def main(arr):
    ans = 0
    n = len(arr) - 1
    for i in range(1, n + 2):
        ans += 76 * (43 - arr[n + 1 - math.ceil(i / 3)] ** 2 - arr[n + 1 - math.ceil(i / 2)]) ** 2
    return ans"
"def main(z):
    r = 0
    n = len(z)
    for i in range(len(z)):
        r += 66 * (z[i // 4] - z[i // 4] ** 3) ** 6
    r = r * 57
    return r"
"import math

def main(z, x):
    number = 0
    n = len(x)
    for i in range(1, n + 1):
        number += math.sin(53 * x[n - math.ceil(i / 3)] ** 2 + 77 * z[n - i]) ** 3
    return 25 * 95 * number"
"def main(z: list):
    result = 0
    for i in range(len(z)):
        result += 64 * abs(z[len(z) - 1 - i] / 67) ** 5
    return result * 73"
"from math import ceil, cos

def main(z, y, x):
    n = len(z)
    a = 0
    for i in range(1, n + 1):
        a += 26 * cos(x[i - 1] ** 3 + z[n + 1 - i - 1] + 11 * y[n + 1 - ceil(i / 4) - 1] ** 2) ** 2
    return 36 * a"
"import math

def main(y, x):
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        total += (1 + x[n + 1 - i] ** 3 + 94 * y[n + 1 - i]) ** 6
    return 56 * total"
"import math

def main(x, z):
    n = len(x)
    x.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 86 * x[n + 1 - math.ceil(i / 2)] ** 2
        middle = 72 * z[math.ceil(i / 4)]
        right = x[n + 1 - math.ceil(i / 2)] ** 3
        total += left + middle + right
    return total"
"import math

def main(z):
    n = len(z)
    z.insert(0, 0)
    temp_sum = 0
    for i in range(1, n + 1):
        arg1 = 78 * pow(z[math.ceil(i / 4)], 2)
        arg2 = 93 * z[math.ceil(i / 4)]
        arg3 = 65
        temp_sum += math.exp(arg1 + arg2 + arg3)
    return temp_sum * 47"
"from math import ceil

def main(y, x, z):
    n = len(y)
    result = 0
    for i in range(1, n + 1):
        result += (x[n - ceil(i / 4)] / 99 - z[ceil(i / 4) - 1] ** 3 - 63 * y[n - ceil(i / 3)] ** 2) ** 5
    return result / 13"
"import math

def main(y):
    n = len(y)
    total = 0
    for i in range(1, n + 1):
        left = 9 * y[n - i] ** 2
        right = y[n - i]
        total += 91 * (left - right)
    return total"
"import math

def main(list):
    n = len(list)
    summ = 0
    list.insert(0, 0)
    for i in range(1, n + 1):
        left = 1 + 34 * list[n + 1 - math.ceil(i / 2)]
        right = list[n + 1 - math.ceil(i / 2)] ** 3
        summ += (left + right) ** 5
    return summ"
"import math

def main(z):
    ans = 0
    n = len(z)
    for i in range(1, n + 1):
        ans += 68 * (37 * z[math.ceil(i / 2) - 1] ** 3 - z[i - 1]) ** 6
    return ans"
"from math import *

def main(z):
    f = 0
    n = len(z)
    for i in range(1, n + 1):
        f += 12 * (57 * z[n + 1 - i - 1] + 93 * z[ceil(i / 2) - 1] ** 3) ** 5
    return 89 * f"
"import math
from math import *

def main(y, z, x):
    value = 0
    n = len(y)
    for i in range(1, n + 1):
        left = x[n + 1 - i - 1] ** 2 / 99
        middle = y[i - 1]
        right = z[math.ceil(i / 3 - 1)] ** 3
        value += 18 * (left + middle + right) ** 5
    return value * 75"
"def main(y, z):
    ans = 0
    n = len(z)
    for i in range(1, n + 1):
        ans += 69 * z[n - i] ** 3 - y[i - 1]
    return 59 * ans"
"import math

def main(y):
    n = len(y)
    y.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 87
        middle = y[math.ceil(i / 3)] ** 3
        right = 8 * y[math.ceil(i / 3)]
        total += 99 * (left + middle + right) ** 4
    return 57 * total"
"import math

def main(y, x):
    ans = 0
    n = len(x)
    for i in range(1, n + 1):
        ans += (35 * x[n - math.ceil(i / 2)] - 64 * y[math.ceil(i / 3) - 1] ** 3 - x[n - i] ** 2) ** 6
    return ans"
"import math

def main(y):
    n = len(y)
    res = 0.0
    for i in range(1, n + 1):
        l1 = 92 * y[math.ceil(i / 3) - 1] ** 2
        l2 = 84 * y[n - i]
        res += 14 * math.ceil(l1 - l2) ** 7
    return res * 10"
"import math

def main(y):
    a = len(y)
    sum = 0
    for i in range(0, len(y)):
        a = len(y)
        b = a + 1 - i - 2
        c = y[b] ** 3
        d = 10 * c
        e = math.sqrt(43 + d)
        f = 23 * e
        sum += f
    return sum"
"import math

def main(n):
    result = 0
    i = 0
    while i < len(n):
        y = 98 + 32 * n[len(n) - i - 1] * n[len(n) - i - 1] + n[len(n) - i - 1]
        result += pow(math.cos(y), 4)
        i += 1
    return result"
"def main(x, z, y):
    sum = 0
    for i in range(0, len(z)):
        a = x[int(i / 2)] ** 3
        b = y[int(i / 3)] / 6
        c = z[len(z) - 1 - i] ** 2 / 64
        d = (a + b + c) ** 3
        e = 71 * d
        sum += e
    return sum"
"import math

def main(z, x):
    n = len(z)
    z.insert(0, 0)
    x.insert(0, 0)
    sum = 0
    for i in range(1, n + 1):
        sum += math.atan(6 * x[n + 1 - math.ceil(i / 4)] ** 3 - 36 * z[math.ceil(i / 3)] - 0.01) ** 2
    return sum"
"def main(x):
    b = 0
    for i in range(0, 7):
        z = x[i]
        a = x[len(x) - 1 - int(i / 2)] ** 2 / 85
        b += (a + x[i] ** 3 + 88) / 65
    c = 11 * b
    return c"
"from math import ceil

def main(z):
    res = 0
    n = len(z)
    for i in range(1, n + 1):
        res += abs(z[n - ceil(i / 4)] ** 2) / 32
    return 71 * res"
"from math import *

def main(z, y):
    n = len(z)
    res = 0.0
    for i in range(1, n + 1):
        num1 = y[n - ceil(i / 4)] + 1 + z[ceil(i / 3) - 1] ** 3
        num2 = log10(num1) ** 4
        res += num2
    return res * 73"
"import math

def main(z, x, y):
    sum = 0.0
    n = len(z)
    for i in range(1, n + 1):
        difficult1 = pow(z[math.ceil(i / 3) - 1], 2) / 5
        difficult2 = y[n - i] ** 3
        difficult3 = x[n - math.ceil(i / 4)]
        substraction_result = difficult1 - difficult2 - 82 * difficult3
        sum += math.ceil(substraction_result)
    return sum * 37"
"from math import *

def main(x, z, y):
    n = len(x)
    _sum = 0
    for i in range(1, n + 1):
        _sum += sin(z[i - 1] + y[n - i] ** 3 + x[int((i - 1) / 2)] ** 2 / 99)
    return _sum * 18"
"import math

def main(y, x):
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 53 * y[n + 1 - i] ** 3
        right = x[n + 1 - math.ceil(i / 2)] ** 2
        total += 81 * (left + 1 + right) ** 3
    return total"
"def main(z, y, x):
    res = 0
    n = 5
    for i in range(len(x)):
        result1 = pow(y[n + 1 - i], 2)
        result2 = z[i]
        result3 = pow(x[n + 1 - i // 4], 3) / 4
        res += pow(result1 - result2 - result3, 5)
    return 28 * res"
"import math

def main(y):
    ans = 0
    n = len(y)
    for i in range(1, n + 1):
        ans += 10 * math.cos(89 * y[n - i] - y[n - i] ** 2 - 0.04) ** 7
    return ans"
"from math import cos, ceil

def main(x, z, y):
    n = len(x)
    sum_i = 0
    for i in range(1, n + 1):
        sum_i += cos(x[i - 1] + y[i - 1] ** 2 + 94 * z[n - ceil(i / 4)] ** 3) ** 7 / 26
    return 54 * sum_i"
"import math

def main(x, z, y):
    n = len(x)
    x.insert(0, 0)
    z.insert(0, 0)
    y.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 67 * x[n + 1 - math.ceil(i / 4)] ** 3
        middle = z[math.ceil(i / 3)]
        right = 94 * y[n + 1 - math.ceil(i / 3)] ** 2
        total += 35 * math.log2(left + middle + right) ** 5
    return 92 * total"
"import math

def main(y, x):
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 92 * y[n + 1 - i]
        right = x[n + 1 - i] ** 2
        total += left - right
    return 67 * total"
"import math

def main(*lst):

    def fun(num):
        return math.log(89 * num ** 3 + 20 * num, 10) ** 7
    res = 0
    x = lst[0]
    n = len(x) - 2
    for i in range(0, n + 2):
        res += fun(x[n + 1 - i // 3])
    return float('%.2e' % res)"
"import math

def main(y, z, x):
    n = len(y)
    y.insert(0, 0)
    z.insert(0, 0)
    x.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = y[i]
        middle = x[n + 1 - math.ceil(i / 2)] ** 3 / 72
        right = 62 * z[n + 1 - math.ceil(i / 4)] ** 2
        total += 24 * math.exp(left + middle + right)
    return 93 * total"
"def main(y, x):
    n = len(x)
    r = 0
    for i in range(0, n):
        r += (x[n - 1 - i] - 58 * x[i // 4] ** 3 - y[i // 2] ** 2) ** 7
    return r"
"from math import ceil

def main(y, x):
    f = 0
    n = len(y)
    for i in range(1, n + 1):
        f += (y[n - i] - 63 * x[n - ceil(i / 2)] ** 2) ** 2
    return f"
"import math

def main(y, x):
    ans = 0
    n = len(y)
    for i in range(1, n + 1):
        ans += 56 * (53 * y[math.ceil(i / 2) - 1] ** 2 + x[i - 1] + 45 * x[i - 1] ** 3) ** 4
    return 44 * ans"
"import math

def main(y, z, x):
    n = len(x)
    result = 0
    for i in range(1, n + 1):
        result += 80 * abs(46 * y[i - 1] + z[n - i] ** 2 + 63 * x[n - math.ceil(i / 4)] ** 3) ** 3
    return result"
"from math import floor

def main(y, z):
    n = len(y)
    a = 0
    for i in range(1, n + 1):
        a += 47 * (z[floor((i - 1) / 2)] ** 2 + 1 + y[floor((i - 1) / 3)] ** 3) ** 4
    return a"
"import math

def main(y):
    n = len(y)
    y.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        middle = y[n + 1 - math.ceil(i / 3)] ** 2
        middle2 = middle / 80
        total += middle2 ** 3
    return 26 * total"
"import math

def main(z, x, y):
    sum = 0
    n = len(z)
    for i in range(1, n + 1):
        sum += 19 * (47 * y[n + 1 - math.ceil(i / 2) - 1] ** 2 + 74 * z[n + 1 - i - 1] + x[n + 1 - math.ceil(i / 2) - 1] ** 3) ** 4
    return 45 * sum"
"import math

def main(z, y, x):
    n = len(z)
    res = 0
    for i in range(1, n + 1):
        res += 47 * (x[int((i - 1) / 4)] ** 2 - y[i - 1] - z[int((i - 1) / 3)] ** 3) ** 2
    return 16 * res"
"import math

def main(y, z, x):
    n = len(z)
    res = 0
    for i in range(1, n + 1):
        res += 48 * y[n - i] ** 3 - z[n - math.ceil(i / 3)] ** 2 / 76 - 75 * x[i - 1]
    return res"
"import math

def main(y, z, x):
    n = len(z)
    res = 0
    for i in range(1, n + 1):
        res += (9 * z[i - 1] ** 2 - 78 * x[int((i - 1) / 4)] - 94 * y[int((i - 1) / 2)] ** 3) ** 2
    return res"
"import math

def main(z):
    n = len(z)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        x = 28 * z[i] ** 2 - 46 * z[i]
        total += abs(x) ** 2
    return total"
"def main(z):
    A = 0
    for i in range(len(z)):
        A += 38 * (25 * z[i] ** 3 - z[i] - 36 * z[i] ** 2) ** 5
    return 65 * A"
"import math

def main(y, x, z):
    res = 0
    n = len(y)
    for i in range(1, n + 1):
        index1 = n + 1 - math.ceil(i / 4) - 1
        index2 = i - 1
        index3 = math.ceil(i / 3) - 1
        res += (90 * y[index1] ** 3 + z[index2] ** 2 + x[index3]) ** 7
    return 82 * res"
"import math

def main(z):
    n = len(z)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        total += 76 * math.log10(z[n + 1 - math.ceil(i / 3)]) ** 6
    return total"
"def main(x, z):
    a = 0
    for i in range(0, len(x)):
        a += 30 * (76 + z[i] ** 2 / 58 + 61 * x[len(x) - 1 - i] ** 3) ** 6
    return a * 95"
"def main(x):
    n = len(x)
    a = 0
    for i in range(1, n + 1):
        a += (45 * x[i - 1] ** 2 - x[i - 1] ** 3 / 96) ** 7
    return a"
"import math

def main(x, z, y):
    res = 0
    n = len(y)
    for i in range(1, n + 1):
        index1 = math.ceil(i / 3) - 1
        index2 = i - 1
        index3 = math.ceil(i / 4) - 1
        res += (y[index1] / 15 - 60 * x[index2] ** 3 - z[index3] ** 2) ** 4
    return 29 * res"
"import math

def main(z):
    n = len(z)
    z.insert(0, 0)
    sumv = 0
    for i in range(1, n + 1):
        temp = 0
        temp += z[math.ceil(i / 4)] ** 3 - 30 * z[n + 1 - math.ceil(i / 4)]
        sumv += math.floor(temp - 0.03) ** 3
    return sumv"
"import math

def main(z):
    res = 0
    n = len(z)
    for i in range(1, n + 1):
        res += (z[i - 1] ** 2 + 65 * z[i - 1] + 17) ** 3
    return res"
"def main(z):
    v = z
    result = 0
    for i in range(1, len(v) + 1):
        result = result + (v[len(v) - i] ** 2 + 97 * z[len(v) - i])
    return 34 * result"
"import math

def main(z, x, y):
    ans = 0
    n = len(y)
    for i in range(1, n + 1):
        ans += 80 * (z[n - math.ceil(i / 3)] - x[math.ceil(i / 4) - 1] ** 3 / 32 - y[math.ceil(i / 2) - 1] ** 2 / 46) ** 6
    return ans"
"import math

def main(x):
    n = len(x)
    x.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        bec = n + 1 - math.ceil(i / 4)
        yrov = 15 * math.exp(1 - 56 * x[bec] ** 2) ** 3
        total += yrov
    return total"
"from math import ceil

def main(x, y, z):
    n = len(x)
    a = 0
    for i in range(1, n + 1):
        a += 93 * (z[ceil(i / 2) - 1] ** 3 - 91 * y[n - ceil(i / 3)] ** 2 - 70 * x[n - i]) ** 2
    return a"
"import math

def main(z, y, x):
    n = len(z)
    z.insert(0, 0)
    y.insert(0, 0)
    x.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 21 * x[i] ** 2
        middle = z[n + 1 - math.ceil(i / 2)] ** 3 / 62
        right = y[n + 1 - math.ceil(i / 4)]
        total += 64 * math.exp(left + middle + right) ** 4
    return 18 * total"
"def main(y):
    f = 0
    n = len(y)
    for i in range(1, n + 1):
        f += 76 * (17 * y[i - 1] - y[i - 1] ** 3 - 35 * y[n - i] ** 2) ** 3
    return f"
"from math import ceil

def main(y, x):
    f = 0
    n = len(y)
    for i in range(1, n + 1):
        f += (y[n + 1 - i - 1] ** 3 + 1 + x[n + 1 - ceil(i / 3) - 1]) ** 7 / 53
    return float('{:.2e}'.format(42 * f))"
"from math import ceil

def main(z, y, x):
    res = 0
    n = len(y)
    for i in range(1, n + 1):
        res += (y[i - 1] ** 2 + x[ceil(i / 3) - 1] / 83 + 93 * z[n - i] ** 3) ** 3 / 16
    return res"
"import math

def main(z):
    n = len(z)
    z.insert(0, 0)
    res = 0
    for i in range(1, n + 1):
        res += 22 * (51 * z[n + 1 - math.ceil(i / 2)] ** 2 - 38 * z[math.ceil(i / 2)] - 92) ** 5
    return res"
"import math

def main(y, x, z):
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 10 * y[math.ceil(i / 3)] ** 3
        middle = 71 * z[i] ** 2
        right = x[math.ceil(i / 3)] / 46
        total += (left + middle + right) ** 4
    return 14 * total"
"from __future__ import annotations
import math
from typing import List

def get_amount(a: List[int | float]) -> int | float:
    n = len(a)
    summ = 0
    for i in range(1, n + 1):
        summ += (a[n - i] ** 3 + a[n - math.ceil(i / 2)] + 1) ** 5
    return summ

def main(a: List[int | float]) -> int | float:
    return 64 * get_amount(a)"
"from __future__ import annotations
import math

def example(z, x, y):
    n = len(z)
    summ = 0
    for i in range(1, n + 1):
        _y = y[n - i]
        _z = z[math.ceil(i / 2) - 1]
        _x = x[n - math.ceil(i / 2)]
        res = (_y ** 2 + 15 * _z + _x ** 3) ** 0.5
        summ += res / 67
    return summ

def main(z, x, y) -> int | float:
    return example(z, x, y)"
"import math

def main(y, x, z):
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    z.insert(0, 0)
    sum1 = 0
    for i in range(1, n + 1):
        result1 = y[math.ceil(i / 2)]
        result2 = pow(z[math.ceil(i / 4)], 2) / 85
        result3 = pow(x[n + 1 - i], 3)
        sum1 += result1 - result2 - result3
    return 30 * sum1"
"import math

def main(x, y, z):
    f = 0
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    z.insert(0, 0)
    for i in range(1, n + 1):
        f += 42 * z[math.ceil(i / 3)] ** 2 - 23 * y[n + 1 - math.ceil(i / 2)] ** 3 - 23 * x[n + 1 - i]
    return f"
"import math

def f(x, y):
    n = len(x)
    res = 0
    for i in range(1, n + 1):
        var1 = 52 * pow(x[i - 1], 3)
        var2 = x[math.ceil(i / 3 - 1)]
        var3 = 67 * pow(y[i - 1], 2)
        res += 58 * pow(var1 + var2 + var3, 6)
    return 24 * res

def main(*args):
    return f(*args)"
"import math

def main(z, x):
    n = len(x)
    z.insert(0, 0)
    x.insert(0, 0)
    res = 0
    for i in range(1, n + 1):
        left = z[n + 1 - math.ceil(i / 4)]
        right = x[math.ceil(i / 3)] ** 3
        res += 31 * math.pow(math.cos(left - right), 3)
    return 30 * res"
"from math import ceil

def main(y, x):
    n = len(y)
    a = 0
    for i in range(1, n + 1):
        a += 36 * (43 * x[n - i] ** 3 + 11 + y[ceil(i / 4) - 1]) ** 2
    return 14 * a"
"from math import sin

def main(x, y):
    f = 0
    for i in range(1, len(x) + 1):
        f += 34 * sin(y[(i - 1) // 3] ** 2 / 62 - x[i - 1]) ** 5
    return f"
"from math import ceil

def main(x):
    n = len(x)
    a = 0
    for i in range(1, n + 1):
        a += 25 * (92 * x[ceil(i / 2) - 1] + x[i - 1] ** 3 + x[i - 1] ** 2) ** 3
    return 14 * a"
"import math

def main(y, z, x):
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 61 * y[n + 1 - math.ceil(i / 3)] ** 3
        middle = 65 * x[math.ceil(i / 4)]
        right = z[n + 1 - i] ** 2
        total += 15 * (left + middle + right) ** 3
    return total"
"import math

def main(y):
    n = len(y)
    y.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 36
        middle = y[math.ceil(i / 2)]
        right = 33 * y[math.ceil(i / 2)] ** 3
        total += (left - middle - right) ** (7 / 2)
    return total"
"from math import ceil

def main(x):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res += 69 * (x[n - ceil(i / 3)] - x[i - 1] ** 2) ** 7
    return res"
"def main(y, z, x):
    n = len(z)
    res = 0
    for i in range(1, n + 1):
        res += 32 * (22 * x[n - i] ** 3 - z[n - i] - y[n - i] ** 2)
    res = 98 * res
    return res"
"import math

def main(z):
    sum = 0
    n = len(z)
    for i in range(1, n + 1):
        sum += pow(z[n - i] / 58 + 89 * pow(z[n - math.ceil(i / 4)], 2), 6)
    d = 89 * sum
    return float('%.2e' % d)"
"import math

def main(z, x):
    ans = 0
    n = len(x)
    for i in range(1, n + 1):
        ans += math.ceil(60 * z[n - math.ceil(i / 4)] ** 3 + x[n - math.ceil(i / 3)] + z[n - math.ceil(i / 2)] ** 2) ** 2
    return 65 * ans"
"import math

def main(x, z, y):
    sum = 0
    n = len(z)
    for i in range(1, n + 1):
        it = 84 * y[n - math.ceil(i / 4)] + 66 * z[math.ceil(i / 4) - 1] ** 3 + 75 * x[i - 1] ** 2
        sum += it ** 5
    return sum * 50"
"import math

def main(z, x):
    ans = 0
    n = len(x)
    for i in range(1, n + 1):
        ans += (23 * z[i - 1] - 33 * x[i - 1] ** 2) ** 7
    return ans"
"import math

def main(y):
    n = len(y)
    y.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 37 * y[n + 1 - i] ** 2
        middle = 1
        right = y[math.ceil(i / 3)] / 85
        total += 20 * (left - middle - right) ** 4
    return 54 * total"
"import math

def main(z, y):
    n = len(y)
    z.insert(0, 0)
    y.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = y[math.ceil(n + 1 - i)] ** 3
        right = 5 * z[math.ceil(n + 1 - i)]
        total += 74 * (1 - left - right) ** 7
    return total"
"import math

def main(x, z):
    ans = 0
    n = len(x)
    for i in range(1, n + 1):
        ans += 47 * math.sin(x[n - i] ** 3 / 26 + 43 * z[n - i] + 61 * z[n - i] ** 2) ** 2
    return 11 * ans"
"import math

def main(y):
    sum = 0
    n = len(y)
    for i in range(1, n + 1):
        sum += (28 - y[i - 1] ** 2 - y[n - math.ceil(i / 4)]) ** 6
    return 97 * sum"
"import math

def main(y):
    res = 0
    for i in range(0, 7):
        res += (38 * y[i // 3] ** 2 + 68 * y[i // 3] ** 3 + 1) ** 7
    return res * 78"
"def main(z, x, y):
    sum = 0
    for i in range(0, 7):
        a = 13 * y[i]
        b = x[6 - int(i / 4)] ** 3
        c = z[int(i / 3)] ** 2 / 72
        d = 37 * (a + b + c) ** 5
        sum += d
    return sum"
"from math import ceil

def main(z, x, y):
    n = len(z)
    s = 0
    for i in range(1, n + 1):
        s += (y[ceil(i / 3) - 1] - z[n - ceil(i / 4)] ** 3 - 29 * x[i - 1] ** 2) ** 4 / 31
    return 94 * s"
"def main(x, z):
    sum = 0
    for i in range(0, 6):
        a = 37 * z[len(z) - 1 - int(i / 4)] ** 3
        b = 97 * x[i] ** 2
        c = 78 * (a - b) ** 2
        sum += c
    return sum"
"import math

def main(z):
    ans = 0
    n = len(z)
    for i in range(1, n + 1):
        ans += math.ceil(50 * z[math.ceil(i / 3) - 1] ** 3 + 49 * z[math.ceil(i / 3) - 1] + 79) ** 4 / 64
    return 88 * ans"
"import math

def main(y, x, z):
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = y[n + 1 - i] ** 2
        middle = x[i] ** 3
        right = z[n + 1 - math.ceil(i / 3)]
        total += 41 * (left + middle + right)
    return total"
"import math

def main(z, y, x):
    res = 0
    n = len(z)
    for i in range(1, n + 1):
        res += (z[n - i] ** 2 - 75 * y[n - math.ceil(i / 2)] - x[math.ceil(i / 2) - 1] ** 3) ** 5
    return res"
"import math

def main(z, y, x):
    n = len(y)
    result = 0
    for i in range(1, n + 1):
        result += (x[n - math.ceil(i / 3)] - 57 * z[n - math.ceil(i / 4)] ** 3 - y[n - i] ** 2 / 12) ** 5
    return 44 * result"
"from math import ceil

def main(x, y):
    n = len(x)
    x.insert(0, 0)
    y.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 12 * y[i] ** 3
        middle = 48 * x[i]
        right = y[ceil(i / 3)] ** 2
        total += (left + middle + right) ** 3
    return 93 * total"
"import math

def main(y):
    sum1 = 0
    for i in range(len(y)):
        sum1 += (y[len(y) - 1 - i] ** 3 / 39 - y[len(y) - 1 - i] ** 2) ** 7
    return 51 * sum1"
"def main(y):
    ans = 0
    n = len(y)
    for i in range(1, n + 1):
        ans += (73 * y[n - i] ** 3 + y[n - i] ** 2 + 1) ** 3
    return 86 * ans"
"import math

def main(y, x):
    ans = 0
    n = len(y)
    for i in range(1, n + 1):
        ans += math.sqrt(99 * y[i - 1] + x[n - i] ** 2 + 39 * x[math.ceil(i / 2) - 1] ** 3) ** 6
    return ans"
"import math

def main(x, y):
    n = len(x)
    x.insert(0, 0)
    y.insert(0, 0)
    summa = 0
    for i in range(1, n + 1):
        a = x[n + 1 - math.ceil(i / 2)]
        b = y[n + 1 - math.ceil(i / 2)] ** 2
        summa += (a + b) ** 7
    return summa * 16 * 16"
"import math

def main(y, z):
    n = len(y)
    y.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = y[n + 1 - math.ceil(i / 4)] / 6
        right = 50 + 72 * z[math.ceil(i / 2)] ** 2
        total += math.cos(left + right) / 49
    return total"
"import math

def main(y, z, x):
    f = 0
    f1 = 0
    f2 = 0
    f3 = 0
    for i in range(len(x)):
        f1 = z[len(z) - 1 - i]
        f2 = y[math.floor(i / 4)] ** 2
        f3 = 9 * x[len(x) - 1 - math.floor(i / 2)] ** 3
        f += 78 * (f1 - f2 - f3) ** 6
    return f"
"import math

def main(z, x):
    ans = 0
    n = len(z)
    for i in range(1, n + 1):
        ans += 9 * (x[math.ceil(i / 3) - 1] ** 2 - 50 * z[n - i]) ** 2
    return 17 * ans"
"import math

def main(y, x):
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = x[n + 1 - math.ceil(i / 3)] / 2
        right = 95 * y[math.ceil(i / 3)] ** 2
        total += (0.33 + right + left) ** 5
    return 58 * total"
"import math

def main(y, x):
    s = 0
    n = len(x) - 1
    for i in range(1, n + 2):
        s += 50 * (x[n + 1 - i] + 28 * y[n + 1 - math.ceil(i / 4)] ** 2 + 81)
    return 51 * s"
"import math

def main(x):
    n = len(x)
    x.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 70 * x[math.ceil(i / 3)]
        right = x[math.ceil(i / 3)] ** 2 / 8
        total += (left - right) ** 3
    return total"
"from math import *

def main(x, z):
    f = 0
    n = len(x)
    for i in range(1, n + 1):
        f += sin(74 * z[i - 1] - x[n + 1 - i - 1] ** 2 / 87) ** 3
    return f"
"import math

def main(x, y):
    x = [0] + x
    y = [0] + y
    total = 0
    for i in range(1, len(x)):
        total = total + (math.pow(y[math.ceil(i / 3)], 3) - 87 * x[i] - math.pow(y[math.ceil(i / 2)], 2)) ** 5
    return total * 6"
"def main(y, z):
    import math
    n = len(z)
    res = 0
    y.insert(0, 0)
    z.insert(0, 0)
    for i in range(1, n + 1):
        res += 7 * (y[n + 1 - math.ceil(i / 4)] ** 2 - 15 * z[i] ** 3) ** 7
    return res"
"import math

def main(z):
    n = len(z)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        middle = 19 * z[n + 1 - math.ceil(i)]
        right = 13 * z[math.ceil(i / 4)] ** 2
        total += 15 * (middle - right) ** 6
    return 51 * total"
"def main(y):
    sum = 0
    n = len(y) - 1
    for i in range(0, n + 1):
        sum += (77 * y[n - int(i // 2)] ** 3) ** 2
    return sum"
"def main(y, x):
    result = 0
    for i in range(0, len(x)):
        first_term = y[i // 3]
        second_term = y[i // 3] ** 3
        third_term = 45 * x[len(x) - 1 - i] ** 2
        result += (first_term - second_term - third_term) ** 2 / 77
    return result"
"from math import ceil, tan

def main(y, z, x):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res += tan(x[ceil(i / 4) - 1] ** 2 - 56 * z[i - 1] - y[n - i] ** 3) / 64
    return res * 98"
"import math

def main(y, z, x):
    ans = 0
    n = len(x)
    y.insert(0, 0)
    x.insert(0, 0)
    z.insert(0, 0)
    for i in range(1, n + 1):
        ans += 9 * (x[math.ceil(i / 2)] ** 3 + 62 * z[n + 1 - math.ceil(i / 3)] ** 2 + y[math.ceil(i / 3)]) ** 7
    return 30 * ans"
"import math

def main(x):
    sum1 = 0
    for i in range(len(x)):
        sum1 += (67 * x[i] ** 2 + x[i] / 92) ** 7
    return sum1"
"from math import sin, ceil

def main(y, z, x):
    n = len(y)
    sum = 0
    for i in range(1, n + 1):
        buff = z[ceil(i / 3) - 1] ** 3
        buff -= x[i - 1] ** 2
        buff -= 84 * y[n - ceil(i / 3)]
        sum += sin(buff) ** 3
    sum *= 32
    return sum"
"def main(lst):
    a = 0
    n = 3
    for i in range(n):
        a = a + lst[2] ** 3 / 11
    return 6 * a"
"import math

def main(z, y):
    n = len(z)
    y.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = y[n + 1 - math.ceil(i / 2)] ** 2
        right = z[n + 1 - i] ** 3
        midle = 1
        total += (left - right - midle) ** 3
    return 95 * total"
"import math

def main(x, y, z):
    n = len(y)
    x.insert(0, 0)
    y.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = x[i] ** 3 / 3
        middle = y[n + 1 - math.ceil(i / 3)] ** 2
        right = 11 * z[math.ceil(i / 3)]
        total += (left - middle - right) ** 6
    return total"
"import math

def main(z, x, y):
    e = 0
    n = len(z)
    for i in range(n):
        e += 6 * math.ceil(y[i // 3] ** 2 + x[i // 4] ** 3 + z[n - 1 - i]) ** 6
    return e"
"import math

def main(y):
    n = len(y)
    y.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        total += (94 * y[n + 1 - math.ceil(i / 4)] ** 3) ** 4
    return 28 * total"
"import math

def main(z, y):
    n = len(z)
    z.insert(0, 0)
    y.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 69 * y[math.ceil(i)]
        right = 16 * z[math.ceil(n + 1 - i)] ** 2
        total += (left + 1 + right) ** 5
    return 63 * total"
"import math

def main(z, y, x):
    sum = 0
    for i in range(0, 4):
        sum += 30 * math.log(y[3 - int(i / 4)] ** 2 - 59 * z[3 - int(i / 2)] ** 3 - x[3 - i], math.exp(1)) ** 6
    return sum"
"def main(y, x, z):
    sum1 = 0
    for i in range(len(y)):
        sum1 += 17 * pow(50 * pow(x[i], 3) + 59 * pow(y[i // 3], 2) + z[i], 6)
    return sum1"
"import math

def main(x):
    n = len(x)
    x.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = x[math.ceil(i / 4)] ** 2
        middle = 68 * x[math.ceil(i / 4)] ** 3
        total += 55 * (left - middle - 43) ** 5
    return 79 * total"
"import math

def main(y, x):
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 81 * x[n + 1 - i] ** 2
        right = 50 * y[i]
        total += (left + right) ** 7
    return 8 * total"
"import math

def main(x):
    ans = 0
    n = len(x)
    for i in range(1, n + 1):
        ans += 46 * math.sqrt(x[n - math.ceil(i / 4)]) ** 7
    return 57 * ans"
"import math

def main(y, x):
    n = len(y)
    result = 0
    for i in range(1, n + 1):
        result += (1 + 86 * x[math.ceil(i / 4) - 1] ** 2 + y[n - math.ceil(i / 2)] ** 3) ** 3
    return result"
"import math

def main(x):
    n = len(x)
    sum_i = 0
    for i in range(1, n + 1):
        sum_i += (45 * x[n + 1 - math.ceil(i / 4) - 1] ** 3) ** 4
    return 5 * sum_i"
"import math

def main(z):
    n = len(z)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = (z[math.ceil(i / 4)] - 1 - z[math.ceil(i)] ** 3) ** 6
        total += left / 76
    return total"
"import math

def main(z, y, x):
    n = len(z)
    m = [0]
    x = m + x
    y = m + y
    z = m + z
    result = 0
    for i in range(1, n + 1):
        result += math.sqrt(x[math.ceil(i / 4)] ** 3 + 69 * z[n + 1 - i] + y[n + 1 - math.ceil(i / 3)] ** 2) ** 7
    return 41 * result"
"import math

def main(x):
    res = 0
    n = len(x)
    x.insert(0, 0)
    for i in range(1, n + 1):
        res += 78 * abs(x[n + 1 - math.ceil(i / 3)]) ** 3
    return 91 * res"
"import math

def main(z):
    n = len(z)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 97 * z[n + 1 - math.ceil(i / 2)] ** 2
        middle = z[math.ceil(i)] ** 3
        right = 28 * z[n + 1 - math.ceil(i / 2)]
        total += math.atan(left + middle + right) ** 7
    return total"
"import math

def main(z, y):
    n = len(y)
    z.insert(0, 0)
    y.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = y[i] ** 2 - 98 * z[n + 1 - math.ceil(i / 3)]
        right = 10 * y[math.ceil(i / 2)] ** 3
        total += (left - right) ** 7 / 69
    return total"
"import math

def main(z, y):
    ans = 0
    n = len(z)
    for i in range(1, n + 1):
        ans += 11 * (72 * z[i - 1] ** 2 - 4 - 55 * y[n - math.ceil(i / 2)] ** 3) ** 2
    return 65 * ans"
"import math

def main(z, x, y):
    sum = 0
    for i in range(0, 8):
        a = 88 * z[i] ** 2 - y[7 - i] - x[i] ** 3
        b = a ** 6
        c = b / 33
        sum += c
    return sum"
"import math

def main(x):
    n = len(x)
    result = 0
    for i in range(n):
        result += math.acos(x[n - math.ceil((i + 1) / 4)]) ** 5 / 70
    return result"
"from math import fabs, ceil

def main(y, z):
    r = 0
    n = len(y)
    for i in range(1, n + 1):
        r += fabs(z[i - 1] ** 3 - y[n - ceil(i / 3)] / 62) ** 7
    return 65 * r"
"from math import *

def main(x):
    f = 0
    n = len(x)
    for i in range(1, n + 1):
        f += (61 * x[ceil(i / 3) - 1] + 4 * x[i - 1] ** 2) ** 7 / 41
    return 32 * f"
"import math

def main(y, z):
    ans = 0
    n = len(z)
    for i in range(1, n + 1):
        ans += math.tan(0.02 + y[n - math.ceil(i / 4)] ** 2 + z[n - math.ceil(i / 2)]) ** 7
    return 36 * ans"
"import math

def main(x, z):
    total = 0
    n = len(x)
    x.insert(0, 0)
    z.insert(0, 0)
    for i in range(1, n + 1):
        left = z[n + 1 - math.ceil(i / 2)]
        right = 99 * x[n + 1 - math.ceil(i / 2)] ** 2
        total += 37 * (left + right) ** 2
    return 59 * total"
"import math

def main(x, y, z):
    n = len(y)
    x.insert(0, 0)
    y.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = x[n + 1 - math.ceil(i / 4)] / 41
        middle = y[n + 1 - math.ceil(i / 4)] ** 2
        right = 44 * z[n + 1 - math.ceil(i)] ** 3
        total += 77 * math.exp(left + middle + right) ** 3
    return 96 * total"
"from math import ceil

def main(z, x):
    n = len(z)
    f = 0
    for i in range(1, n + 1):
        f += x[n - ceil(i / 2)] ** 2 - 30 * z[n - i] - 92 * x[i - 1] ** 3
    return f"
"import math

def main(y):
    result = 0
    n = len(y)
    for i in range(1, n + 1):
        result += math.floor(58 * y[n - math.ceil(i / 2)] + 12 * y[n - math.ceil(i / 2)] ** 2) ** 3
    return 49 * result"
"from math import ceil

def main(x):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res1 = 28 * x[ceil(i / 4) - 1] ** 3
        res2 = 14 * x[n + 1 - i - 1]
        res += 81 * (res1 - res2) ** 5
    return 32 * res"
"import math

def main(z):
    a = 0
    for i in range(0, len(z)):
        d = z[math.ceil(i)] ** 3
        c = (69 + d + z[i] / 89) ** 7
        a = a + 43 * c
    return a"
"import math

def main(*lst):

    def fun(a, b):
        return (a + 20 + b ** 3 / 41) ** 4
    (x, z) = lst
    res = 0
    for i in range(1, len(x) + 1, 1):
        res += fun(z[math.ceil(i / 2) - 1], x[len(x) - i])
    return res"
"import math

def main(*lst):

    def fun(a, b):
        return (a ** 3 / 62 + 28 * b ** 2 + 1) ** 3
    (z, y) = lst
    res = 0
    for i in range(len(y)):
        res += fun(y[i], z[6 - i])
    return 43 * res"
"import math

def main(x, z, y):
    n = len(x)
    result = 0
    for i in range(1, n + 1):
        result += 71 * 36 * (51 * y[n - i] - x[n - math.ceil(i / 2)] ** 2 - 89 * z[n - i] ** 3) ** 5
    return result"
"import math

def main(z):
    z.insert(0, 0)
    i = 1
    n = 2
    s = 0
    a = 0
    r = 0
    for i in range(n):
        i = i + 1
        r = 43 * z[n + 1 - math.ceil(i / 2)] ** 3 - 1
        s = 29 * (r - 47 * z[n + 1 - math.ceil(i / 2)] ** 2) ** 4
        a = a + s
    return a"
"import math

def main(z, y):
    n = len(z)
    z.insert(0, 0)
    y.insert(0, 0)
    result = 0
    for i in range(1, n + 1):
        left = z[math.ceil(i / 3)] / 39
        middle = y[math.ceil(i)] ** 2
        right = 81 * z[math.ceil(i / 3)] ** 3
        result += 82 * (left + middle + right) ** 5
    return 95 * result"
"import math

def main(x, z):
    n = len(x)
    x.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = x[math.ceil(i / 4)]
        right = z[math.ceil(n + 1 - i)] ** 2 / 40 + 6
        total += (left - right) ** 3
    return 52 * total"
"from math import ceil, cos

def main(z, y, x):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res += cos(14 * x[n - ceil(i / 3)] ** 2 + 9 * y[ceil(i / 3) - 1] + 70 * z[ceil(i / 3) - 1] ** 3) ** 4
    return 22 * res"
"import math

def main(z, y):
    ret = 0
    n = len(z)
    for i in range(1, n + 1):
        ret += abs(97 * z[math.ceil(i / 2) - 1] - y[n + 1 - i - 1] ** 3) ** 4
    return ret"
"def main(y, x, z):
    f = 0
    n = len(y)
    for i in range(0, n):
        a = 64 * y[n - (int(i / 2) + 1)] ** 3
        f += 39 * (a + z[n - (int(i / 4) + 1)] + x[i] ** 2)
    return f"
"from math import ceil

def main(z, x):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res += 65 * (7 * z[n - i] - 69 * x[i - 1] ** 3 - 1)
    return res"
"from math import *

def main(y, z, x):
    f = 0
    n = len(y)
    for i in range(1, n + 1):
        f += 65 * sin(z[ceil(i / 2) - 1] - y[i - 1] ** 3 - x[ceil(i / 4) - 1] ** 2) ** 3
    return f"
"from math import ceil

def main(y, z, x):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res += (90 * x[i - 1] ** 3 + 25 * z[n - ceil(i / 2)] ** 2 + y[n - i]) ** 3 / 65
    return 66 * res"
"import math

def main(x, y):
    s = 0
    n = len(x)
    for i in range(0, n):
        s += (y[n - 1 - i] ** 2 - 1 - x[math.ceil((i + 1) / 2) - 1] / 34) ** 4
    return 38 * s"
"from math import ceil, log

def main(x):
    res = 0
    n = len(x)
    for i in range(1, len(x) + 1):
        res += 99 * log(x[n - ceil(i / 3)]) ** 2
    return 76 * res"
"import math

def main(y, x, z):
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 31 * y[n + 1 - math.ceil(i / 4)] ** 3
        middle = 59 * x[n + 1 - i] ** 2
        right = 76 * z[n + 1 - math.ceil(i / 3)]
        total += 1 / 76 * (left - middle - right) ** 7
    return 76 * total"
"import math

def main(x, z):
    n = len(x)
    x.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 80 - x[n + 1 - math.ceil(i / 3)] ** 2
        middle = z[math.ceil(i / 2)]
        total += 12 * (left - middle) ** 6
    return total"
"import math

def main(y, x):
    n = len(y)
    sum_i = 0
    for i in range(1, n + 1):
        sum_i += math.sin(1 + y[n + 1 - math.ceil(i / 4) - 1] + x[i - 1] ** 2) ** 6 / 22
    return 95 * sum_i"
"import math

def main(x, z):
    s = 0
    n = len(x)
    for i in range(1, n + 1):
        s += 56 * math.exp(39 * z[n - 1 - i] + 1 + x[n - 1 - i] ** 3) ** 7
    return s"
"from math import tan
from math import ceil

def main(x, z):
    n = len(x)
    a = 0
    for i in range(0, n):
        a += tan(1 + x[n - ceil((i + 1) / 3)] + z[i] ** 2) ** 7
    return a"
"import math

def main(z):
    ans = 0
    n = len(z)
    for i in range(1, n + 1):
        ans += 93 * (3 + 98 * z[n - math.ceil(i / 2)] + z[i - 1] ** 3) ** 3
    return 40 * ans"
"import math

def main(z, x, y):
    res = 0
    n = len(z)
    for i in range(1, n + 1):
        index1 = n + 1 - math.ceil(i / 4) - 1
        index2 = n + 1 - i - 1
        index3 = i - 1
        res += 98 * (72 * x[index1] ** 3 + z[index2] ** 2 + y[index3]) ** 7
    return res"
"import math

def main(x):
    sum1 = 0
    n = len(x)
    for i in range(1, n + 1):
        sum1 += 74 * math.tan(x[n + 1 - math.ceil(i / 4) - 1]) ** 4
    return 6 * sum1"
"import math

def main(z, y):
    n = len(y)
    z.insert(0, 0)
    y.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 13
        middle = y[math.ceil(i)] ** 3
        right = 40 * z[n + 1 - math.ceil(i / 3)]
        total += 49 * (left + middle + right) ** 2
    return 55 * total"
"from math import sin, cos, log10, sqrt, floor, ceil
from array import *

def main(z, x, y):
    n = len(x)
    summ = 0
    for i in range(1, n + 1):
        res1 = y[i - 1] ** 3 - 35 * z[n - ceil(i / 4)]
        res2 = 53 * x[n - ceil(i / 3)] ** 2
        res = 75 * log10(abs(res1 - res2)) ** 7
        summ = summ + res
    return summ"
"import math

def main(x, z):
    n = len(x)
    x.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = x[n + 1 - math.ceil(i / 4)] ** 3 / 17
        right = 53 * z[n + 1 - math.ceil(i / 4)] ** 2
        total += (left + right) ** 4
    return total"
"def main(x):
    n = len(x)
    r = 0
    for i in range(n):
        r += 5 * (x[n - 1 - i // 3] ** 2 - 1) ** 6
    return r"
"import math

def main(x, z, y):
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = y[n + 1 - math.ceil(i / 3)] / 74
        center = z[n + 1 - math.ceil(i / 2)] ** 2
        right = 33 * x[math.ceil(i / 2)] ** 3
        total += 69 * (left + center + right)
    return total"
"from math import ceil

def main(x, y, z):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res1 = x[ceil(i / 3) - 1] ** 3
        res2 = z[ceil(i / 4) - 1]
        res3 = y[i - 1] ** 2 / 77
        res += (res1 + res2 + res3) ** 6 / 94
    return res"
"import math

def main(x, y):
    n = len(x)
    x.insert(0, 0)
    y.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        a = 77 * y[i] ** 2 + 39 * x[math.ceil(i / 4)] ** 3 + 69
        total += math.log(a) ** 6
    return total"
"import math

def main(z, y):
    n = len(z)
    y.insert(0, 0)
    z.insert(0, 0)
    result = 0
    for i in range(1, n + 1):
        left = 62
        midle = z[math.ceil(i / 4)] / 68
        right = y[math.ceil(i / 2)] ** 2
        result += 64 * math.exp(left + midle + right)
    return 34 * result"
"import math

def main(y, z):
    n = len(y)
    y.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = z[i] + 38 * y[math.ceil(i / 3)] ** 3 + y[math.ceil(i / 3)] ** 2 / 65
        right = 16
        total += math.log10(left) ** 7 / right
    return 66 * total"
"from math import ceil

def main(y, z, x):
    n = len(y)
    a = 0
    for i in range(1, n + 1):
        a += 91 * (y[n - ceil(i / 2)] ** 2 + 72 * x[n - i] + 69 * z[n - ceil(i / 2)] ** 3)
    return 98 * a"
"def main(z, y):
    log = 0
    for i in range(1, len(z) + 1):
        log += 65 * y[len(z) - i] ** 2 - z[i - 1] ** 3 / 14
    return log"
"import math

def main(y, x, z):
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    z.insert(0, 0)
    result = 0
    for i in range(1, n + 1):
        left = y[n + 1 - math.ceil(i / 4)] ** 3
        middle = x[math.ceil(i / 3)] ** 2
        right = 11 * z[i]
        result += (left - middle - right) ** 7
    return result"
"import math

def main(*vec):
    z = vec[0]
    y = vec[1]
    summ = 0
    for i in range(len(z)):
        newz = 38 * z[math.ceil((i + 1) / 3) - 1] ** 3
        newy = y[math.ceil((i + 1) / 4) - 1]
        summ += 97 * abs(newz - newy) ** 7
    return summ"
"import math

def main(*vec):
    z = vec[0]
    y = vec[1]
    x = vec[2]
    summ = 0
    for i in range(len(z)):
        newy = 53 * y[len(z) - i - 1] ** 3
        newz = z[math.ceil((i + 1) / 4) - 1]
        newx = 70 * x[math.ceil((i + 1) / 3) - 1] ** 2
        summ += math.floor(newy + newz + newx) ** 2
    return summ"
"def f(y, z):
    a = 0
    n = len(z)
    for i in range(0, n):
        a += 21 * pow(pow(y[i // 3], 3) - 51 * z[n - 1 - i] - 69 * pow(y[i // 3], 2), 4)
    return a

def main(*args):
    return f(*args)"
"import math

def main(n):
    return f(n)

def f(n):
    em = len(n)
    e = math.exp
    gt = 0
    for i in range(1, em + 1):
        g = 1 + 73 * n[math.ceil(i / 4) - 1] ** 3 + 66 * n[math.ceil(i / 4) - 1] ** 2
        gt += math.log(g) ** 2
    gt = gt * 58
    return gt"
"import math

def main(x, y):
    res = 0
    x.insert(0, 0)
    y.insert(0, 0)
    for i in range(1, len(x)):
        res1 = x[i] ** 2
        res2 = 69 * y[math.ceil(i / 3)]
        res = res + (res1 - 1 - res2) ** 2
    return res * 98"
"import math

def main(y, z, x):
    s = 0
    a = [None]
    a.extend(y)
    b = [None]
    b.extend(z)
    c = [None]
    c.extend(x)
    for i in range(1, len(x) + 1):
        tmp = a[len(x) + 1 - math.ceil(i / 3)] ** 3 / 90
        s += 90 * (27 * b[i] + c[math.ceil(i / 4)] ** 2 + tmp) ** 7
    return 13 * s"
"import math

def main(y, x):
    n = len(y)
    res = 0
    y.insert(0, 0)
    x.insert(0, 0)
    for i in range(1, n + 1):
        first = x[math.ceil(i / 2)] ** 3
        second = y[n + 1 - math.ceil(i / 4)] ** 2
        res += math.exp(first + 1 + second) ** 6
    return res"
"import math

def main(y, z):
    s = 0
    n = len(y)
    for i in range(1, n + 1):
        s = s + 4 * (29 * y[n - 1 + 1 - i] - 94 - z[n - 1 + 1 - math.ceil(i / 3)] ** 2) ** 3
    return s"
"from math import ceil

def main(z, x, y):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res += (x[i - 1] ** 3 / 63 - 87 * y[i - 1] - z[ceil(i / 2) - 1] ** 2) ** 5
    return res"
"import math

def main(x):
    res = 0
    n = len(x) - 1
    for i in range(1, n + 2):
        p = x[n + 1 - i]
        res += 37 * (32 - 18 * p ** 3 - p ** 2 / 85) ** 3
    return res * 68"
"import math

def main(y):
    n = len(y)
    f = 0
    for i in range(n):
        f += 95 * math.log10(y[n - 1 - i // 4] ** 3 + 27 * y[n - 1 - i // 4] ** 2 + 28 * y[n - 1 - i // 4]) ** 2
    return 71 * f"
"import math

def main(x):
    n = len(x)
    x.insert(0, 0)
    s2 = 0
    for i in range(1, n + 1):
        s1 = math.log10(19 * x[math.ceil(i / 2)] ** 3) ** 4 / 38
        s2 += 48 * s1
    return s2"
"from math import exp

def main(y):
    n = len(y)
    total = 0
    y.insert(0, 0)
    for i in range(1, n + 1):
        temp = y[n + 1 - i] ** 3 / 39
        total += exp(temp) ** 6 / 36
    return 71 * total"
"import math

def main(y, z):
    sum = 0
    n = len(y)
    for i in range(n):
        sum += 20 * y[n - 1 - math.floor(i / 2)] ** 2 - z[math.floor(i / 3)] ** 3
    sum *= 8
    return sum"
"from math import *

def main(y, z):
    s = []
    for i in range(0, len(z)):
        x = 53 * (68 * z[i] ** 2 - 39 - y[len(z) - 1 - i]) ** 4
        s.append(x)
    return 63 * sum(s)"
"from math import ceil

def main(z):
    n = len(z)
    res = 0
    for i in range(1, n + 1):
        res += (90 * z[i - 1] ** 3 - z[n - ceil(i / 3)] - 46) ** 5
    return res"
"def main(z):
    n = len(z)
    k = 0
    for i in range(n):
        k += z[i] ** 3 / 49 + 29 * z[n - 1 - i] ** 2 + 75
    return k"
"import math

def main(y, x):
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 0.01
        middle = 42 * x[i] ** 3
        right = y[math.ceil(i / 3)] ** 2
        total += 8 * (left + middle + right) ** 4
    return 9 * total"
"import math

def main(y, x, z):
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = z[n + 1 - i] ** 3
        middle = x[math.ceil(i / 3)]
        right = 80 * y[n + 1 - i] ** 2
        total += 98 * (left - middle - right) ** 4
    return total"
"import math

def main(z):
    n = len(z)
    r = 0
    for i in range(n):
        r += math.ceil(69 * z[i // 3] ** 2 - 1 - z[i // 4] ** 3) ** 2
    return 55 * r"
"import math

def main(y):
    ans = 0
    n = len(y)
    for i in range(1, n + 1):
        ans += 63 * math.ceil(y[n - math.ceil(i / 2)] - 67 * y[n - math.ceil(i / 2)] ** 3 - 1) ** 4
    return 75 * ans"
"import math

def main(y, z):
    n = len(y)
    y.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = z[math.ceil(i / 4)]
        middle = 49 * y[math.ceil(i / 3)] ** 2
        right = 51
        total += 2 * (left + middle + right) ** 7
    return 93 * total"
"from math import ceil

def main(z, x, y):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res += (26 * y[n - i] - z[ceil(i / 4) - 1] ** 3 - 80 * x[n - i] ** 2) ** 3
    return 32 * res"
"import math as m

def main(*lst):
    (y, x) = lst
    res = 0
    for i in range(1, len(x) + 1, 1):
        res += (x[len(x) - m.ceil(i / 4)] - y[len(y) - i] ** 2 - 0.01) ** 2
    return res"
"import math

def main(y, z, x):
    n = len(y)
    n1 = len(y) - 2
    f = 0
    for i in range(0, n):
        f += (89 * x[n1 + 1 - math.floor(i / 2)] + 18 * z[n1 + 1 - math.floor(i / 3)] ** 3 + 10 * y[n1 + 1 - math.floor(i / 4)] ** 2) ** 6
    return f * 33"
"import math

def main(x, z):
    s = 0
    n = len(z)
    z.insert(0, 0)
    x.insert(0, 0)
    for i in range(1, n + 1):
        s += 91 * math.atan(z[i] + x[math.ceil(i / 3)] ** 2) ** 7
    return s"
"import math

def main(x, z):
    ans = 0
    n = len(x)
    for i in range(1, n + 1):
        ans += 4 * (1 + 85 * z[n - i] ** 3 + 15 * x[n - math.ceil(i / 4)]) ** 7
    return 11 * ans"
"import math

def main(z, y):
    n = len(y)
    y.insert(0, 0)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 71 * z[math.ceil(i / 2)] ** 2
        middle = 1
        right = 27 * y[n + 1 - i] ** 3
        total += (left + middle + right) ** 6
    return 71 * total"
"import math

def main(x, z):
    sum = 0
    for i in range(0, 3):
        a = z[i] ** 3
        b = x[math.floor(i / 3)] ** 2
        c = b / 71
        d = 82 * x[math.floor(i / 4)]
        e = a - c - d
        f = e ** 6
        g = f / 38
        sum += g
    sum1 = 32 * sum
    return sum1"
"from math import *

def main(z):
    res = 0
    n = len(z)
    for i in range(1, n + 1):
        res += log2(26 * z[ceil(i / 3) - 1] ** 2) ** 2 / 21
    return res * 51"
"from math import log

def main(y, x):
    result = 0
    n = len(y)
    for i in range(n):
        result += log(17 * x[n - 1 - i] - pow(y[n - 1 - int(i / 3)], 3) / 57) ** 4
    return result"
"from math import ceil, log10

def main(x):
    n = len(x)
    f = 0
    for i in range(1, n + 1):
        f += log10(99 * x[n - ceil(i / 4)] ** 3) ** 4
    return f * 45"
"def main(x, z):
    n = len(x)
    a = 0
    for i in range(1, n + 1):
        a += (72 - z[n - i] - x[i - 1] ** 3) ** 3 / 76
    return 47 * a"
"import math

def main(z):
    n = len(z)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = 66 * z[math.ceil(i)]
        middle = -z[n + 1 - math.ceil(i / 2)] ** 2
        right = -1
        total += 93 * math.cos(left + middle + right) ** 2
    return 99 * total"
"from math import ceil

def main(z):
    f = 0
    n = len(z)
    for i in range(1, n + 1):
        f += 58 * (z[ceil(i / 3) - 1] - z[i - 1] ** 3 / 40) ** 4
    return f"
"from math import log, ceil

def main(x):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res += 77 * log(x[n - ceil(i / 4)], 2) ** 5
    return 7 * res"
"from math import ceil, cos

def main(z):
    res = 0
    n = len(z)
    for i in range(1, n + 1):
        res += (92 + z[n - ceil(i)] + 3 * z[n - ceil(i)] ** 2) ** 7
    return 10 * res"
"import math as m

def f(z, x, y):
    n = len(z)
    s = 0
    for i in range(1, n + 1):
        s += 94 * (28 * z[i - 1] ** 2 + 85 * y[n - m.ceil(i / 3)] + 69 * x[m.ceil(i / 3) - 1] ** 3) ** 2
    return s

def main(z, x, y):
    return f(z, x, y)"
"from math import ceil

def main(y, z, x):
    res = 0
    n = len(x)
    for i in range(1, n + 1):
        res += y[n - i] ** 3 / 18 + 55 * x[ceil(i / 2) - 1] ** 2 + 15 * z[n - ceil(i / 4)]
    return res"
"import math

def main(x, y):
    s = 0
    n = len(y)
    y.insert(0, 0)
    x.insert(0, 0)
    for i in range(1, n + 1):
        a = y[math.ceil(i / 4)] + 1
        b = 4 * x[n + 1 - math.ceil(i / 3)] ** 3
        s += 57 * math.log(a + b)
    return s"
"import math

def main(z, x, y):
    s = 0
    n = len(z)
    z.insert(0, 0)
    x.insert(0, 0)
    y.insert(0, 0)
    for i in range(1, n + 1):
        a = 81 * y[i] ** 2
        b = z[n + 1 - math.ceil(i / 4)]
        c = 20 * x[i] ** 3
        s += (a + b + c) ** 4
    return s"
"import math

def main(x, z, y):
    f = 0
    n = len(z)
    n1 = len(z) - 2
    for i in range(0, n):
        a = 90 * z[i] ** 3 - 54 * y[n1 + 1 - math.floor(i / 2)]
        b = x[math.floor(i / 2)] ** 2 / 64
        f += (a - b) / 77
    return f * 13"
"import math

def main(y):
    s = 0
    n = len(y)
    y.insert(0, 0)
    for i in range(1, n + 1):
        a = y[n + 1 - i] ** 3 / 80
        s += 71 * math.fabs(64 - a) ** 7
    return s"
"import math

def main(z):
    n = len(z)
    z.insert(0, 0)
    total = 0
    for i in range(1, n + 1):
        left = abs(z[n + 1 - math.ceil(i / 2)])
        total += 67 * left ** 2
    return 61 * total"