code
"import math

def main(x):
    if x < 55:
        return x ** 6 + 67 * x + 1
    elif 55 <= x < 122:
        return 7 * x ** 2 + x / 76
    else:
        return math.ceil(x) ** 5 / 98 - x / 25"
"import math

def main(x):
    if x < 55:
        return x ** 6 + 67 * x + 1
    elif 55 <= x < 122:
        return 7 * x ** 2 + x / 76
    else:
        return math.ceil(x) ** 5 / 98 - x / 25"
"import math

def main(x):
    if x < 55:
        return x ** 6 + 67 * x + 1
    elif 55 <= x < 122:
        return 7 * x ** 2 + x / 76
    elif x >= 122:
        return math.ceil(x) ** 5 / 98 - x / 25"
"import math

def main(z):
    if z < 13:
        return z ** 5
    elif z < 75:
        return (18 * z) ** 4 / 25 - 1 - z ** 2
    elif z < 133:
        return 65 * z ** 3
    elif z < 217:
        return 78 * z ** 2
    else:
        return (90 - z ** 2 - z) ** 7 / 84 - math.log(z) - math.sin(z) ** 6"
"def main(x):
    if x < 6:
        return 87 * x ** 5
    if x < 19:
        return (33 * x ** 2 + x ** 3 + 59 * x) ** 6
    return abs(77 * x + 1) + x ** 4"
"def main(y):
    if y < 125:
        return 4 * y ** 2 - y ** 5 - 82
    elif y < 195:
        return 66 * y ** 5 + 65 * y ** 4
    elif y < 280:
        return 28 * y - y ** 21 / 35 - 46 * (y ** 3 / 62 - 40 - 40 * y) ** 6
    elif y < 379:
        return 0.02 + (y ** 2 - 13 * y ** 3 - y) ** 7 / 5
    return 1 + abs(y) / 37 + 12 * abs(y ** 2 + 89) ** 5"
"def main(x):
    if x < 6:
        return 87 * x ** 5
    if x < 19:
        return (33 * x ** 2 + x ** 3 + 59 * x) ** 6
    return abs(77 * x + 1) + x ** 4"
"def main(x):
    if x < 6:
        return 87 * x ** 5
    if x < 19:
        return (33 * x ** 2 + x ** 3 + 59 * x) ** 6
    return abs(77 * x + 1) + x ** 4"
"def main(x):
    if x < 6:
        return 87 * x ** 5
    if x < 19:
        return (33 * x ** 2 + x ** 3 + 59 * x) ** 6
    return abs(77 * x + 1) + x ** 4"
"import math

def main(z):
    if z < 13:
        return z ** 5
    elif z < 75:
        return (18 * z) ** 4 / 25 - 1 - z ** 2
    elif z < 133:
        return 65 * z ** 3
    elif z < 217:
        return 78 * z ** 2
    else:
        return (90 - z ** 2 - z) ** 7 / 84 - math.log(z) - math.sin(z) ** 6"
"import math

def main(x):
    if x < 123:
        return 1 + 13 * x ** 2
    elif x >= 123 and x < 143:
        return x ** 4 / 35
    elif x >= 143 and x < 236:
        return 70 * x ** 3 - math.exp(x)
    elif x >= 236:
        t = 70 * (x + 1 + 35 * x ** 2) ** 5
        return t + (x ** 2 + 34 * x ** 3) ** 3"
"import math

def main(z):
    if z < 13:
        return z ** 5
    elif z < 75:
        return (18 * z) ** 4 / 25 - 1 - z ** 2
    elif z < 133:
        return 65 * z ** 3
    elif z < 217:
        return 78 * z ** 2
    else:
        return (90 - z ** 2 - z) ** 7 / 84 - math.log(z) - math.sin(z) ** 6"
"from math import pow, ceil, fabs

def f(y):
    if y < 45:
        return 40 * pow(y, 7) - pow(y, 6)
    elif y < 100:
        return 42 * pow(51 * y + pow(y, 3), 7)
    elif y < 189:
        return 20 * pow(ceil(pow(y, 2) - 23 * pow(y, 3) - y / 83), 7) + 46 * fabs(y)
    else:
        return 7 * pow(y, 10) + pow(pow(y, 3) + pow(y, 2) + 72 * y, 4)

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

def main(y: float) -> float:
    y2 = y ** 2
    if y >= 54:
        return (22 * y2) ** 5 - 37 * y2 - math.cos(y) ** 7
    y3 = y * y2
    if y < 25:
        return 93 * y * y3 - 8 * (83 * y2 + 91 * y3) ** 7 - 79 * math.sin(y) ** 5
    else:
        return 17 * (1 + 44 * y3) ** 5 - 33 * y3 ** 2 - y2 / 20"
"import math

def main(x):
    if x < 91:
        return (x ** 3 + x ** 2 + 42 * x) ** 5 - 43 * (41 * x ** 3 + x ** 2 + 50) - x ** 6 / 87
    if 91 <= x < 155:
        return 24 * math.sin(x ** 2 + 97 + x ** 3) ** 6 + math.atan(x ** 2) ** 4
    if x >= 155:
        return x ** 7 + 87 * math.atan(1 + x ** 3 + x) ** 5 + (52 * x ** 2 - 35 - 70 * x) ** 6"
"import math as m

def main(z):
    if z < 21:
        return (75 + 13 * z) ** 7
    elif 21 <= z < 93:
        return 1 - 66 * z ** 2 - 53 * z ** 7
    elif 93 <= z < 160:
        return m.cos(z) ** 7
    elif 160 <= z < 204:
        return z ** 4 - m.cos(27 + z ** 2 + 35 * z ** 3) ** 2 / 20
    else:
        return 0.5 - z ** 7 - 90 * z ** 4"
"import math as Math

def main(x):
    result = 0
    if x < 109:
        result = 74 * x ** 4 - 87 * (40 - 48 * x ** 3) - x ** 3 / 92
    elif 109 <= x < 202:
        result = Math.log(74 + x ** 3) ** 6 + 63 * (18 * x ** 2 + x + x ** 3) ** 3
    else:
        result = 89 * Math.sin(x) ** 6 - 37 * x ** 5
    return result"
"def main(y):
    if y < 65:
        return 88 * y ** 3 + (70 * y ** 2 - 1 - 65 * y) ** 4
    elif 65 <= y < 78:
        return (74 * y ** 3 + 0.2 + y) ** 5 / 8 - 55
    elif 78 <= y < 108:
        return 24 * y ** 2 + 30 * (1 + y ** 3 + 67 * y ** 2)
    elif y >= 108:
        return y ** 2 + 61 * (77 * y ** 2 - y) ** 7"
"import math as m

def main(z):
    if z < -9:
        return m.exp(z) ** 4 / 28 - 65 * m.atan(z) ** 2 - 1
    if -9 <= z < 13:
        return z ** 7
    if z >= 13:
        return 20 * z ** 7 - (21 * z * z) ** 5"
"import math

def main(y):
    if y < 38:
        f = y + (99 * y) ** 7 + 52
        return f
    elif y >= 38 and y < 54:
        f = y + (86 * y + 18) ** 6
        return f
    elif y >= 54 and y < 149:
        f = (43 * y ** 3 - 43 * y * y) ** 6 - 0.05 - math.atan(y * y * y) ** 7
        return f
    elif y >= 149 and y < 235:
        f = math.sin(y) ** 4 + y ** 3
        return f
    else:
        f = 35 * y ** 4
        return f"
"import math

def main(x):
    if x < 37:
        f = 75 * math.fabs(x) ** 5 - 1
        return f
    elif 37 <= x < 125:
        f = 65 * (18 * x ** 3) ** 4
        return f
    elif 125 <= x < 218:
        f = 36 - 28 * x
        return f
    elif 218 <= x < 241:
        f = 20 * math.fabs(x - x ** 3 - 1) ** 7 - 6 * math.sin(x ** 2) - 27 * x
        return f
    elif x >= 241:
        f = 40 * x ** 2 + x ** 5
        return f"
"import math

def main(z):
    if z < 105:
        f1 = (z + 62) ** 5
        f2 = (60 - z ** 3 - 36 * z) ** 3 / 83
        res = 14 + f1 + f2
    elif 105 <= z < 189:
        res = 63 * z ** 3
    else:
        f1 = (94 * z ** 2) ** 2 / 6
        f2 = 23 * z ** 6
        f3 = math.log10(z) ** 3
        res = f1 + f2 + f3
    return res"
"import math

def main(z):
    if z < 148:
        f = 71 * math.log2(z) ** 2
        f += 99 * math.atan(46 * z) ** 4 + 96 * math.exp(z) ** 5
    elif z >= 148 and z < 186:
        f = z ** 5 + 41 + (z + 94 * z ** 2) ** 4 / 17
    elif z >= 186 and z < 247:
        f = 80 * z ** 7 + math.sin(z)
    elif z >= 247 and z < 294:
        f = 1 - z ** 2 / 25
    elif z >= 294:
        f = math.log2(19 * z ** 3 + 1 + z) ** 5
    return f"
"import math

def main(x: float) -> float:
    if x < 112:
        return 6 * math.pow(x, 5)
    elif x < 137:
        return 1 - 71 * math.pow(4 * math.pow(x, 2) - 1, 6) - 91 * x ** 3
    elif x < 232:
        return math.pow(math.atan(x), 6)
    else:
        return 43 - math.pow(x / 6 - math.pow(x, 2), 7) / 60"
"def main(y):
    from math import log
    from math import atan
    if y < -2:
        return atan(y) ** 6 + y ** 2 / 19
    elif y < 47:
        return log(y)
    else:
        return y ** 6 / 35 + 65 * y"
"import math

def main(y):
    if y < 68:
        f = 6 * math.floor(y / 46) ** 4 - (y - 45 * y ** 2) ** 6 / 49
    elif y < 152:
        f = y ** 4 - (69 * y ** 2 - 60 * y) / 20 - 55 * (y ** 3 - 14) ** 2
    else:
        f = 72 * y ** 5 + 99 * y ** 2
    return f"
"def main(z):
    if z < 64:
        return 0.03 - 57 * z ** 2
    if 64 <= z < 138:
        return (80 * z ** 3 - 7 * z) ** 6
    if 138 <= z < 194:
        return (63 + z ** 3) ** 4
    if z >= 194:
        return 50 * z ** 7"
"import math

def main(z):
    if z < 19:
        return 28 * (64 - z ** 3 - 76 * z ** 2) ** 5 + z ** 2
    if 19 <= z < 115:
        return z - 89 * math.sin(z ** 3 / 75) ** 5
    if 115 <= z < 212:
        return z ** 3
    if z >= 212:
        return 14 * (z ** 2 / 51) ** 4 + 98 * z ** 6 + z ** 7"
"from math import acos, sqrt

def main(z):
    if z < 40:
        f = z ** 7
    elif 40 <= z < 135:
        f = 1 + 41 * z ** 5 + 12 * z ** 8
    elif 135 <= z < 197:
        f = z ** 6 + z ** 5
    elif 197 <= z < 248:
        f = (z ** 2 / 62 + 1) ** 4 - 86 * z ** 2 - (33 - z ** 3 / 14) ** 3
    elif z >= 248:
        f = 41 * z ** 2
    return f"
"from math import log

def main(x):
    if x < -22:
        return x - 90 * log(x ** 2 + x) ** 3
    elif -22 <= x < 32:
        return 70 - (x ** 3 + x + 59)
    else:
        return 39 * x ** 5"
"from math import *

def main(z):
    if z < 36:
        f = (z + 22 * z ** 2) ** 5 - 21
    elif 36 <= z < 114:
        f = 10 * (z ** 2 - z) ** 7
    elif 114 <= z < 149:
        f = 83 * z - 1
    elif 149 <= z < 243:
        f = 66 * z
    elif z >= 243:
        f = (z ** 3 - 62 * z) ** 2
    return f"
"from math import cos, sin, log, sqrt, floor, ceil

def main(x):
    if x < 109:
        res = 29 * x ** 7 - x ** 3 / 20 - 1
    if 109 <= x < 157:
        res = 17 * x ** 3 + x ** 7
    if 157 <= x < 174:
        res = ceil(x) ** 6
    if 174 <= x < 257:
        res = 82 - cos(x) - 55 * x ** 3
    if x >= 257:
        res = 49 * (70 * x ** 2 + 66 * x + 56 * x ** 3) ** 2
    return res"
"from math import sin, cos, log, sqrt, tan, asin

def main(z):
    if z < 73:
        f = 82 * z ** 4 - int(z ** 2 + 89) ** 7 - 88
    elif 73 <= z < 107:
        f = log(z, 2) ** 6 + z + z ** 7
    elif z >= 107:
        f = z ** 2 + 28 * round(z) ** 7
    return f"
"def main(z):
    if z < 49:
        return abs(z)
    elif 49 <= z < 113:
        return z ** 2 + z ** 5 / 43
    elif 113 <= z < 192:
        return 85 * z ** 3 + (1 + 34 * z ** 2) ** 7 / 62
    elif 192 <= z < 234:
        return 1 - abs(z) ** 5
    elif z >= 234:
        return 1 - (z ** 3 + 16 + 96 * z ** 2) ** 7"
"from math import log, ceil, sqrt

def main(x):
    if x < 129:
        return 17 + ceil(x ** 2) + 31 * sqrt(x / 38)
    if 129 <= x < 187:
        return 47 * log(x) ** 7 - (x ** 3 + 1 + x) / 64 - 1
    if x >= 187:
        return 25 * x ** 6 + x ** 3 + (x / 58 + x ** 3) ** 4"
"def main(x):
    result = 0
    if x < 43:
        result = 86 * (x - 1 - x * x) ** 4
    elif x >= 43 and x < 61:
        result = (x - 46 * x * x - 1) ** 6 / 30 - x ** 3
    elif x >= 61 and x < 160:
        result = (27 * x * x - 27 * x ** 3) / 44
    elif x >= 160:
        result = 88 * x ** 7
    return result"
"from math import log, e

def main(z):
    if z < -44:
        return z ** 4 / 65
    elif -44 <= z < 26:
        return 57 * (81 * z ** 2 + 19 * z + 1) ** 6 + z
    elif z >= 26:
        return 33 * log(60 * z ** 2, e) ** 6 - 1 - (2 * z ** 2 + z ** 3 / 66) ** 7"
"from math import cos, tan

def main(z):
    if z < 112:
        return 1 - z ** 4
    if 112 <= z < 138:
        return 34 * z ** 6 - cos(z) ** 6
    if z >= 138:
        return z + 86 * tan(z) ** 5"
"from math import floor, log

def main(z):
    if z >= 208:
        return z ** 2 - 20 * z - (z ** 3 + z ** 2 + 1) ** 6
    elif z >= 192:
        res1 = floor(z ** 3 + 0.03) ** 7 / 50
        res2 = log(z ** 2 + 1 + 55 * z ** 3, 2) / 78
        res3 = z ** 4 / 77
        return res1 + res2 + res3
    elif z >= 152:
        return 18 * z
    elif z >= 133:
        return 17 * z ** 3 - 55 * (1 - 11 * z) ** 5 - 51 * z ** 3
    else:
        return 18 * z + z ** 5 + log(z, 10) ** 4 / 24"
"import math

def main(y):
    if y < 123:
        return y ** 6 + y ** 5 + 1
    elif 123 <= y < 220:
        return 75 * y ** 3 + 65 * (25 + y ** 3 + y) ** 6
    elif 220 <= y < 299:
        return 82 * (89 * y) ** 3 - (85 * y ** 2 - 1) ** 2
    else:
        return y ** 3 - math.cos(75 * y ** 2 - 3 - y) ** 5 - y"
"from math import sin, cos, log10, sqrt, floor, ceil

def main(z):
    if z < -14:
        res1 = (z - 29 * z ** 3 - 45 * z ** 2) ** 6
        return res1 - 75 * (60 * z + z ** 2 + 0.01) ** 7
    elif z >= -14 and z < 14:
        return z ** 6 / 71 - 43 * log10(z ** 2 / 44) ** 7
    elif z >= 14 and z < 57:
        return (1 - z ** 3) ** 4 - 24 * z ** 5
    elif z >= 57 and z < 102:
        return 87 * z ** 5 - 1
    elif z >= 102:
        return z ** 4 / 83"
"from math import *

def main(z):
    if z < 115:
        f = 57 * abs(z) ** 7 - 36 * (z ** 2 - 1) ** 6 - 39 * z ** 5
    elif 115 <= z < 169:
        f = (98 * z ** 3) ** 6 + 7 * exp(z / 81 - z ** 3 - 0.02) ** 2
    elif z >= 169:
        res1 = 25 * abs(84 * z) ** 7
        res2 = (63 * z - 82 * z ** 2 - 52 * z ** 3) ** 6 / 22 - 1
        f = res1 - res2
    return f"
"from math import cos

def main(y):
    if y < 180:
        return 94 + (y / 88 + y ** 3 + y ** 2) ** 6
    elif 180 <= y < 198:
        re1 = (11 * y ** 2 - 91 * y - 87) ** 4
        re2 = 94 * cos(58 * y ** 3 - 77 * y ** 2)
        return re1 + re2
    elif 198 <= y < 220:
        return 49 * abs(y) ** 3
    elif 220 <= y < 236:
        return (95 - 51 * y ** 3 - 5 * y) ** 2
    else:
        return 55 * y ** 4 - y ** 6"
"from math import log

def main(z):
    if z < -57:
        f = 62 * log(3 - z ** 3, 2) ** 2 - 84 * z ** 3
    elif -57 <= z < -15:
        f = 69 * (1 - z - z ** 3) + 35 * (z ** 3 + 45) ** 5
    elif -15 <= z < 47:
        f = z / 37 - 0.02 - z ** 6 / 9
    elif z >= 47:
        f = 72 + z ** 2
    return f"
"def main(z):
    if z < 45:
        return 26 * (z ** 2 - 33 * z ** 3 - 65) ** 2
    if z >= 45 and z < 124:
        return 74 * (z ** 2 + 60 * z + z ** 3) ** 4
    if z >= 45 and z < 178:
        return 44 * z ** 3
    if z >= 178:
        return 85 * (35 * z) ** 3"
"from math import cos, log

def main(z):
    if z < 11:
        return 25 * (55 * z) ** 3
    elif 11 <= z < 96:
        res1 = 18 * log(z - 1, 2) ** 2 - 93 * (37 * z ** 2 - 6 * z) ** 6
        res2 = 36 * abs(z) ** 3
        return res1 - res2
    elif 96 <= z < 145:
        res3 = 73 * (59 * z) ** 3 - 41 * (z ** 3 - 63 * z ** 2) ** 4
        res4 = 6 * log(z)
        return res3 - res4
    elif 145 <= z < 177:
        return 90 * z - 83 * z ** 2 - 75 * z ** 3
    elif z >= 177:
        return 11 * z ** 5 - (1 - z) ** 6 / 61 - 43 * cos(z)"
"from math import tan

def main(x):
    if x < 102:
        return 47 * x ** 3 - 87 * (89 + 75 * x) ** 7 - 1
    elif 102 <= x and x < 147:
        return (38 + x ** 2 + x ** 3 / 59) ** 5 + (8 - x ** 2) ** 3
    elif 147 <= x and x < 193:
        res1 = 63 * (x ** 2 / 97 + 52 * x) ** 5
        res2 = 54 * tan(x + x ** 2) ** 6
        res3 = 52 * (x ** 2 + 1 + 56 * x) ** 2
        return res1 - res2 - res3
    elif 193 <= x and x < 291:
        return 1 + (7 * x ** 3 - 57 - x / 37) ** 4
    elif x >= 291:
        res4 = 42 * int(x - x ** 2 - 1) ** 4
        res5 = 49 * (x - 1 - x ** 2) ** 6
        res6 = 99 * abs(x) ** 7
        return res4 - res5 - res6"
"def main(x):
    if x < 51:
        z = 53 * pow(4 * pow(x, 3), 5) + 1
        return z.real
    if 51 <= x < 101:
        z = 72 * pow(57 + pow(x, 3) / 92, 4) + (pow(pow((x, 2) / 40) - 55 * x), 7) / 3
        return z.real
    if x >= 101:
        z = 82 * pow(x, 6) + 62 * pow(pow(x, 3) + 85 * x, 3)
        return z.real"
"from math import *

def main(z):
    rez = 0
    if z < 59:
        rez = 25 * pow(85 * pow(z, 2) - 54 * pow(z, 3), 3)
    elif 59 <= z < 106:
        rez = pow(tan(1 - pow(z, 2) / 79), 6) + pow(z, 5)
    elif 106 <= z < 145:
        rez = pow(24 + 56 * z, 6) + 78 * abs(pow(z, 5)) + pow(1 - pow(z, 3) - z, 7)
    elif z >= 146:
        rez = 3 * pow(log(z, 10), 5) - 57 * pow(tan(z + pow(z, 3)), 6) - 1
    return rez.real"
"def main(z):
    if z < 79:
        return 4 * z ** 4 + z ** 2
    if 79 <= z and z < 99:
        return 9 * (27 * z - 96 * z ** 2) ** 2 + z ** 3 / 86
    if z >= 99:
        return 43 * abs(57 * z ** 2 - z ** 3 / 15 - 82) ** 3"
"from math import *

def main(x):
    if x < 82:
        return 53 * (33 * x ** 3) ** 3 + 5 * x ** 2
    elif 82 <= x < 116:
        return 27 * x ** 4 + 55 * x ** 5 + log10(x ** 2 / 44 + 78) ** 7
    elif 116 <= x < 186:
        return (80 - 54 * x - 60 * x ** 3) ** 5 / 62
    elif 186 <= x < 204:
        return 89 * (x ** 2 - 49 * x ** 3 - 36) ** 7
    else:
        return 17 * atan(0.01 - x ** 2) ** 2 + log(x) ** 4 + 1 + x / 7"
"def main(y):
    if y < 56:
        f = 21 - 33 * y
    elif y >= 56 and y < 139:
        f = 27 * abs(44 * y ** 3) - y ** 7 - pow(78 * y - 49 * y ** 2 - 1, 2)
    elif y >= 139:
        f = 32 + 78 * y ** 3
    return f"
"def f(y):
    if y < 103:
        a = 46 * (y ** 3 / 7 + y) ** 2
        b = 51 * (y ** 3 / 76 - y ** 2 - y) ** 3
        return a - b
    elif y >= 162:
        return y ** 7 + y ** 2
    else:
        return 3 + abs(94 * y ** 3 + y ** 2 + 1) ** 3 + y ** 4 / 90

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

def main(z):
    res1 = 68 * z ** 7 - 79 * (1 - 8 * z ** 3 - z ** 2 / 70) ** 6
    res2 = z ** 6
    res3 = cos(92 + z ** 2) ** 4
    if z < 55:
        return res1
    elif 55 <= z < 150:
        return res2
    else:
        return res3"
"def main(x):
    if x < 157:
        return 47 * x ** 7 + x
    elif 157 <= x < 236:
        return 30 * (x ** 2 + 14 * x + 54) ** 7 + x ** 4 + 62 * x ** 6
    elif 236 <= x < 307:
        return 1 + 27 * (0.01 - 64 * x ** 2 - 34 * x) ** 5
    elif 307 <= x < 332:
        return 78 * (21 * x ** 3 - x - 1) ** 2 - (89 * x ** 2 + 37 * x ** 3) ** 6 - x ** 3
    else:
        return 23 - 71 * abs(37 * x ** 2 - 60 * x - 1) ** 7 - x"
"from math import *

def main(y):
    if y < 48:
        result = 76 * pow(97 * pow(y, 2), 3) - 37 * pow(y, 7)
        -pow(y / 29 - pow(y, 2) - 1, 2) / 76
    if 48 <= y < 120:
        result = pow(y, 2)
    if 120 <= y < 186:
        result = 17 * pow(tan(y), 3)
    if y >= 186:
        result = 38 * pow(y, 7) + 33 * pow(pow(y, 3) + 71 * y, 3)
    return result"
"import math

def main(z):
    if z < 18:
        return 46 * z - 44
    elif 18 <= z < 75:
        return z ** 6 / 43 + (1 - z / 55) ** 7
    elif 75 <= z < 146:
        return (33 * z ** 3) ** 6
    elif 146 <= z < 236:
        t1 = (1 - z) ** 4
        t2 = 83 * (78 - 75 * z ** 3) ** 2
        t3 = 71 * math.sin(40 * z + z ** 3 + 44 * z ** 2)
        return t1 - t2 - t3
    else:
        return z ** 6 / 89 - 88 * z ** 4"
"from math import log10, log2

def main(y):
    if y < 117:
        return 90 * y ** 6 + log10(y) ** 3 + 59 * abs(63 + y ** 2 + 51 * y ** 3) ** 4
    elif 117 <= y < 189:
        return 55 * y ** 5 - 2 * (y ** 3 + 0.03) ** 4
    elif 189 <= y < 252:
        return 66 * log2(23 * y ** 2)
    elif 252 <= y < 284:
        return 23 * (y ** 2 - 74 * y ** 3 - 1) + 80 * y ** 4
    else:
        return y ** 2 + (89 + y ** 2 + y) ** 4 + (y + y ** 2) ** 6"
"import math

def main(x):
    if x < 97:
        return 92 * x + 72 * math.cos(x ** 3 / 3 + x * x + 1) ** 6
    elif x < 167:
        return (38 * x ** 2 - 1) ** 5 + (92 - x * x / 99 - x ** 3) ** 7 + x - 1 - 86 * x ** 2
    elif x < 226:
        return 89 * (79 * x ** 3 + x * x) ** 6
    return math.tan(x) ** 6 / 58 + 86 * (x * x - 23 * x ** 3) ** 3"
"import math

def main(z):
    z0 = 0
    z1 = 0
    if z < 8:
        z1 = 93 * pow(z, 2) + 33 * pow(z, 3)
    if z >= 8 and z < 97:
        z1 = 0.02 + pow(z, 3) / 7
    if z >= 97:
        z0 = pow(z, 3) - 82 * pow(z, 2) - 1
        z1 = 1 + 15 * pow(z, 6) + 41 * pow(z0, 3)
    return z1"
"from math import log2, floor

def main(z):
    if z < 17:
        return 72 * z ** 3
    elif 17 <= z & z < 29:
        return (65 - 40 * z ** 2 - z ** 3) ** 2 + z ** 6 / 55 + 73
    elif 29 <= z & z < 84:
        return 2 * floor(1 + 21 * z ** 3) - 8 * z ** 7 - 28 * log2(z) ** 6
    elif z >= 84:
        return 38 * (36 + 44 * z) ** 3"
"import math

def main(z):
    if z < 74:
        res = 86 * math.log(z, 2) ** 6 - math.atan(1 + 98 * z ** 3 + z / 99) ** 3 - 1
    elif 74 <= z < 171:
        res = (z - 1 - z ** 3) ** 5
    elif 171 <= z < 208:
        res = 66 * (1 + 11 * z ** 2 + z ** 3)
    elif z >= 208:
        res = math.exp(8 * z ** 2 - 23 * z ** 3 - z) ** 3 / 45 - z ** 6 / 90
    return res"
"import math

def main(z):
    if z < 96:
        return z
    elif 96 <= z < 194:
        return 78 * z ** 2 + 1 + z ** 5
    elif 194 <= z < 253:
        return math.log2(z ** 3) ** 6
    elif z >= 253:
        return 73 * math.cos(z) ** 4"
"from math import cos, atan, exp

def main(x):
    if x < 49:
        return cos(x) ** 7 + 95 * x ** 6 + x ** 15
    elif 49 <= x < 65:
        return atan(x) + x ** 3
    elif 65 <= x < 102:
        return 80 * (x - x ** 2) - 24 * (x ** 3 - 57 * x) ** 5
    elif 102 <= x < 201:
        return x ** 7
    else:
        return exp(x) + (6 - x ** 2 - x ** 3) ** 4"
"from math import atan

def main(x):
    if x < 161:
        return 54 * x
    elif 161 <= x < 193:
        return atan(x)
    else:
        return 1 + x ** 4 / 7"
"import math

def main(x):
    if x < 18:
        return 98 * math.tan(x) ** 5 + 58 * x ** 6
    if x < 36:
        ans = math.cos(x ** 3 / 67 - 1) ** 7
        ans += +42 * (1 - x ** 2 / 37) ** 6 + 89 * x ** 5
        return ans
    if x < 108:
        return 93 + x ** 3 + 25 * math.floor(x ** 3) ** 7
    return 38 * (20 * x - x ** 2 - 86) ** 3"
"def main(y):
    if y >= 191:
        return y ** 3
    elif y >= 121:
        return 35 * (y + 1 + y ** 2) ** 4
    elif y >= 21:
        return 1 + 83 * y ** 7
    else:
        return 16 * (y ** 2 + 35 + y / 51) ** 5"
"from math import log2, sqrt, exp

def main(z):
    if z < -10:
        return 22 * (43 * z + z ** 2) - z ** 4
    elif z < 84:
        return z ** 4 + exp(1 - z ** 3 - 78 * z ** 2) + z ** 7
    else:
        res1 = 88 * (z ** 3 - z ** 2 - 43) ** 2 + 1
        res2 = abs(z ** 3 + 60 * z + 57 * z ** 2) ** 6
        return res1 + res2"
"import math

def main(x):
    if x < -27:
        return 95 * x ** 5
    elif x < 43 and -27 <= x:
        return 90 * x ** 4 + 79 * x ** 2 + 1
    elif 43 <= x and x < 98:
        return x ** 3
    elif 98 <= x and x < 147:
        return 18 * math.atan(x + 0.01) ** 5 - 71 * ((x ** 3 - 14 - x ** 2) // 1 + 1) ** 4 - 1
    else:
        return 27 * math.exp(x) ** 2 - 55 * math.atan(x ** 3) ** 6"
"def main(y):
    if y < 11:
        return y * y / 23
    elif 11 <= y < 90:
        return (82 * y + 40 * y ** 3 + 99 * y * y) ** 2
    else:
        return (y + y * y) ** 7 / 41 + (33 * y ** 3 + 1) ** 6"
"def main(y):
    if y < -24:
        res1 = 2 * (29 * y - y ** 2 - 37) ** 3
        return res1
    elif -24 <= y < 15:
        res2 = 3 * y
        return res2
    elif y >= 15:
        res3 = 32 * int(y) ** 2
        return res3"
"import math

def main(y):
    if y < 14:
        return 75 * y ** 4 - 33 * y
    elif 14 <= y < 78:
        return y ** 6 / 13 + (62 * y) ** 4
    elif y >= 78:
        return 15 * math.ceil(y) ** 6 + 49 * math.log10(y) ** 3"
"from math import atan

def main(y):
    if y < 97:
        return atan(y) ** 6 + 27 * (13 * y - 1) + y ** 2 / 95
    elif 97 <= y < 157:
        return 49 * (y ** 2 - y ** 3) + y ** 4
    else:
        return y"
"from math import log10

def main(x):
    res = x
    if x < 58:
        res = (x ** 2 / 95 - 27 * x - 1) ** 7 - 98
    if 58 <= x < 133:
        res = 62 * x ** 4
    if 133 <= x < 199:
        res = x ** 2 / 70 - x ** 3
    if 199 <= x < 211:
        res = 51 * log10(x) ** 4
    if x >= 211:
        res = x + 82 * (x - 1 - x ** 2) ** 7
    return res"
"import math

def main(y: float) -> float:
    if y < 128:
        return 24 * y ** 7
    elif 128 <= y < 149:
        return 25 * math.ceil(y) ** 6 - 20 * y ** 3
    else:
        return (55 - y - 80 * y ** 3) ** 2 + y ** 5 / 24"
"from math import atan, log, sin

def main(x):
    if x < 17:
        rez = (1 - x ** 3) ** 6 + 96 * log(x) ** 2
    elif 17 <= x < 85:
        rez = atan(x) ** 4 - x ** 7 - 1
    elif 85 <= x < 135:
        rez = (25 * x ** 3 + 0.02) ** 7 - 76 * (1 + x + x ** 2) ** 2
    elif x >= 135:
        rez_1 = 35 * (x ** 2 - 1 - x ** 3) ** 7
        rez_2 = sin(91 * x ** 3) + (x ** 2 + 77) ** 2
        rez = rez_1 + rez_2
    return rez"
"import math
from math import atan, sin, log10, log2, floor, cos

def cal1(x):
    res1 = 58 * (x + x * x + 76 * x ** 3) ** 3 - 1
    return res1

def cal2(x):
    res2 = x ** 7
    return res2

def cal3(x):
    res3 = 1 - 79 * cos(x)
    return res3

def cal4(x):
    res4 = 47 * x ** 7 - log2(x) ** 4 - x * x
    return res4

def cal5(x):
    res5 = 53 + (1 + 25 * x) ** 3 + abs(x)
    return res5

def main(x):
    if x < 67:
        return cal1(x)
    if x >= 67 and x < 105:
        return cal2(x)
    if x >= 105 and x < 177:
        return cal3(x)
    if x >= 177 and x < 240:
        return cal4(x)
    if x >= 240:
        return cal5(x)"
"from math import ceil, floor

def main(y):
    if y < 61:
        res = (1 - 99 * y ** 3) ** 6 + abs(51 * y ** 3) ** 4
    if y >= 132:
        res = 64 * floor(y) ** 3 - 36
    if 61 <= y < 132:
        res = ceil(y) ** 7 - 61 * y ** 5
    return res"
"def main(z: int):
    if z < 104:
        res = (45 * z ** 3 - z / 39 - 56 * z ** 2) ** 6 + 1
    elif 104 <= z < 176:
        res = (z ** 2 - z) ** 7 + z / 67 + z ** 4
    elif 176 <= z < 218:
        res = (3 * z) ** 3 + 14 * (79 * z) ** 5
    else:
        res = 77 * z + 45 * z ** 5
    return res"
"from math import log10, log2, sqrt, exp, tan

def main(z):
    if z < -12:
        return (37 * z ** 2 + 1 + z ** 3 / 37) ** 6
    if z < 60:
        return z + (z ** 3 / 82 + z ** 2 / 41 + z) ** 4 + 19 * log2(11 + z) ** 3
    if z < 157:
        return tan(24 * z ** 3) ** 7 + (0.11 + 37 * z ** 2) ** 6 + z ** 4 / 77
    return 94(z + z ** 3) ** 2 - z ** 5 - z ** 14"
"from math import cos

def main(x):
    if x < 35:
        return (55 * x ** 2 - 32 * x - 1) ** 6 - (18 * x ** 2) ** 2
    if 35 <= x < 90:
        return 93 + 35 * x ** 7
    return 1 + 2 * (59 * x ** 3 + 2 * x ** 2 + 1) ** 2 + 43 * cos(x) ** 4"
"from math import sin

def main(x):
    if x < -3:
        return 46 * x ** 4 + 1
    elif x < 12:
        return 72 * x - (14 * x - 7)
    elif x < 36:
        return (x ** 3 - 82 * x - x ** 2) ** 6 + 81 * x + 77 * (87 * x ** 2) ** 7
    else:
        return (66 * x + x ** 3) ** 5 + 8 * sin(x) ** 4"
"from math import atan

def main(y):
    if y < 164:
        res1 = 58 + 92 * (20 * y) ** 3 + (51 * y ** 2 - y ** 3 - 4 * y) ** 5 / 93
    elif 164 <= y < 221:
        res1 = 0.02 + 53 * atan(18 * y) ** 4 + y ** 3
    elif 221 <= y < 284:
        res1 = (24 * y ** 3 - y) ** 2 / 62
    elif y >= 284:
        res1 = 16 * (y ** 2 - 1) ** 4 - 6 * y ** 2
    return res1"
"from math import sqrt, log, tan, fabs

def main(z):
    if z < 106:
        res = 88 * z ** 6 + 94 + (z ** 3 + 45 * z) ** 5
        return res
    if 106 <= z and z < 188:
        res = 23 * tan(90 * z) ** 2 + z ** 7
        return res
    if 188 <= z and z < 263:
        res1 = 1 - sqrt(86 * z + 27 * z ** 3 + 90) ** 5
        res2 = (z ** 2 + 17 * z ** 3) ** 6
        return res1 - res2
    if z >= 263:
        res3 = 78 * (1 + z ** 3 + z ** 2 / 10) ** 3
        res4 = 92 * log(z ** 3 + 50 * z ** 2 + z, 2) - fabs(z) ** 4
        return res3 - res4
    return 0"
"import math

def main(y):
    if y < 174:
        return y ** 6 + 58 * math.sin(y ** 3 - 6 * y - 1) ** 5
    elif 174 <= y < 262:
        return y ** 7 - 93 * (34 * y - 45 * y ** 3 - 50) ** 4 - (y ** 3 + y ** 2) ** 2
    return math.log(y, 2) + y ** 5 + math.log(y, 10) ** 3 / 52"
"from math import exp, atan

def main(x):
    if x >= 183:
        return atan(x) ** 5 - 9 * exp(x) ** 3 - 1
    elif 119 <= x < 183:
        return 57 * (x ** 2 + 1 + 25 * x ** 3) ** 5 - 49 * x ** 2
    elif 97 <= x < 119:
        return 51 * x ** 6
    elif 39 <= x < 97:
        return 13 + (x - x ** 2 - 67 * x ** 3) ** 6 + (x + x ** 2) / 22
    else:
        return 67 * x"
"from math import log10, sin, acos

def main(y):
    if y < 70:
        return 19 * y ** 2
    if y < 82 and y >= 70:
        m = 5 * y ** 7 + 82 * acos(84 * y + 98) ** 2 + 84 * y ** 3
        return m
    if y < 132 and y >= 82:
        return y ** 6 - 29 * log10(y)
    if y < 219 and y >= 132:
        return 15 * y
    if y >= 219:
        return y ** 4 + (69 - y ** 3) ** 6 + sin(y) ** 5"
"from math import cos, atan, exp

def main(z):
    if z < -50:
        res = abs(z ** 2 - z ** 3) + 39
    elif z < -18:
        res = cos(z) ** 5 + 34 * z ** 2 + 10 * (1 - 13 * z ** 3) ** 4
    elif z < 43:
        a = exp(z) ** 3 - 20 * abs(z) ** 4
        b = 35 * (14 * z - 42 - 24 * z ** 2) ** 5
        res = a - b
    elif z < 110:
        res = z ** 4 + 62 * z ** 7
    else:
        res = 2 * z ** 10 + atan(z) ** 4
    return res"
"def main(x: int):
    if x < -12:
        x = 98 * x ** 3
    elif -12 <= x < 74:
        x = 1 + 44 * (x * x - 52) ** 4 + (x * x + 94 * x ** 3 + 1) ** 6
    else:
        x = (x ** 3 / 11 + 37 * x + 70) ** 3 / 3 - x / 5
    return x"
"def main(y):
    if y < 118:
        f = y ** 15 - 21 * y ** 12
    elif 118 <= y < 187:
        f = 61 * y ** 5 - 25 * (1 - 23 * y ** 2) ** 4 - 21 * abs(y - 71 - y ** 3) ** 3
    elif 187 <= y < 244:
        f = 52 * (y ** 3 / 69 + y + 89 * y ** 2) ** 4
    elif y > 244:
        f = y ** 5
    return f"
"from math import sqrt, exp, floor, atan, cos

def main(z):
    res1 = 18 * pow(atan(65 * z ** 2), 7) - 81 * z - z ** 6 / 89
    res2 = 35 * z ** 2 + pow(cos(z ** 2), 4)
    res3 = z ** 6 - 75 * z ** 2 - pow(z ** 3 - 56 * z - 19, 4)
    if z < 93:
        return res1
    if 187 > z >= 93:
        return res2
    if z >= 187:
        return res3"
"import math

def main(y):
    if y < 64:
        return 1 - 47 * pow(y, 3)
    elif y >= 64 and y < 99:
        return 35 * pow(y, 6) + 15
    elif y >= 99 and y < 168:
        return pow(y, 5) / 55 - pow(75 * y + pow(y, 2) + pow(y, 3), 6) - 82 * pow(math.log(33 * pow(y, 3) - 1, 2), 7)
    else:
        return pow(math.tan(49 * y + 2 * pow(y, 2)), 5) - 17 * pow(y, 7) - pow(y, 6)"
"import math

def main(y):
    if y < 64:
        return 1 - 47 * pow(y, 3)
    elif y >= 64 and y < 99:
        return 35 * pow(y, 6) + 15
    elif y >= 99 and y < 168:
        return pow(y, 5) / 55 - pow(75 * y + pow(y, 2) + pow(y, 3), 6) - 82 * pow(math.log(33 * pow(y, 3) - 1, 2), 7)
    else:
        return pow(math.tan(49 * y + 2 * pow(y, 2)), 5) - 17 * pow(y, 7) - pow(y, 6)"
"from math import atan, tan

def main(x):
    if x < 85:
        res1 = atan(x) ** 4 + 1
        res2 = 59 * (63 * x + 40 + 75 * x ** 3) ** 6
        return res1 + res2
    elif (x >= 85) & (x < 177):
        res = 85 - 55 * (32 * x) ** 2 - tan(x) ** 7
        return res
    elif (x >= 177) & (x < 188):
        return x ** 6
    elif (x >= 188) & (x < 287):
        res = x ** 6 - 19 * (x ** 3 + 88 + x ** 2) ** 4 - x ** 9
        return res
    else:
        return 28 * (42 * x) ** 4"
"from math import sqrt, exp, floor, atan, cos, log

def main(y):
    res_1_1 = 71 * y ** 2 - (33 * y ** 3 - 99 * y - 23 * y ** 2)
    if y < -24:
        return res_1_1 - pow(cos(y), 5) / 52
    if -24 <= y < -2:
        return pow(95 - y * y * y, 2)
    if -2 <= y < 65:
        return pow(log(y), 2) + 74 * y
    if y >= 65:
        return 41 * pow(log(76 * y * y * y + 90 * y * y + y, 10), 5)"
"import math

def main(x):
    if x < 16:
        return 26 * x ** 18 - 28 * x ** 2 - 50 * math.sin(1 - x ** 2)
    elif x < 90:
        return 50 * (1 - x) ** 3 - x ** 2
    elif x < 173:
        return x ** 4
    else:
        return 12 * (42 * x - x ** 2 - 72 * x ** 3) + 75 * abs(x) ** 4"
"from math import log

def main(x):
    if x < 102:
        a = (32 * x ** 3 - 42 * x - 1) ** 4 / 25
        b = 57 * (39 * x ** 3 - 59 * x) ** 5
        res = a + b
    elif x < 116:
        res = x
    else:
        res = log(x, 10) ** 7
    return res"
"import math

def main(z):
    if z < 167:
        return 37 * z ** 3 + 40 + z * z + 71 * math.log2(z) ** 6
    elif 167 <= z < 180:
        return 83 * z ** 6 - math.log2(z)
    else:
        return 2 * z ** 6 - 99 * (z / 56 - z ** 3 - 90) ** 4"
"def main(x):
    if x < 59:
        return 83 * pow(x + 39 + 87 * pow(x, 3), 2)
    if 59 <= x < 157:
        return 60 * pow(x, 5) - 24 * x * x
    if 157 <= x < 231:
        return 75 * x * x * x
    if 231 <= x < 275:
        return 62 * x * x + 1 + 41 * pow(x + 1 + 60 * x * x, 4)
    if x >= 275:
        return 60 * pow(26 * x, 5)"
"from math import log2

def main(z):
    if z < 141:
        f = log2(z) ** 7 / 22 + 79 * z ** 4
    elif z >= 141 and z < 228:
        f = 42 * z ** 7
    elif z >= 228 and z < 254:
        f = (50 * z ** 2) ** 4 + 71 * z
    elif z >= 254:
        f = 90 * (1 + z / 39) + (z + z ** 3 + z ** 2) ** 5 / 96 + (68 - 39 * z ** 3 - z) ** 3
    return f"
"from math import *

def main(z):
    if z < 29:
        return 61 * (48 * z ** 2 + z / 52 + 1) ** 2 - z ** 4 / 50
    elif 29 <= z <= 114:
        return abs(66 * z ** 3 - 34 - 86 * z) + (z + z ** 3 + z ** 2) ** 3 + z ** 5
    elif 114 <= z <= 147:
        return 31 * z ** 4 - atan(29 * z ** 2) ** 3
    elif 147 <= z <= 183:
        return 1 + atan(22 - 64 * z ** 3 - 8 * z ** 2) + 15 * z ** 4
    elif z >= 183:
        return z ** 6"
"import math

def main(z):
    if z < -52:
        return 22 * z ** 2
    if z < 6:
        return z ** 6 + 35 + int(60 * z) ** 7
    if z < 94:
        return 99 * math.log(z) - 65 * z ** 5
    return 11 * (19 + z ** 2) ** 2"
"import math

def main(y):
    if y < -31:
        return 5 * abs(y ** 3) ** 4 + y ** 5
    elif -31 <= y < 47:
        return (1 + y + y ** 3) ** 3 + 75 + y ** 4
    elif 47 <= y < 73:
        return y ** 6 - 7 * (0.01 - y ** 2 - 41 * y) ** 5
    else:
        return y ** 15 + math.log(y) ** 2 + 98 * y ** 6"
"import math

def main(x):
    if x < 36:
        return 80 * math.log(x ** 3 - x ** 2) ** 5 - 79 * (x + x ** 2) ** 6
    elif x < 52:
        return 1 - (10 - 22 * x ** 2) ** 6 - 56 * math.tan(x) ** 4
    elif x < 90:
        return 47 - 88 * x ** 4 - 55 * math.exp(x) ** 5
    elif x < 186:
        return (x + 1 + x ** 2) ** 3
    else:
        return math.log(x) ** 3"
"def main(z):
    ans = z ** 7 - z ** 5
    if z < 30:
        ans = 23 * z
    elif 30 <= z < 59:
        ans = 26 * (67 * z ** 3 + 31 + 59 * z) ** 6 + z ** 4
    return ans"
"import math

def main(x):
    if x < 28:
        return x ** 6
    elif 28 <= x < 103:
        return math.exp(x) ** 6 + 18 * math.tan(1 - x ** 3) ** 2
    else:
        return 1 - 6120 * x ** 2 - math.tan(x) ** 4"
"import math

def main(y):
    if y < 72:
        return (y ** 3 - 58) / 43 + 72 * math.log(y, 10) ** 2
    if 72 <= y < 84:
        return (79 * y ** 3 - 75 - y) ** 2
    if 84 <= y < 137:
        return 45 * y ** 4
    if y >= 137:
        return y ** 2 - 25 * (74 * y ** 2) ** 7"
"import math

def main(z):
    if z < -8:
        rez = 18 * (z ** 2 / 60) ** 5
    elif -8 <= z < 82:
        rez = (49 * z ** 2) ** 3 - 0.1 - (math.fabs(z) ** 3 + z ** 2) / 96
    elif 82 <= z < 107:
        rez = 75 * math.exp(z) - math.sqrt(z) ** 3 - 49 * math.tan(36 * z ** 2) ** 2
    elif 107 <= z < 120:
        rez = 47 * math.fabs(z) ** 2
    elif z >= 120:
        rez = 3 * (z ** 3 / 31) ** 2
    return rez.real"
"import math

def main(z):
    if z < -40:
        return pow(z, 6) - pow(z, 2)
    if z >= -25:
        return pow(math.sin(pow(z, 2) + z / 77 + 46 * pow(z, 3)), 3) - pow(2 * pow(z, 3) - 41 * z, 7)
    return 4 * z"
"import math

def main(y):
    if y < 38:
        return 1 - math.atan(y)
    elif 38 <= y < 109:
        return (64 * y ** 2 + 54 + y ** 3) ** 7 - 9
    else:
        return 74 * (y ** 3 + 1 + y ** 2) ** 6 + 31 * (y ** 3 - 80 * y ** 2 - y) ** 4"
"import math

def main(x):
    if x < 119:
        f = abs(pow(x, 2) - 92)
    elif 119 <= x and x < 137:
        f = 25 - 11 * pow(30 * x + 27 + pow(x, 2) / 7, 3)
    elif 137 <= x and x < 206:
        f = pow(x, 3)
    elif 206 <= x and x < 267:
        f = 61 * pow(math.floor(11 * x - pow(x, 3) - pow(x, 2) / 5), 3)
    elif x >= 267:
        f = math.sin(x + pow(x, 3) + 60) + pow(73 * pow(x, 3), 6) / 55
    return f"
"import math

def main(z):
    if z < 11:
        a = math.pow(z - 1 / 9 * math.pow(z, 3), 2)
        b = 8 * math.pow(math.pow(z, 3) + math.pow(z, 2) + 0.01, 7)
        return a - b
    if (z >= 11) & (z < 110):
        c = 62 * math.pow(z, 7)
        d = math.pow(1 - math.pow(z, 2) - 42 * math.pow(z, 3), 5)
        return c - d
    if z >= 110:
        return math.pow(math.fabs(z), 4) - math.pow(z, 6) - 1"
"import math

def main(z):
    if z < 114:
        res = 94 * z ** 10
        res = res + 43 * math.atan(z + z ** 3 / 73 + z ** 2) ** 6
    elif z < 173:
        res = z ** 4 + z + 3 * (17 * z ** 2) ** 7
    elif z < 207:
        res = 37 * (51 * z ** 3 - 6) ** 5
    elif z < 239:
        res = math.atan(z) ** 5 / 37 + z / 89
    else:
        res = math.log(z, 10) ** 2 - 82 * (z ** 2 + 1 + 86 * z) ** 4
    return res"
"from math import cos

def main(x):
    if x < 34:
        ans = 1482 * 4
    elif 34 <= x < 75:
        ans = 79 * (74 * x ** 3) ** 5 + 0.01
    elif 75 <= x < 137:
        ans = x ** 4 + x
    elif 137 <= x < 229:
        ans = int(x) ** 7 + 1 + x
    else:
        ans = x ** (5 / 2) + 62 + cos(x) ** 7
    return float('{:.2e}'.format(ans))"
"import math

def main(x):
    counter = 0
    if x < 178:
        counter = 68 * (67 * x ** 2 - 72) ** 2 + x ** 4
    if 178 <= x < 228:
        counter = x ** 4 - 98 * x ** 5
    if 228 <= x < 315:
        counter = x ** 7 - x ** 2
    if x >= 315:
        counter = 25 * (42 * x ** 3) ** 6 + 21 * math.log10(x) ** 7
    return counter"
"import math

def main(z):
    result = 0
    if z < 74:
        result += math.floor(z) ** 3
    if 74 <= z < 90:
        result += (z - z ** 3) / 27 - 24 * (21 * z) ** 3
    if 90 <= z < 175:
        result += (z ** 3 + 90 + 98 * z) ** 7
    if z >= 175:
        result += 69 * (6 * z + 1) ** 4 + 0.01 + z ** 6
    return result"
"import math

def main(x):
    if x < -46:
        return 72 + 93 * x ** 21
    if x >= -46 and x < 4:
        return 24 * x ** 10 + 72 * x ** 4
    if x >= 4 and x < 46:
        return 70 + (88 + 51 * x) ** 2 + 64 * math.sin(1 + 34 * x) ** 3
    if x >= 46 and x < 60:
        return 74 * (x ** 2 / 39 + 1) ** 7 - 28 - 18 * x ** 4
    if x >= 60:
        return x ** 4 - math.log10(x) ** 6 / 34"
"def main(z):
    if z < 39:
        return 90 * z ** 5 - z ** 3
    a1 = (z + z ** 3 + 1) ** 4
    a2 = -29 - 89 * (1 - 54 * z ** 3 - z ** 2) ** 5
    if 39 <= z < 83:
        return abs(a1) + a2
    if 83 <= z < 121:
        return (z ** 2 + z) ** 3
    if 121 <= z < 213:
        return z ** 6
    if z >= 213:
        return 47 * (z ** 3 / 91 + 44 + z) ** 7 + 1 + 75 * z ** 2"
"import math

def main(z):
    if z < 50:
        return z ** 6
    elif z >= 50 and z < 107:
        return 76 * z ** 3 - 1 + z ** 6 + 80 * math.exp(1 - 43 * z) ** 5
    elif z >= 107 and z < 185:
        return 23 * z
    elif z >= 185 and z < 204:
        return math.log(z ** 2 + 1 + 70 * z, 2) ** 5
    else:
        a = (z - z ** 3 - 86) ** 2 - 3 * math.atan(z) ** 6
        return (z ** 2 / 92) ** 5 / 70 - a"
"from math import log10

def main(z):
    if z < -12:
        res = 41 * z ** 3 + 0.1 + z ** 2 / 7
    elif z >= -12 and z < 77:
        res = log10(64 * z ** 2 + 95 + z) ** 3 + z ** 7
    else:
        res = 63 * (82 * z ** 2 + 59 * z + z ** 3 / 36) ** 4
    return res"
"import math

def main(z):
    if z < 32:
        return 41 * z ** 7 - z ** 6 - abs(z) ** 3
    if z >= 122:
        return math.exp(z) - 65 * math.atan(z) ** 3
    return 43 - 71 * (1 - z ** 2 - 9 * z ** 3) ** 2"
"import math

def main(y):
    if y < 70:
        return y ** 7 - 11 * math.exp(y) ** 3 - 1
    if 70 <= y < 111:
        return 61 * (y ** 3 + 1 + y ** 2) - math.tan(y) ** 2 / 88
    if 111 <= y < 175:
        return math.atan(82 * y ** 2 - y ** 3) - (76 * y ** 3) ** 7
    if 175 <= y < 223:
        return y ** 7 / 81
    if y >= 223:
        return math.cos(67 * y ** 3) + 32 * (40 * y ** 3 - y - y ** 2 / 70) ** 2 + y ** 4 / 16"
"import math

def main(z):
    if z < 112:
        return 39 * math.log(z ** 2 + 1 + 81 * z, 10) ** 6
    elif z < 195:
        return z ** 3 - (1 + 10 * z ** 3) ** 7
    else:
        return z ** 6"
"def main(x):
    if x < 8:
        result = 44 * (88 * x ** 3) ** 5
    elif x >= 8 and x < 29:
        result = 38 + 87 * x ** 2
    else:
        result = 52 * (x / 62 + 1) ** 7 + 1
    return result"
"import math as m

def main(z):
    if z < 49:
        s1 = 38 * m.sin(z ** 2 / 7 - 92 * z ** 3 - z) ** 2
        s2 = 22 * (z ** 2 + 83 * z + 50 * z ** 3) ** 6
        s3 = (77 * z ** 2 - 95 * z ** 3) ** 5
        return s1 + s2 + s3
    elif z >= 49 and z < 107:
        return z ** 5 - (86 * z ** 3 + z ** 2) / 90
    elif z >= 107 and z < 165:
        return z ** 7 / 61 - 1
    elif z >= 165 and z < 210:
        return (9 * z ** 2) ** 6 / 55 + z ** 3
    elif z >= 210:
        return 1 + (4 * z ** 2) ** 5 + z ** 3"
"def main(x):
    if x < 51:
        return 1 + x ** 5
    if 51 <= x < 73:
        return x ** 3 + 1 + 31 * x ** 5
    if 73 <= x < 133:
        return x ** 3
    if 133 <= x < 173:
        return 1 + x ** 4 / 47
    return 54 - 70 * (x ** 2 + 78 * x + x ** 3) ** 5"
"import math

def main(y):
    if y < 76:
        return math.tan(y) ** 2 / 69
    elif 76 <= y < 101:
        return 96 * y ** 6 - y ** 21 / 72 - 2
    elif 101 <= y < 177:
        return (71 - y ** 2 - 29 * y ** 3) ** 4
    elif 177 <= y < 252:
        return math.log(39 * y + 83 * y ** 3 + 1, 10) ** 2
    elif y >= 252:
        return y ** 2 / 25"
"import math

def main(x):
    if x < 143:
        return x ** 2
    if 143 <= x < 231:
        return 22 * (x + 55 * x ** 3) ** 4
    if 231 <= x < 326:
        return 68 * (x ** 2 / 57 + 1 + x) ** 7 - 69 * (43 + x ** 3 + x ** 2) ** 5 - 76 * abs(95 - x ** 2 - x) ** 3
    if 326 <= x < 342:
        return 67 * cos(73 * x + x ** 3 + 26) ** 3 - 84 - 75 * (27 * x ** 2) ** 4
    if x >= 342:
        return x ** 6 - abs(x) / 7"
"import math

def main(z):
    if z < 57:
        return z ** 4 / 95
    elif 57 <= z < 106:
        return z ** 7 - z ** 4 - 37 * (56 - z ** 2)
    elif 106 <= z < 183:
        return 46 * z ** 7 - 60 * (z ** 3 - z ** 2 - 1) ** 2
    else:
        term1 = math.tan(z - 1) ** 7 / 86
        term3 = 41 * (25 - z ** 3 - 92 * z) ** 6
        return term1 - z ** 3 - term3"
"import math

def main(y):
    if y < 94:
        first = y - y ** 2 - y ** 3 / 30
        second = -6 * abs(y) ** 2
        third = -24 * (45 - y ** 2 / 46 - 59 * y ** 3) ** 6
        return first + second + third
    if 94 <= y < 109:
        return 40 * (y ** 3 / 5) ** 6
    if 109 <= y < 181:
        return math.atan(y) ** 4
    return y + (52 * y ** 2 + 1) ** 4"
"def main(x):
    if x < 50:
        return x ** 2 + 6 * x ** 4
    elif 50 <= x < 97:
        return x ** 7
    elif 97 <= x < 115:
        return 94 * x ** 2
    elif x >= 115:
        return 4 - (x ** 2 + 16 * x ** 3) ** 7 - x ** 6 / 2 - x ** 6 / 2"
"import math
from math import cos

def main(y):
    if y < 43:
        ans = cos(y) ** 3 + (28 * y ** 2 + 98 * y + y ** 3) ** 2
    elif 43 <= y < 119:
        ans = y ** 4
    elif 119 <= y < 138:
        ans = 85 * y ** 4 - (17 * y ** 3) ** 2 - 1
    elif 138 <= y < 216:
        ans = 74 * y ** 2 - 14 * y ** 6 - math.log(y) ** 7
    else:
        ans = 1 - 76 * int(y ** 3 + y ** 2) ** 7
    return float('{:.2e}'.format(ans))"
"import math
from math import cos

def main(y):
    if y < 43:
        ans = cos(y) ** 3 + (28 * y ** 2 + 98 * y + y ** 3) ** 2
    elif 43 <= y < 119:
        ans = y ** 4
    elif 119 <= y < 138:
        ans = 85 * y ** 4 - (17 * y ** 3) ** 2 - 1
    elif 138 <= y < 216:
        ans = 74 * y ** 2 - 14 * y ** 6 - math.log(y) ** 7
    else:
        ans = 1 - 76 * int(y ** 3 + y ** 2) ** 7
    return float('{:.2e}'.format(ans))"
"import math
from math import *

def main(z):
    if z < 186:
        return pow(68 * z ** 2 - 1, 3)
    elif 186 <= z < 214:
        return 79 * z ** 3 + z ** 4 + pow(z + 50 * z ** 3 + z ** 2, 7)
    else:
        return 59 * pow(z ** 2 - 0.01, 3)
main(107)"
"import math

def main(y):
    if y < 65:
        f = pow(y, 5)
    elif 65 <= y and y < 143:
        f = y / 14 + 5 * pow(math.cos(72 * pow(y, 2) + 31 * y), 7) + 7
    elif y >= 143:
        f = pow(math.sin(y), 2)
    return f"
"from math import *

def main(x):
    if x < 99:
        return pow(log(x * x + 16 + x * x * x), 6) + 74 * pow(x // 1, 4) + x * x / 37
    elif x >= 99 and x < 148:
        return 76 * pow(log2(x - 1), 7) - 37 * pow(cos(x), 2) - 43
    elif x >= 148:
        return pow(x, 6)"
"import math

def main(z):
    if z < 106:
        a = z ** 4
        return a
    elif 106 <= z < 120:
        a = 97 * z * z + 98 * z + z ** 3 + 1
        return a
    elif 120 <= z < 213:
        a = 98 * z ** 3
        return a
    else:
        a = 86 * math.atan(z) + 57 * z ** 4
        return a"
"import math

def main(x):
    if x < 166:
        f = 45 * (x ** 3 / 79 + 15 * x ** 2 + 1)
    if 166 <= x < 243:
        f = x / 59
    if 243 <= x < 320:
        f = x ** 2
    if 320 <= x < 335:
        f = (x ** 3 + 96) / 28 + 77 * x ** 6
    if x >= 335:
        f = 1 - math.cos(23 * x - x ** 2 - 37) ** 6 - math.cos(x) ** 2 / 67
    return f"
"import math

def main(z):
    if z < 22:
        a = 21 * abs(z) ** 3 + math.atan(z)
    elif 22 <= z < 120:
        a = 51 * z * z
    elif 120 <= z < 214:
        a = 79 * z
    elif 214 <= z < 258:
        a = 3 * (25 * z ** 3 + z * z) - 26 * (22 * z * z + 33 * z ** 3) ** 7 - 16 * z ** 4
    elif z >= 258:
        a = 67 * (1 + z + 47 * z ** 3) ** 3 - 51 * (z / 60 + z * z) ** 5 - z ** 6
    return a
main(287)
main(52)"
"import math

def main(z):
    if z < 17:
        return z ** 6
    elif 17 <= z < 57:
        return z ** 7
    elif 57 <= z < 109:
        return z * 78
    elif 109 <= z < 133:
        return z ** 2 - 1 - 23 * (5 + z + z ** 2) ** 3
    else:
        return 32 * z ** 4 + (z + 99) ** 5 / 95 + 26 * math.cos(z) ** 3"
"import math

def main(y):
    if y < 92:
        fi = 78 * math.log2(y + 66)
        se = 50 * math.tan(3 * y ** 3 - 1) ** 5
        f = fi - se - y ** 2 / 39
        return f
    if 92 <= y < 126:
        f = (1 + 68 * y + 15 * y ** 2) ** 3
        return f
    if 126 <= y < 211:
        f = y ** 6 + 99 * math.log10(y) ** 7
        return f
    if 211 <= y < 304:
        f = 28 * y ** 7 + y ** 3 + 5
        return f
    if y >= 304:
        fi = math.atan(59 * y) ** 4
        se = 90 * (1 + 47 * y ** 2) ** 2
        f = fi + se
        return f"
"import math

def main(y):
    if y < 10:
        return 21 * y ** 2
    elif 10 <= y < 84:
        return (y ** 0.5) ** 3 + math.log(y ** 3 + 1, 2) ** 5 + 0.01
    elif y >= 84:
        return math.log(y, 2) + y ** 5 + 1"
"import math

def main(x):
    if x < 43:
        return (32 * x ** 2 - 74 * x ** 3) ** 6 + 57 * x
    elif 43 <= x < 142:
        return 1 + 69 * math.tan(83 + 3 * x ** 3 + 57 * x ** 2) ** 5
    elif 142 <= x:
        return 43 * abs(x) ** 6 - 77 * math.log(62 * x - 74)"
"import math

def main(y):
    if y < 86:
        a = 1 + (29 * y ** 3 + 53 * y) ** 7
        return a
    elif 86 <= y < 116:
        a = math.sin(14 * y ** 3 - 36 * y ** 2 - 44) ** 2 / 74
        return a
    else:
        a = 28 * y
        return a"
"def main(y):
    if y < 183:
        return y ** 4
    elif 183 <= y < 249:
        return 98 * y ** 3 + 1 + 7 * y ** 6
    else:
        return 4455 * y ** 3 + 54 * y ** 4"
"import math

def main(z):
    res = 0.0
    if z < 62:
        res = math.pow(z, 6)
    elif z < 142:
        res = 79 * math.pow(z, 2) + 73 * math.pow(z, 6) + z
    else:
        res_t = 1 - math.pow(z, 2) - 7 * math.pow(z, 3)
        res = math.pow(res_t, 6) / 54 - math.pow(z, 4)
    return float('{:.2e}'.format(res))"
"import math

def main(z):
    if z < 41:
        r = z / 5 + pow(z, 4)
    elif 41 <= z < 90:
        r = 1 - pow(math.exp(z), 2)
    elif 90 <= z < 110:
        r = z + pow(z, 3) + 1
    else:
        r = 58 * pow(math.exp(z), 2)
    return r"
"import math as m

def main(x):
    if x < 121:
        return 45 * (22 * x ** 3 + 32 + x) ** 4 - (44 * x ** 2) ** 3
    if 121 <= x < 155:
        return m.sin(x) ** 5 - (74 * x - x ** 3 - x ** 2) ** 6 - x ** 4 / 36
    if 155 <= x < 255:
        return (1 + 14 * x ** 2) ** 5
    if 255 <= x < 353:
        return x - 24 * m.fabs(x) ** 6
    if x >= 353:
        return 1 + x ** 5 + m.ceil(62 * x + x ** 2) ** 2"
"from cmath import exp

def main(z):
    if z < -81:
        return z ** 4
    elif z < 7:
        return 76 * (69 * z ** 2) ** 5 + 1
    elif z < 25:
        return 64 - z ** 6
    else:
        return z ** 4"
"import math

def main(x):
    if x < 37:
        return 80 * x ** 6
    elif 37 <= x and x < 59:
        return 72 * x ** 4 + math.cos(x) + x ** 6
    elif 59 <= x and x < 78:
        return 63 * math.atan(x) ** 2 + x ** 6 + 5 * x ** 3
    elif 78 <= x and x < 165:
        return math.log(x ** 3 + x, 10) ** 6
    elif x >= 165:
        return x ** 3"
"from math import ceil, log1p, atan, tan

def main(y):
    if y < 62:
        return 92 * ceil(y) ** 5
    elif y >= 62 and y < 116:
        return 95 * y - 20 * y ** 7
    elif y >= 116 and y < 203:
        return 30 * (10 * y - y ** 2) ** 7 - 36 - (y / 26 + 1) ** 3
    elif y >= 203 and y < 303:
        return 25 + 39 * log1p(y) ** 7 + 60 * (y ** 3 - y ** 2 - 1) ** 3
    else:
        return 90 * atan(14 - 68 * y ** 3 - y) ** 4 + y ** 3 - 11 * y + 10 * tan(y) ** 2"
"from math import *

def main(z):
    if z < 30:
        return 24 * (z ** 2 + z + 1) ** 2
    elif 30 <= z < 130:
        return 23 * cos(z) + (13 + 69 * z ** 3 + z ** 2) ** 2 + 62 * z ** 6
    elif 129 <= z < 180:
        return z ** 2 - log10(z) ** 7 / 68
    else:
        return 97 * (z ** 3 / 9 + z ** 2 + 25) ** 4 + log2(z) ** 7 + 1"
"import math

def main(x):
    counter = 0
    if x < 157:
        counter = abs(x) ** 5 + math.log(x, 2) ** 3 + x
    if 157 <= x < 257:
        counter = 1 + abs(60 * x) ** 2
    if 257 <= x < 289:
        counter = x ** 7
    if 289 <= x < 310:
        counter = 41 * math.sin(x) ** 4 - x ** 7 / 53
    if x >= 310:
        counter = 79 * x ** 6 + 29 * x + math.cos(x) ** 4
    return counter"
"def main(y):
    return f(y)

def f(y):
    if y < -5:
        return first_case(y)
    elif -5 <= y < 93:
        return second_case(y)
    else:
        return third_case(y)

def first_case(y):
    return round(y) ** 3 + 76 * y ** 2 / 60

def second_case(y):
    return 23 * round(y ** 2) ** 7 + y ** 4

def third_case(y):
    return y ** 3 - 36"
"import math

def main(z):
    result = 0
    if z < -71:
        result = 98 * math.pow(0.03 - z - z ** 3, 2) + 0.02
    elif -71 <= z < 20:
        result = 19 * z ** 2 - math.pow(math.sin(z + z ** 2 / 32 + 39 * z ** 3), 5) / 66 - 7 * math.pow(math.atan(59 * z ** 2), 6)
    elif 20 <= z < 106:
        result = 1 + 91 * math.cos(z)
    elif 106 <= z < 190:
        result = math.pow(z ** 3 - 19, 7) - z ** 4 - 39 * z ** 3
    else:
        result = 98 * math.pow(z ** 3 - 15, 6) - 30 * z ** 2 - 82 * math.pow(z ** 2 - z ** 3 - 0.03, 3)
    return result"
"import math

def main(x):
    if x < 5:
        return math.pow(6 * x, 3) / 8
    elif 5 <= x < 104:
        return math.pow(6 - x - x ** 3, 6)
    elif x >= 104:
        return math.cos(x + x ** 2) / 42 - math.pow(math.tan(x), 4) - 59"
"import math

def main(z):
    if z < 34:
        ans = 3 * pow(pow(z, 3) + 1 + pow(z, 2), 5)
    elif 34 <= z < 70:
        ans = pow(z, 5) + pow(z - 1 - pow(z, 3), 6)
    elif z >= 70:
        ans = pow(z, 2) - 93 * pow(math.sin(z), 5)
    return ans
main(67)"
"import math

def main(z):
    if z < 70:
        f = 43 + z ** 3
    if z >= 70 and z < 119:
        f = 1540 * z - z ** 6 / 62 - (68 * z ** 2 - z ** 3) ** 4 / 28
    if z < 147 and z >= 119:
        f = 50 * (z - z ** 2) ** 3
    if z >= 147:
        f = 93 * math.sin(z) ** 2 - 1 - 13 * z ** 5
    return f
main(56)"
"def main(z):
    if z < 49:
        f = 75 * (1 - 74 * z) + 75 * z ** 4
        return f
    if 49 <= z and z < 83:
        f = (65 * z - 47) ** 2
        return f
    if z >= 83:
        f = 99 * z + (z ** 2 / 32 - 9 * z - 20 * z ** 3) ** 4 / 47
        return f"
"import math

def main(x):
    if x < 121:
        ans = 1 + 47 * math.cos(1 + x / 12 + 37 * x ** 3) ** 4 + 93 * x ** 5
    elif x >= 200:
        ans = math.cos(96 * x ** 3) ** 5 / 89
    else:
        ans = 92 * (x / 25 - x ** 2 - 93) ** 2 + 88 * math.tan(x) ** 5 + 68 * (6 * x ** 3 + 19 + x) ** 4
    return ans
main(179)"
"from math import exp

def f1(y):
    return 81 * (y ** 3 / 29 + y * y) ** 7 + (y ** 3 / 78) ** 4 + 40 * y

def f2(y):
    return (64 * y ** 2) ** 5 - 38 * (65 * y ** 2 + y + 96 * y ** 3) ** 4

def f3(y):
    return 89 * exp(y) ** 2 - 72 * y ** 5

def f4(y):
    return 22 * (1 - y - 44 * y ** 3) ** 6 - (y ** 3 + 71 * y + 86) ** 5

def main(y):
    if y < 26:
        return f1(y)
    elif 26 <= y < 123:
        return f2(y)
    elif 123 <= y < 141:
        return f3(y)
    return f4(y)"
"import math

def main(y):
    if y < -88:
        return math.log(y ** 2, 2) ** 3 - 76 * y
    elif -88 <= y < -11:
        return math.ceil(y) ** 3 - y ** 4
    elif y >= -11:
        return (49 * y ** 3 - y ** 2 - 39) ** 4 + 3 * y ** 3 + 51"
"import math

def main(x):
    if x < 93:
        return 41 * pow(pow(x, 2) + 48 * x + 1, 3) - pow(pow(x, 3) / 68, 2)
    if 94 <= x < 177:
        return pow(pow(x, 3) - 68 * x - 14, 6) - pow(x, 8)
    if x >= 177:
        return pow(math.log2(x), 2)"
"from math import log, tan

def main(y):
    if y < 177:
        return 56 * (98 + 95 * y ** 3 + y / 51) ** 4 - 77 * (84 * y) ** 7 - 1
    elif 177 <= y < 189:
        return y ** 2
    elif 189 <= y < 224:
        return 50 + y / 28 + y ** 2 / 28 + 9 * log(y ** 2 + y ** 3) ** 2
    elif 224 <= y < 312:
        return 30 * (15 * y + 36 * y ** 2 + 1) ** 4
    else:
        return 27 * (80 * y ** 3 - y ** 2 - 1) ** 3 + tan(y)"
"def main(x):
    if x < -14:
        return x
    elif -14 <= x < 65:
        return (35 * x) ** 7
    elif 65 <= x < 119:
        return (75 - 20 * x * x) ** 5 / 27 + 75 * x ** 3 + 48 * (x * x)
    elif x >= 119:
        return 98 * x ** 7 - 3 * x * x"
"import math

def main(x):
    if x < 76:
        return 0.05 + math.log10(x) ** 2
    elif 76 <= x < 94:
        return 69 * x ** 3 - abs(x) ** 7
    elif 94 <= x < 123:
        return (31 * x ** 2 - 85 * x) ** 6 + 0.04 + 56 * math.tan(x ** 2 - x ** 3)
    elif 123 <= x < 219:
        return 78 * x ** 7
    elif x >= 219:
        return x ** 6 + 1"
"import math

def main(y):
    if y < -65:
        y = 84 * math.fabs(y) ** 3 - 24 - y ** 4
        return y
    if -65 <= y < -18:
        y = (y - 35 * y ** 3 - 33) ** 3 / 4 + (y + 57 * y ** 3 + 27 * y ** 2) ** 4
        return y
    if -18 <= y < 57:
        y = 73 * y
        return y
    if y >= 57:
        y = 11 * (y - y ** 2 / 28) ** 5 - 27 * (10 * y + 1 + y ** 3) ** 7 - 61 * (1 - 66 * y ** 3 - y)
        return y"
"from math import *

def main(z):
    z = int(z)
    if z < 166:
        return 42 * z ** 3
    elif z < 252:
        return 14 * z ** 5
    else:
        var1 = 91 * pow(36 * z ** 3 + 63 * z + 76, 5)
        var2 = pow(47 * z ** 2 - z / 44, 2)
        var3 = pow(z + 89 + z ** 2, 6) / 14
        return var1 + var2 + var3"
"from math import sin

def main(y):
    if y < -8:
        return (y + y ** 3 + 28 * y ** 2) ** 4 + 1 + (1 - y ** 2 - 24 * y ** 3) ** 3 / 14
    elif y >= -8 and y < 62:
        return 51 - (50 * y ** 2 + y ** 3 + y)
    else:
        return y ** 5 - sin(y ** 2)"
"from math import *

def f_1(x):
    result = x ** 5 - x ** 9 / 5
    return result

def f_2(x):
    return 1 - x

def f_3(x):
    result = 43 * pow(x + 80 * pow(x, 2) + pow(x, 3), 4)
    result += 45 * pow(pow(x, 3) / 64 + pow(x, 2) + 1, 6)
    return result + 3 * x

def f_4(x):
    result = 70 * pow(pow(x, 2) - 1 - pow(x, 3), 2)
    result += pow(tan(x), 5) / 68
    result += 67 * pow(sqrt(0.02 + x), 7)
    return result

def main(x):
    if x < 49:
        return f_1(x)
    elif 49 <= x < 128:
        return f_2(x)
    elif 128 <= x < 183:
        return f_3(x)
    else:
        return f_4(x)"
"import math

def main(y):
    if y < 17:
        res = (y - y ** 3) ** 4 + 6 * y ** 5
    elif y < 66:
        res = y ** 7
    elif y < 156:
        res = 27 * math.sqrt(y ** 2) ** 3 - 73 * y ** 7 - math.cos(y) ** 2
    else:
        res = y ** 5 + 79 * (y ** 2 - 94) ** 7
    return res"
"def main(y):
    if y < -11:
        f = y ** 6
    elif y >= -11 and y < 77:
        f = y
    elif y >= 77 and y < 87:
        f = 34 * y ** 7 - y ** 2
    else:
        f = 42 * y ** 2
    return f"
"import math

def main(z):
    if z < 25:
        return 35 * z ** 4 - 1 - 22 * z ** 3
    elif z >= 25 and z < 46:
        return 88 * z ** 6 + 10 * math.log2(z) ** 5 + 33 * (93 * z ** 2 + z + 89) ** 3
    elif z >= 46 and z < 130:
        return (z ** 2 - z ** 3 / 83) ** 4 - 88 * (z ** 3 - 79 * z ** 2 - z / 32) ** 5
    elif z >= 130 and z < 206:
        return 47 * z ** 3 + math.log10(z) + 6 * (55 * z ** 2 - 1) ** 6
    else:
        z ** 3 - 46 * (46 + z) ** 5 - 60"
"import math

def main(x):
    func = 0
    if x < 100:
        func = math.log(10, x) ** 5 / 63 - (x ** 2 / 98) ** 3 / 97
    elif x >= 100 and x < 119:
        func = 2 * x ** 6 + 15 * x ** 2 - x - 1 + 60 * (91 * x) ** 3
    else:
        func = 55 * math.fabs(46 * x ** 3 - x ** 2 - 1) ** 6 + math.atan(x) ** 5 + 95 * math.log(10, x / 5 - 1)
    return func"
"import math as m

def main(x):
    res = 0
    if x < 40:
        res = 14 * (13 * x ** 3) ** 3
    elif 40 <= x <= 98:
        res = 83 * x ** 6 - 86 * (0.01 + 71 * x ** 2) ** 7
    elif x >= 98:
        res = m.sin(x ** 3) ** 3 + 27 * m.sqrt(x) ** 6 + 61 * m.sin(1 + x + 3 * x ** 3) ** 5
    return res"
"import math

def main(x):
    if x < 144:
        f = x ** 3 - (x ** 3 + 45) ** 6 / 35
    elif 144 <= x < 163:
        f = x ** 6 - 1
    else:
        f = 93 * x ** 6
    return f"
"from math import *

def main(z):
    if z < 114:
        return 49 * (z ** 2 + 0.01 + 23 * z ** 3) ** 4 + ceil(z) ** 2 + (81 * z ** 3) ** 5
    elif 114 <= z < 202:
        return 97 * z ** 15 - sqrt(z) ** 7 / 46
    elif 202 <= z < 284:
        return z ** 2 / 84 + sin(z) ** 6
    elif z >= 284:
        return 22 * z ** 3"
"import math

def main(z):
    if z < -71:
        f = 69 * z + (0.03 + z ** 3 + 8 * z) ** 5
    elif z >= -71 and z < -39:
        f = 82 * (16 + z ** 2) ** 5 - (z - 1) ** 2 / 53 - (21 * z ** 2 + 1) ** 3 / 60
    elif z >= -39 and z < -21:
        f = math.ceil(z + 33 * z ** 3) ** 6
    elif z >= -21:
        f = 40 * (z ** 3 / 63 + 44 * z ** 2 + 50 * z) + z ** 2 + z ** 5
    return f"
"from math import *

def main(x):
    if x < 29:
        f = 32 * ceil(1 - 91 * x ** 3) ** 6 - 18 * (98 * x ** 2) ** 3 - 48 * (1 + x + 10 * x ** 2) ** 7
    elif x >= 29 and x <= 97:
        f = 34 * x + 0.02 + (x ** 3 - 73) ** 5
    elif x >= 97:
        f = 95 * (24 * x ** 2 + 54 * x + 27 * x ** 3) ** 7 + (20 * x) ** 2 / 45
    return f"
"import math

def main(y):
    if y < 21:
        f = math.log10(y * y) ** 7
    if 21 <= y < 82:
        f = math.cos(95 * y * y) + (32 * y ** 3) ** 5 / 27 + math.log10(y) ** 2
    if 82 <= y < 172:
        f = (89 * y ** 3) ** 4 / 52 + math.cos(y) ** 6
    if y >= 172:
        f = y ** 4
    return f"
"import math

def main(x):
    if x < -2:
        return 55 - 92 * x ** 4
    elif x < 39:
        return 5 * math.exp(x) ** 7 - math.tan(x) ** 2
    elif x < 115:
        return 77 * (x ** 2 / 98) ** 2
    elif x < 201:
        return 1 + (46 * x) ** 7 / 51
    else:
        return math.tan(x) ** 5 + 73 * math.tan(x / 82) + 22 * (x ** 3 + x + x ** 2) ** 7"
"from math import *

def main(x):
    if x < 100:
        func = 74 * x ** 3 + 45 * x ** 2 - exp(x ** 2 - x ** 3 - 3) ** 6 / 51
    elif 100 <= x and x < 156:
        func = x ** 2 + floor(x ** 6)
    elif 156 <= x and x < 255:
        func = 1 - x ** 4 / 33 - 80 * pow(tan(x), 3)
    elif x >= 255:
        func = 5 * pow(atan(x), 4)
    return func"
"from math import *

def f(y):
    t1 = 0
    if y < 10:
        t1 = pow(y, 4) - y / 50
    if 10 <= y and y < 80:
        t1 = pow(log(y, 10), 3) / 3
    if 80 <= y and y < 173:
        t1 = pow(y, 4) / 98 + pow(log(y, 10), 3) + 5 * sin(y)
    if 173 <= y and y < 208:
        t1 = 76 * pow(cos(55 * y + 8 * pow(y, 3) + 5), 5)
    if y >= 208:
        t1 = pow(log(y, 10), 2) + 29 * pow(y, 3) + 46 * pow(abs(18 + y + pow(y, 3)), 7)
    return t1

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

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

def f(z):
    if z < 108:
        return 48 * math.tan(93 * z) ** 2 - 85 * z ** 5 - (1 - z ** 2) ** 6
    elif z >= 108 and z <= 157:
        return 93 * (45 * z ** 3 + 84 + 35 * z ** 2) ** 7 - z ** 3
    elif z >= 157:
        return (41 * z ** 2 + 98 * z ** 3) ** 6 + z ** 3 + 52 * math.fabs(z) ** 5

def main(z):
    return f(z)"
"def main(y):
    if y < 125:
        return 4 * y ** 2 - y ** 5 - 82
    elif y < 195:
        return 66 * y ** 5 + 65 * y ** 4
    elif y < 280:
        return 28 * y - y ** 21 / 35 - 46 * (y ** 3 / 62 - 40 - 40 * y) ** 6
    elif y < 379:
        return 0.02 + (y ** 2 - 13 * y ** 3 - y) ** 7 / 5
    return 1 + abs(y) / 37 + 12 * abs(y ** 2 + 89) ** 5"
"def main(y):
    if y < 125:
        return 4 * y ** 2 - y ** 5 - 82
    elif y < 195:
        return 66 * y ** 5 + 65 * y ** 4
    elif y < 280:
        return 28 * y - y ** 21 / 35 - 46 * (y ** 3 / 62 - 40 - 40 * y) ** 6
    elif y < 379:
        return 0.02 + (y ** 2 - 13 * y ** 3 - y) ** 7 / 5
    return 1 + abs(y) / 37 + 12 * abs(y ** 2 + 89) ** 5"
"import math

def main(x):
    if x < -27:
        return 33 * x - math.exp(6) * (x ** 3 + 45 * x + x ** 2) / 4 - (84 * x ** 2) ** 7
    elif x >= -27 and x < 55:
        return math.sqrt(x) / 28
    elif x >= 55:
        return x ** 3 - x ** 2"
"import math

def main(z):
    if z < 0:
        f = z ** 10 - 65 * (z ** 3 + z ** 2 + 1) ** 3 - 60
    elif 0 <= z < 37:
        f = 69 * math.exp(z) ** 2 - 73 * (73 - z ** 2 - z ** 3) ** 6
    elif 37 <= z < 114:
        f = (67 * z ** 3) ** 3 / 19 + z ** 5 + (77 * z ** 3) ** 2
    elif z >= 114:
        f = z ** 5 - 29 * math.cos(z) ** 7 - 10
    return f"
"import math

def main(x):
    if x < 50:
        return math.pow(math.pow(x, 2) + x + 1, 4) - 97 * math.pow(math.sin(1 - math.pow(x, 3) - x / 79), 6) - 15 * math.pow(99 * math.pow(x, 2) + 17, 3)
    elif 50 <= x < 102:
        return math.pow(x, 4) / 34
    elif 102 <= x < 141:
        return 28 * x - math.pow(94 * math.pow(x, 2), 5) - 28 * math.pow(11 * math.pow(x, 3), 7)
    elif x >= 141:
        return math.pow(math.atan(75 * math.pow(x, 2) + 61 + 81 * math.pow(x, 3)), 7) + math.sqrt(math.pow(x, 3) + 6 * x + math.pow(x, 2)) + math.pow(x, 6)
main(45)"
"import math

def main(y):
    if y < 20:
        return y / 76 - 94 - 68 * math.sin(y) ** 2
    elif 20 <= y < 50:
        return 1 + y ** 6 + y ** 7
    elif 50 <= y < 62:
        return 87 * (85 * y + y ** 2 / 57 + 1) ** 6 + 8 * (5 * y ** 2 + 16 * y) ** 2
    elif 62 <= y < 159:
        return 98 * y ** 2 + (y ** 3 - y ** 2) ** 4 + y ** 3 - y / 91 - 1
    elif y >= 159:
        return y ** 6"
"import math
from decimal import Decimal

def main(x):
    if x < -37:
        s1 = math.tan(1 + x ** 3 + 71 * x) ** 5
        s2 = (x - 1) ** 4
        f = s1 + s2
        return f
    elif x >= -37 and x < 61:
        s1 = 20 * (94 + x) ** 5
        s2 = (6 - x ** 3 - x ** 2) ** 4
        f = s1 + s2
        return f
    else:
        s1 = (x - x ** 3 / 87 - 66) ** 6
        s2 = -(2 * math.tan(97 - x ** 2) ** 2)
        f = s1 + s2
        return f"
"import math

def main(y):
    if y < 131:
        return 1 + math.pow(math.tan(y), 2) + 29 * math.pow(y, 12)
    elif 131 <= y < 208:
        return 43 * math.pow(42 * y * y - 1, 2)
    else:
        return math.pow(math.tan(y), 6) - 61 * y * y * y - 1"
"import math

def main(x):
    if x < 89:
        return 15 * math.pow(x, 6)
    elif 89 <= x < 145:
        return math.pow(x, 3) + 49 * math.pow(x, 3) + 1
    elif x >= 145:
        return math.pow(x, 2) - 7 * x"
"import math

def main(y):
    y11 = math.pow(math.pow(y, 3) - y, 5)
    y12 = math.pow(math.atan(1 - 53 * y), 3)
    y21 = math.pow(18 * y, 4)
    y22 = 40 * math.pow(y, 3)
    y31 = math.pow(y, 6)
    y32 = 12 * y + 8 * math.pow(y, 3)
    y33 = math.pow(math.atan(y32), 5)
    y4 = math.pow(y, 3)
    y5 = math.pow(math.log10(math.pow(y, 3)), 6)
    if y < 67:
        return y11 - y12
    elif 67 <= y < 122:
        return y21 - y22 - 7 * y
    elif 122 <= y < 138:
        return y31 + math.pow(math.atan(y32), 5)
    elif y >= 138:
        return 65 * y5
    else:
        return 1"
"import math

def main(y):
    if y < 124:
        return 69 * pow(math.log10(y * y + 1), 6) + 94 * y
    elif 124 <= y < 176:
        return 37 * y * y
    elif 176 <= y < 265:
        return pow(math.log(y, 2), 5) / 71 + 1 + 33 * y * y
    else:
        return 62 * pow(y, 4) - 75 * pow(abs(y), 6) - 34"
"import math

def main(y):
    y1 = math.pow(19 - math.pow(y, 2) / 2, 5)
    y2 = math.pow(math.ceil(y), 6)
    y3 = 65 * (math.pow(y, 2) - math.pow(y, 3) - 41 * y)
    y4 = math.pow(math.exp(y3), 5)
    y5 = math.pow(math.pow(y, 3) - 48 * y - 1, 2)
    y6 = math.pow(36 * (math.pow(y, 3) + 38), 6) / 83
    y7 = 15 * math.pow(math.tan(y - 1), 4)
    y8 = math.pow(math.sin(1 + y / 49), 7)
    y9 = math.pow(y, 6) / 19
    if y < 105:
        return y1 + y2
    elif 105 <= y < 179:
        return y4 - y5 - y6
    elif 179 <= y < 204:
        return y7
    elif 204 <= y < 219:
        return y8 + 0.01 + y9
    elif y >= 219:
        return 51 + 55 * math.pow(y, 7)
    else:
        return 1"
"import math
from decimal import Decimal

def main(x):
    if x < -58:
        a = 55 * (x + 78 * x ** 3 + 47 * x ** 2) ** 6
        return x ** 3 - a - 4 * x ** 7
    elif x >= -58 and x < 42:
        return math.floor(x) ** 6 + (85 - x ** 2) ** 7
    elif x >= 42 and x < 61:
        return x + 25 * math.asin(x) ** 4 + 1
    elif x >= 61 and x < 100:
        return 30 * x ** 7
    else:
        a = (0.02 + 3 * x ** 2 + x) ** 2
        b = 71 - 87 * x - 27 * x ** 3
        return 47 * x ** 4 + a + b"
"import math
from decimal import Decimal

def main(x):
    if x < 76:
        a = (43 * x + 28 * x ** 2 + x ** 3) ** 4
        return 45 * x + 70 * x ** 5 + a
    elif x >= 76 and x < 117:
        return 67 + x ** 7
    else:
        return 69 * math.log(x ** 2 + x + 1) ** 4"
"import math

def main(y):
    if y < 152:
        return 19 + 71 * math.atan(57 * y + 1 + 14 * y ** 2) ** 7
    if y >= 152 and y < 191:
        return 65 * y ** 5 + 20
    if y >= 191:
        return 21 * math.log(36 * y ** 3 + y ** 2 / 92) ** 2"
"import math
import sys

def main(z):
    return f(int(z))

def f(y):
    if y < 148:
        return (88 * y ** 2 - 71 * y - 1) ** 6 / 76
    elif y >= 148 and y < 202:
        return math.log(y) ** 5 / 87
    elif y >= 202 and y < 253:
        return 30 * y ** 3 - y ** 5 - 98 * round(33 * y ** 3 - y ** 2 - 75) ** 7
    elif y >= 253 and y < 308:
        return 82 * math.log(y, 10) ** 7
    elif y >= 308:
        return y ** 2 + 49 * y ** 6"
"def main(x):
    if x < 38:
        return 6 - x ** 2 + x ** 7
    if 38 <= x < 101:
        return x ** 6
    if x >= 101:
        return (60 - 28 * x ** 3 - 25 * x) ** 7 - (x ** 3 / 49) ** 2"
"from math import exp, log, tan

def main(x):
    if x < 86:
        return pow(67 + 85 * pow(x, 3), 6) - pow(exp(x), 3)
    elif 86 <= x < 111:
        return x
    elif 111 <= x < 177:
        return pow(x, 7)
    elif 177 <= x < 190:
        return log(43 * pow(x, 2), 10) + pow(tan(x), 4) + pow(x, 2)
    else:
        return 76 * tan(x) - 97 * pow(x, 2) - 32 * pow(43 * x, 7)"
"import math
import sys

def main(y):
    if y < -18:
        return y ** 3 + (y ** 2 - 0.01) ** 2 + (95 * y ** 3 - 18 * y ** 2) ** 5
    elif y >= -18 and y < -8:
        return 58 * y ** 7 - math.sqrt(39 * y * y) ** 5 / 86 - math.tan(y) ** 6
    elif y >= -8 and y < 49:
        return 60 * (1 + 47 * y + 88 * y ** 3) - y ** 7
    else:
        e = sys.float_info.epsilon
        return 50 * (22 - y) ** 2 + 94 * (77 * y ** 3 - y ** 2 - y) ** 7 + math.exp(y) ** 4"
"import math

def main(z):
    if z < 115:
        return abs(z) ** 4 - 1
    if 115 <= z < 210:
        return z ** 7 + 60
    if 210 <= z < 285:
        return math.tan(z) ** 7
    if 285 <= z < 349:
        return z ** 6
    if z >= 349:
        return 45 * z ** 5 + 25 * math.cos(z) ** 7"
"import math

def main(z):
    if z < 49:
        return 70 * z * z - math.sqrt(z)
    elif z >= 49 and z < 89:
        return 1 + 20 * z ** 4 + 14 * math.log10(z) ** 5
    elif z >= 89:
        return 1 + z ** 7 + z / 92"
"import math

def main(z):
    if z < 104:
        return 2 * math.ceil(z) ** 7 + math.sin(z) ** 4 / 49
    elif z >= 192:
        return 50 - 45 * math.floor(z ** 2 + 44) ** 6
    else:
        return z ** 4"
"import math

def main(z):
    if z < 27:
        res = 18 * z ** 5 - z ** 6 / 87 - math.sqrt(88 + 3 * z) ** 7 / 53
    elif z < 88:
        res = (z ** 2 - 1) ** 5 - (62 * z ** 3) ** 2
    elif z < 177:
        res = (1 - z ** 2 - z ** 3 / 3) ** 2 - 94
    elif z >= 177:
        res = math.log(z ** 2) ** 6 - 1 - 41 * z ** 4
    return res"
"import math

def main(x):
    if x < 151:
        one = pow(x - 44, 7)
        return one
    elif 151 <= x < 217:
        two = 28 * pow(x, 4) + pow(27 * pow(x, 3) + 49 + 62 * pow(x, 2), 5)
        return two
    elif 217 <= x < 267:
        three = pow(math.log(x, 2), 4)
        return three
    elif x >= 267:
        four = pow(54 * pow(x, 2) + pow(x, 3) / 41 + 36 * x, 2)
        return four"
"import math

def main(y):
    if y < 166:
        a = 43 * y
        return a
    elif 166 <= y < 240:
        a = 14 * y ** 5
        return a
    elif 240 <= y < 277:
        a = (29 * y ** 2 + y ** 3 / 29) ** 7 + y ** 2 / 66
        return a
    elif 277 <= y < 295:
        a = y ** 2 + math.sqrt(y) ** 6 / 51 + 1
        return a
    else:
        a = 82 * y ** 5 - (28 + y ** 3) ** 4
        return a"
"import decimal
import math

def main(x):
    if x < 18:
        y = x ** 2 + math.exp(64 * x ** 3 - x - x ** 2) ** 6
        y += math.floor(x) ** 5
        return decimal.Decimal(y)
    if x >= 18 and x < 100:
        y = 53 * math.log(32 + x ** 2 + x ** 3) + 16 * x ** 3 + 1
        return decimal.Decimal(y)
    if x >= 100 and x < 149:
        y = 46 * x ** 3 - math.log(x, 2)
        return decimal.Decimal(y)
    if x >= 149 and x < 240:
        y = 43 * (28 - x ** 3) ** 2
        return decimal.Decimal(y)
    if x >= 240:
        y = 22 * math.cos(8 * x - 65 * x ** 2 - 1)
        return decimal.Decimal(y)"
"from math import atan, asin, sin

def main(y):
    if y < 94:
        return atan(72 * y ** 3) + 44 * asin(y) ** 3
    elif y < 192:
        return y ** 6 - abs(70 * y - y ** 3) ** 7
    elif y < 245:
        return y ** 6
    elif y < 320:
        return sin(y) ** 6
    else:
        return (34 * y + y ** 2) ** 6"
"import math

def main(y):
    if 128 <= y < 149:
        return (y * y / 68) ** 6 / 85
    elif 149 <= y < 205:
        return 32 * math.log(74 * y ** 3, 10) + 37 * y ** 5
    elif y < 128:
        return 66 * y ** 3 - math.ceil(y * y - 1) ** 4 - (y * y - y ** 3)
    elif y >= 205:
        return y ** 3 - (y ** 3 / 92) ** 4
    else:
        raise Exception()"
"import math

def main(z):
    if z < 82:
        a_1 = pow(math.atan(41 * pow(z, 3) + z + 1), 3)
        a_2 = pow(math.cos(z), 6) + pow(z, 5)
        return a_1 - a_2
    if z >= 82 and z < 178:
        b_1 = pow(z / 27 + z ** 2 + z ** 3, 6)
        b_2 = pow(math.log(35 * z ** 2), 7) / 5
        return b_1 - b_2
    if z >= 178 and z < 249:
        c_1 = pow(math.log(z), 6)
        c_2 = pow(z, 7) / 96
        return c_1 - c_2
    if z >= 249:
        d_1 = 31 * pow(math.log(z), 7)
        d_2 = 25 * pow(math.floor(z), 5)
        d_3 = z ** 3
        return d_1 + d_2 + d_3"
"import math

def func_1(y) -> int | float:
    return (1 - 18 * y ** 3) ** 3 - (59 * y) ** 7 - 11 * (49 + y) ** 5

def func_2(y) -> int | float:
    return y ** 10 - 1 - 84 * math.fabs(y) ** 6

def func_3(y) -> int | float:
    return 93 * (69 * y ** 3 + 1 + y / 37) ** 4 + 39 + 55 * math.floor(66 * y)

def func_4(y) -> int | float:
    return 64 + (y ** 3 / 95) ** 4 + 53 * y ** 7

def main(y) -> int | float:
    if y < 85:
        return func_1(y)
    elif 85 <= y < 139:
        return func_2(y)
    elif 139 <= y < 218:
        return func_3(y)
    return func_4(y)"
"from math import sqrt, floor, log2, log, cos

def main(y):
    if y < 53:
        return (y / 81 + 0.02) ** 5 / 91 - 16 * (y + y ** 3 + 1) ** 4 - 88 * y ** 7
    elif y < 151:
        return 13 * log2(y) ** 5 - y
    elif y < 172:
        return 55 * cos(y + 14 * y * y) ** 2
    elif y < 226:
        return log(y) ** 3 / 71 + y ** 4 + 64 * (y * y / 24 + 59) ** 5
    else:
        return 1 - 57 * y - floor(1 + 35 * y + y ** 3) ** 3"
"import math

def main(x):
    if x < 88:
        return (66 * x ** 3 - 6 * x * x) ** 4 + 12 * (69 + 72 * x ** 3) ** 6 + 24 * math.atan(x) ** 5 * x
    elif x < 100:
        return math.log10(x) ** 3 - x ** 4 / 80 - 77
    elif x < 123:
        return 3 * (35 * x * x - 40 * x ** 3 - 46) ** 7 - x / 34
    elif x < 182:
        return math.log2(50 * x) ** 4 - x
    else:
        return 37 * math.atan(x) ** 7"
"def main(x):
    if x < -44:
        return (1 + x ** 2 / 68 + x) ** 3 - 1
    elif -44 <= x < 46:
        return x
    elif 46 <= x < 58:
        return 51 * (x - x ** 3) ** 3
    elif x >= 58:
        return 85 - 30 * x ** 5"
"import math

def main(z):
    value = 0.0
    if z < 26:
        value = 55 * pow(z, 4) - 1 - 82 * pow(z, 10)
    elif 26 <= z < 85:
        value = pow(z, 2) - pow(z, 6) - 12 * pow(99 + pow(z, 3) + 67 * z, 7)
    elif 85 <= z < 164:
        value = pow(math.sqrt(z), 4) - 21 * pow(z, 5)
    elif z >= 164:
        value = pow(math.tan(z), 3) + pow(math.sin(12 * z + 24 * pow(z, 2)), 6) + pow(z, 4) / 27
    return value"
"import math

def f1(z):
    return 35 * abs(z) ** 4 + 48 * math.sin(z ** 3 / 11 + 28 * z ** 2 + z) ** 7

def f2(z):
    return 26 * (z ** 3 + z) ** 4 + z ** 7 + 83 * math.atan(34 * z ** 2 + z) ** 2

def f3(z):
    return 36 * math.log(82 * z + 1 + 4 * z ** 3) ** 3 + (93 - z ** 2 - z) ** 5 + 24 * z ** 4

def f4(z):
    return math.atan(63 * z) ** 2 - z ** 6

def main(z):
    if z < -21:
        return f1(z)
    elif z < 63:
        return f2(z)
    elif z < 151:
        return f3(z)
    else:
        return f4(z)"
"import math

def main(z):
    if z < 108:
        return 27 * math.sin(z) + (15 * z ** 2 - 1) ** 6 + 95 * (40 * z ** 2) ** 2
    if 108 <= z < 160:
        return 1 - 3 * (78 + z ** 2 + 67 * z) ** 6 - 51 * z ** 2
    if z >= 160:
        return 99 * math.tan(z) ** 4 - (99 * z ** 2) ** 3 - 1"
"import math

def main(y):
    if y < -19:
        return 42 * (16 * y ** 3 + y ** 2) ** 3 - y ** 5
    elif y in range(-19, 8):
        return y ** 18
    elif y in range(8, 45):
        return 34 * y ** 5
    elif y in range(45, 120):
        return (y + 65 * y ** 2 + 1) ** 5 + (0.02 + y ** 2) ** 3 + math.sin(y) ** 6
    else:
        return 74 * (1 - y) ** 3"
"import math

def main(x):
    if x < 83:
        result = x ** 6 - 79 * (x ** 2 + 87) ** 4
    elif x >= 83 and x < 119:
        result = 1 - x - math.sin(29 * x ** 2 + 96) ** 3
    elif x >= 119 and x < 182:
        result = x - math.log(x) ** 5 / 29
    elif x >= 182 and x < 269:
        result = 16 * x ** 4 - 22 * (x + x ** 2 + 0.01) ** 6
    elif x >= 269:
        result = 3783 * x
    return result"
"import math

def main(x):
    if x < 111:
        return 1 - x ** 4 - 65 * math.ceil(4 * x) ** 6
    elif x < 134:
        return 96 * x * x + 47 * math.cos(x * x + 75 * x * x * x) ** 3 + (x * x * x - x) ** 6
    elif x < 165:
        return 20 * x * x * x * x + x + 75 + 7 * x * x * x
    else:
        return (49 * x * x * x - x * x - 1) ** 6 - 24"
"import math

def main(x):
    if x < 8:
        return x ** 6 / 54
    elif 8 <= x < 37:
        return 33 * math.tan(1 + 31 * x) ** 2 + 68 * x
    elif x >= 37:
        return x ** 5
main(-43)
main(21)"
"import math

def main(x):
    if x < -2:
        one = pow(x, 6) - 84 * x - pow(x, 4)
        return one
    elif -2 <= x < 22:
        two = 89 * pow(x, 5) - 15 * pow(pow(x, 2) / 10 - 1 - x, 7) - pow(math.log10(x), 4) / 15
        return two
    elif 22 <= x:
        three = 55 * pow(x, 6) + x / 37 + pow(math.atan(pow(x, 2) + 1), 4)
        return three"
"import math

def main(z):
    if z < 47:
        return 50 * math.fabs(z) ** 4
    elif 47 <= z < 86:
        return math.ceil(z ** 2) ** 7 - 94
    elif 86 <= z < 155:
        return 72 * math.cos(z + 32 * z ** 2) ** 5
    elif 155 <= z < 206:
        f1 = math.sin(63 * z ** 2 + z ** 3 + 1) ** 4
        f2 = math.ceil(52 + z + 3 * z ** 2) ** 6 - 24 * math.log2(3 * z - 0.02) ** 7
        return f1 - f2
    elif z >= 206:
        return 41 * math.sin(z) ** 7"
"import math

def f_1(z):
    return 76 * z ** 2 / 86 + 47 * (65 * z ** 3) ** 4 + 0.17

def f_2(z):
    return 75 * z ** 3 - 72 * math.atan(z) ** 2 - z

def f_3(z):
    return 34 * z + 38 * (z ** 2 + 1) ** 7 + z ** 4

def main(z):
    if z < 73:
        return f_1(z)
    elif 73 <= z < 128:
        return f_2(z)
    else:
        return f_3(z)"
"from math import tan, sin, log

def main(z):
    if z < 170:
        return 94 * tan(95 + z ** 2 / 81 + 33 * z ** 3)
    elif 170 <= z and z < 267:
        return z ** 3 - 75 * (1 + z) ** 7 - 39 * (22 * z - 80 * z ** 2)
    elif 267 <= z and z < 309:
        return 30 * z ** 5 + 71 * z ** 4 + (z ** 3 + z ** 2 + 78 * z) ** 6
    elif 309 <= z and z < 403:
        a = (69 * z ** 2 - 63 * z ** 3) ** 5
        b = log(10, 57 * z ** 2 - 84 - z ** 3 / 13)
        c = 8 * (z ** 3 - z ** 2 / 54) ** 7
        return a - b - c
    elif z >= 403:
        return (z ** 3 - z) ** 5 + z ** 3 / 58 + sin(z) ** 7"
"import math

def f(x):
    result = 0
    if x < 34:
        result = 23 * x ** 3
    elif 34 <= x < 56:
        a = math.sin(1 + x ** 3 + x ** 2) ** 2
        b = (89 * x - x ** 3 - x ** 2) ** 3
        result = 83 - a - b
    elif 56 <= x < 145:
        result = 35 * x ** 7 + 85 * x ** 6
    else:
        result = x ** 5
    return result

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

def f(y):
    result = 0
    if y < 179:
        a = math.cos(y ** 3 + y ** 2 + 53 * y)
        b = 96 * (y ** 3 + 61 * y ** 2) ** 7
        c = (63 * y ** 2) ** 5
        result = a - b - c
    elif 179 <= y < 204:
        result = 90 * math.exp(y) ** 2 + 8
    elif 204 <= y < 251:
        result = 18 * math.sqrt(86 + y / 88)
    elif 251 <= y < 337:
        result = math.tan(y) ** 6 / 76 + (1 + y ** 2) ** 5
    else:
        result = 75 * y ** 5 - math.log10(y ** 3 - y - 80 * y ** 2)
    return result

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

def main(x):
    if x < 6:
        return 90 * x ** 7 + math.cos(x) ** 5
    elif 6 <= x < 42:
        return 42 * x ** 4
    elif x >= 42:
        return x ** 4 / 39 - x ** 3
main(96)
main(61)"
"import math

def f(x):
    result = 0
    if x < 68:
        result = math.log2(x + 6) ** 5 / 37
    elif 68 <= x < 94:
        a = (77 + 79 * x ** 2) ** 2
        result = (x ** 3 / 37) ** 6 - a
    else:
        result = x ** 5 / 81 - 1
    return result

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

def main(x):
    if x < 98:
        return (26 + x ** 2 + 23 * x) ** 6 / 78
    elif 98 <= x < 180:
        a = (x ** 3 + 1 + 76 * x) ** 7
        b = 61 * math.floor(51 - x) ** 6
        c = 48 * math.floor(x ** 2 + x + x ** 3 / 37) ** 5
        result = a + b + c
        return result
    elif 180 <= x < 257:
        return 46 * x ** 7
    elif 257 <= x < 313:
        return 11 * (19 * x ** 3 + x ** 2) ** 3
    elif x >= 313:
        return (x - x ** 3 / 19) ** 6
main(294)
main(148)"
"import math

def main(z):
    if z < 106:
        return 23 * math.floor(z) ** 3
    elif z < 134:
        return math.sin(25 * z - 19 * z ** 2)
    else:
        return 37 * (96 * z - 45 * z ** 3 - 47 * z ** 2) ** 4 + z ** 6 + math.cos(z) ** 3"
"import math

def main(z):
    if z < 32:
        return 31 * pow(z, 6)
    elif z < 109 and z >= 32:
        a = pow(z, 3) - 57 * z
        return 8 * pow(math.sin(z), 3) - 37 * pow(a, 6)
    elif z >= 109:
        return 1 + 19 * pow(z, 5) + pow(z, 4)"
"import math

def main(z):
    if z < 49:
        f = z ** 4 / 91 + 22 * math.log10(93 * z ** 2 - 1) ** 3 + 83 * z ** 2
    elif 49 <= z < 61:
        f = z ** 3 - 15 * z ** 2 - 58 - 0.02
    elif 61 <= z < 140:
        f = 89 * z ** 5
    elif 140 <= z < 215:
        f = 10 * z ** 7 + 92 * z ** 5
    else:
        f = z
    return f"
"import math

def main(y):
    if y < -7:
        f = 57 * y ** 2 - (y ** 2 - y ** 3 - y / 13) - y ** 4
    elif -7 <= y < 67:
        f = 54 * math.cos(y) - 12 * y ** 14 - 1
    elif 67 <= y < 125:
        f = 72 * math.log2(y ** 3 - y ** 2 / 45) ** 5
    elif 125 <= y < 163:
        f = 1 - 50 * y ** 8
    elif y >= 163:
        f = y ** 5
    return f"
"def main(y):
    if y < 39:
        f = 88 + (1 - y / 14) ** 7
    elif 39 <= y < 136:
        f = y ** 7 / 66
    elif 136 <= y < 162:
        f = (y ** 2 / 62 + 1 + 12 * y) ** 4 + 20
    elif y >= 162:
        f = 8 * (1 + y ** 2) ** 4 + y ** 3
    return f"
"import math

def main(x):
    if x < 1:
        s1 = 23 * (86 * x ** 2 + 22) ** 6 + x ** 4 + 61 * math.sin(x)
        return s1
    elif x >= 1 and x < 38:
        s2 = math.log10(x) ** 2
        return s2
    elif x >= 38:
        s3 = x ** 5 / 8
        return s3"
"import math

def main(y):
    if y < 26:
        return (89 - y ** 3 - 28 * y ** 2) ** 3 + 91 * y ** 4
    elif 26 <= y < 103:
        return 22 * (97 * y ** 3) ** 4 + 31 * math.cos(y ** 3 + 1)
    elif 103 <= y < 197:
        return abs(y ** 2) ** 4 - 57 * abs(y) - 95 * y ** 7
    elif y >= 197:
        return math.atan(y) ** 4 + y ** 7"
"import math

def main(x):
    if x < 151:
        return 47 * math.log(x ** 3 + 71, 2) ** 3
    elif 151 <= x < 218:
        return math.floor(63 + x + x ** 2) ** 7 / 74 + x ** 4 / 95 + 48 * x ** 6
    elif x >= 218:
        return math.sin(x) ** 3 + 64 * x ** 6"
"import math

def main(x):
    f = 0
    if x < 85:
        f1 = math.log(x ** 3 / 94 + 1 + x ** 2, 2) ** 5
        f2 = 71 * (x ** 2 - 0.02 - 39 * x) ** 2
        return f1 - f2
    elif x < 144:
        return 86 * x ** 6 - 44 - 81 * x ** 4
    elif x < 242:
        return 48 + 99 * (48 * x ** 2 + 0.01 + x) ** 7
    else:
        return 6 * x ** 3 - math.log(x, 2) - (x - 15 * x ** 3 - x ** 2) ** 2"
"import math

def main(y):
    if y < 104:
        return y ** 4 / 28 + 18 * y ** 2 + 93 * (1 - y ** 2 - y ** 3) ** 2
    elif 104 <= y < 138:
        return 20 * math.cos(48 * y + y ** 2) ** 7 - math.log(2 * y ** 3 + 97) ** 4 / 28
    else:
        return y ** 4"
"import math as math

def main(y):
    if y < -42:
        return y - pow(y, 7) - 54
    elif y < 18:
        return 97 * pow(y, 4)
    elif y < 53:
        return 57 * pow(math.atan(y - pow(y, 5)), 3) - pow(y, 5)
    else:
        return y"
"import math as math

def main(y):
    if y < 124:
        return y / 15
    elif y < 205:
        return 56 * math.log(y) + 0.01 + pow(math.atan(y), 5)
    elif y < 256:
        return 50 * pow(y, 6)
    elif y < 322:
        z = pow(y, 3) + pow(pow(y, 3) / 47, 2) / 34
        return 80 * (pow(y, 2) / 60 - pow(y, 3) - y) + z
    else:
        return 99 * pow(pow(y, 2) + 16 + pow(y, 3) // 1, 4) + y / 69"
"import math

def main(x):
    if x < 79:
        res = math.log(x, 2) ** 7 - 1
    if x >= 79 and x < 123:
        res = 85 * math.sin(x) ** 7 + 1
    if x >= 123 and x < 205:
        res = x ** 2
    if x > +205 and x < 221:
        res = x ** 4
    if x >= 221:
        res = (1 + x ** 3) / 83
    return res"
"import math

def main(y):
    res = 0
    if y < -9:
        res = 91 * pow(math.atan(y), 6)
    elif y >= -9 and y < 8:
        res = pow(pow(y, 2) - 47 - pow(y, 3), 2) - 94 * y
    elif y >= 8:
        res = 27 * pow(45 + 34 * pow(y, 2), 7) + math.atan(y) / 67
    return res"
"import math

def main(x):
    if x < 88:
        f = (x ** 2 / 33) ** 6 - 33 * (70 * x ** 2 - x - 85 * x ** 3) ** 5 - math.atan(x ** 7) * x
        return f
    elif (88 <= x) & (x < 119):
        f = 71 - 97 * x ** 7
        return f
    elif (119 <= x) & (x < 175):
        f = (58 * x ** 2 + x) / 33
        return f
    elif (175 <= x) & (x < 232):
        f = 15 * math.sqrt(x) ** 4
        return f
    else:
        f = x ** 3
        return f"
"import math

def main(y):
    if y < 66:
        x = 38 * (0.07 + y ** 2) ** 5
    elif y >= 147:
        x = 74 * y ** 2 + 64 + 24 * (0.03 + y ** 2 + y / 64) ** 4
    else:
        x = 91 * y ** 3 - 24 * y - 12 * y ** 6
    return x"
"def main(y):
    if y >= 187:
        y = 1 - 49 * (4 * y ** 2 + 77 * y ** 3) ** 2
    elif y < 103:
        y = y
    else:
        y = 57 * y ** 5
    return y"
"import math

def main(y):
    if y < 5:
        f = abs(y) ** 6 - 63 * math.cos(y + 96 + y ** 2) ** 5
    elif 5 <= y < 15:
        f = math.atan(y) ** 2 / 84
    elif 15 <= y < 43:
        f = 3 * (78 * y ** 2 - 42) ** 4 - (62 * y ** 3 - 65 * y) - math.log(95 * y ** 2 - 1) ** 3
    elif 43 <= y < 132:
        f = y - 0.04 - math.floor(y / 76 + y ** 2) ** 7 - 1
    elif 132 <= y:
        f = y ** 5
    return f"
"import math

def main(z):
    if z < 56:
        result = math.sin(z) ** 2 + 26 * math.cos(z) ** 3
    elif z > 145:
        result = 47 * z ** 5 + z ** 4
    elif (z >= 56) & (z < 89):
        result = z ** 7 - z ** 3
    else:
        result = (z ** 3 + z ** 2 + 60) ** 6
    return result"
"import math

def main(x):
    if x < 148:
        return x ** 5 - 10 * (93 * x - 1) ** 4 - x ** 7
    elif 148 <= x < 241:
        return 94 * x + 40 * (x ** 2 - 26) ** 5 + x ** 7
    elif 241 <= x < 290:
        return 72 * math.cos(1 + x) ** 4
    elif x >= 290:
        return math.tan(x) ** 6 - 79 * x ** 4 - 2 * (18 - x ** 3 - 25 * x) ** 2"
"import math

def main(y):
    if y < 136:
        x = 29 + 216 * y ** 2 + (y ** 3 / 37 + 59) ** 2
    elif y < 169:
        x = math.log(y) ** 2 + 81 * y ** 7
    elif y < 240:
        x = 26 * math.floor(y) ** 5
    else:
        x = 5 + 92 * (1 - y - y ** 3) ** 3
    return x"
"from math import atan, log10

def main(z):
    if z < 27:
        return 42 * (80 * z - z ** 2 / 16 - 31) ** 6 + 1
    elif z < 81:
        return 43 * z - 93 * atan(70 * z ** 2) ** 6 - log10(z) ** 2
    else:
        return 7 * (15 * z ** 3 + 28 + z) - 97 * z ** 4"
"import math

def main(z):
    if z < -37:
        return 53 * 50 * pow(z, 3) + pow(z, 2) + z / 18
    elif z >= -37 and z < 28:
        return 60 * z
    elif z >= 28:
        return pow(54 - 24 * z - pow(z, 2), 3) / 67"
"import math

def f1(z):
    return z ** 7 + abs(z) ** 3

def f2(z):
    return math.atan(76 - z ** 3 - z) ** 4 - z

def f3(z):
    return math.tan(z) + 17 * math.log(z, 10) ** 7 + (z + 45 * z ** 2) ** 4 / 17

def f4(z):
    return z ** 6 - 47 * (z ** 2 + z + 1) ** 7

def f5(z):
    return 27 * (1 - 2 * z ** 3) ** 3 + 28 * z ** 6

def main(z):
    if z < 1:
        return f1(z)
    elif z < 46:
        return f2(z)
    elif z < 95:
        return f3(z)
    elif z < 184:
        return f4(z)
    else:
        return f5(z)"
"import math

def main(y):
    result = 0
    if y < 113:
        result = 84 * (69 * y ** 2 - 97 * y - 50) ** 7 - 71 - 4 * math.cos(1 + y ** 3 + y ** 2)
    elif 113 <= y < 193:
        result = 34 - y ** 4
    elif 193 <= y < 204:
        result = 37 * y
    elif 204 <= y < 237:
        result = math.exp(y) ** 2 + 35 * y ** 4 + 49 * (1 - 67 * y ** 2 - y) ** 7
    else:
        result = y ** 2 + y
    return result
main(96)
main(244)"
"import math

def main(x):
    if x < 65:
        rez = 57 * math.log10(x) ** 7 - (x ** 2 - x ** 3 - x) ** 4 / 48 - x ** 2
    elif 65 <= x < 81:
        rez = 21 + (x ** 3 - 1) ** 4
    elif x >= 81:
        rez = 60 * x ** 2 - 69 * x - 68
    return rez"
"import math

def main(z):
    if z < 138:
        ans = 14 * (z ** 3 - z / 36 - 26) ** 2 - 46 * z
    elif 138 <= z < 182:
        ans = 66 * z ** 2 - math.log10(7) * z
    else:
        ans = z ** 4
    return ans"
"from math import sqrt
from math import tan
from math import log

def main(x):
    if x < -2:
        res = x * x + 93 * x ** 14 + (1 + 43 * x * x + 60 * x) ** 6 / 70
    if -2 <= x < 28:
        res = 77 * (93 * x ** 3) ** 6 - 80 * x * x - 24
    if 28 <= x < 54:
        res = x * x - tan(x) ** 3 / 17
    if x >= 54:
        res = log(x, 2) ** 4 - 76 * log(39 + x * x + 51 * x ** 3, 10) ** 5 - x ** 7
    return res"
"import math

def main(y):
    if y < 1:
        return 0.02 - 98 * pow(y, 3)
    if y >= 1 and y < 39:
        return pow(y + 90, 5) - pow(14 + pow(y, 3), 2) / 31
    if y >= 39:
        return pow(math.sin(y), 7) + 68 * pow(95 * y - pow(y, 2) / 18 - 45 * pow(y, 3), 4)"
"def main(x):
    if x < 12:
        return x ** 3 / 28 - (x - x ** 3) ** 4 / 62
    elif x >= 12 and x < 80:
        return (27 + 59 * x) ** 4
    else:
        return 89 * (x ** 3 / 55 - x) ** 3"
"import math

def main(x):
    if x < 96:
        return 0.01 - 44 * math.log(x ** 3) ** 2 - 90 * x ** 3
    elif 96 <= x < 166:
        return 44 * x ** 4 + 7 * (x ** 2 - x ** 3) ** 3 + 40 * x ** 7
    elif 166 <= x < 231:
        return 2 * (x ** 3 + x + x ** 2) ** 2
    else:
        return math.log(x, 10) ** 5 / 83"
"from math import exp, log

def main(x):
    if x < 72:
        return pow(85 * pow(x, 3) + x ** 2 + 74, 3) - pow(x ** 2 / 41 + x ** 3, 2) - 73
    elif x < 125:
        return pow(log(x), 3)
    elif x < 198:
        return (1 - 79 * x) ** 3 - x ** 6
    elif x < 234:
        return 34 * pow(exp(x), 3) + x + 92 * pow(27 * pow(x, 3), 5)
    else:
        return 16 + 33 * pow(log(x ** 2 / 21 + 72 + 52 * pow(x, 3)), 4)"
"from math import *

def main(x):
    if x < 103:
        return 28 - pow(log10(x ** 2 - 14 * x), 7)
    elif x < 201:
        one = (26 * x + x ** 3 + x ** 2) ** 4
        return one + (96 * x ** 2 + 22) ** 3 + x ** 7
    elif x < 230:
        return 62 * tan(10 * x) ** 3 + 0.01 + x ** 4 / 28
    elif x < 260:
        return 85 + x / 89
    else:
        return x ** 6 - 97 * x"
"import math

def main(y):
    if y < 8:
        return y ** 7
    elif y < 71:
        return (45 + 34 * y ** 3) ** 3 + 7 * (y - y * y / 76 - 6 * y ** 3) ** 5
    elif y < 122:
        r1 = math.tan(y * y + 91 * y) ** 2
        r2 = 62 * y * y - 1 - 32 * y - 39 * math.sin(11 * y - 50) ** 4
        return r1 - r2
    else:
        return y / 24 + 41 * y ** 6"
"import math

def main(x):
    if x < -2:
        return (x ** 3 / 24) ** 3 + 37 * math.ceil(x) ** 2 + 75 * (x ** 2 / 15) ** 7
    elif -2 <= x < 47:
        return 53 * math.floor(x + 1 + x ** 3) ** 6 + (x - 96 * x ** 3 - 21 * x ** 2) ** 3 / 71
    elif 47 <= x < 59:
        return 55 * (85 - x ** 2) ** 5 - 29 * x ** 2 - 9 * (x ** 3 - x ** 2 - 66) ** 6
    elif 59 <= x < 149:
        return 76 * x + math.sin(x) ** 4
    elif x >= 149:
        return x + 40 * math.tan(x / 19) ** 4 + x ** 5"
"import math

def main(y):
    if y < 61:
        r = 46 * (y ** 2 + 1 + 50 * y ** 3)
    elif 61 <= y < 127:
        r = 8 * (33 * math.floor(y)) ** 3
    elif 127 <= y < 201:
        r = 41 * y ** 4 + 1
    elif 201 <= y < 250:
        r = 80 * y ** 2 + y ** 4
    else:
        r = math.atan(y) ** 5
    return r"
"def main(y):
    if y < 31:
        return y ** 4 - (y - 9 * y ** 2 - 77 * y ** 3) ** 6 - y ** 2
    if 31 <= y < 108:
        return (35 * y ** 2) ** 6 - 1 - 27 * (1 - y ** 3 - y ** 2) ** 3
    if y >= 108:
        return y ** 21 + 2 * y ** 2"
"import math

def main(x):
    if x < 29:
        f = 26 * (x ** 2 / 63 - x ** 3 / 89 - 40) ** 7 - x ** 5 - (70 * x ** 2 + 83 + x / 35) ** 3
    elif 29 <= x < 55:
        f = 4 * (1 - 11 * x ** 3 - x) ** 6 + math.exp(x) ** 5 + 50
    elif 55 <= x < 69:
        f = x ** 3 + 1 + x ** 3
    elif 69 <= x < 153:
        f = x ** 4 - 28 - x ** 5
    elif x >= 153:
        f = 1 - 97 * x ** 3
    else:
        f = x
    return f"
"from math import *

def main(z):
    if z < 40:
        return 34 * abs(z ** 2 + z ** 3 / 7 + z) ** 3 + 41 * z + 8 * z ** 2
    elif z < 121:
        return (82 + z ** 3) ** 4 - 54 * tan(6 * z - z ** 2 - 92) ** 2
    else:
        one = (42 * z ** 2 - 70 * z) ** 2
        return one + tan(0.01 + 14 * z ** 3 + 8 * z ** 2) ** 5 + 19"
"import math

def main(y):
    if y < -39:
        return 3 * pow(math.sin(pow(y, 2)), 5)
    elif -39 <= y < 27:
        return 86 * pow(math.sin(3 * pow(y, 2)), 7) - 1 - 40 * pow(79 - y - 95 * pow(y, 3), 2)
    elif 27 <= y < 65:
        return 29 * pow(pow(y, 2) - 1, 6) + pow(y, 4)
    elif 65 <= y < 163:
        return pow(y, 2) + pow(math.cos(y), 7)
    elif y >= 163:
        return math.sqrt(y) / 39 + pow(y, 2)"
"import math

def fu(z):
    if z < 18:
        a = pow(math.log10(pow(z, 2) / 95 + 1), 6)
    if z >= 18 and z < 59:
        a = pow(pow(z, 2) / 33 + pow(z, 3), 3)
    if z >= 59:
        a = pow(z, 7) + pow(90 * pow(z, 3), 4) + pow(z, 2)
    return a

def main(arg):
    return fu(arg)"
"import math

def main(z):
    if z < 99:
        a = z ** 3 + z ** 5 / 42
        a = a + 25 * math.fabs(26 - 25 * z ** 2 - 17 * z ** 3) ** 6
    elif z >= 99 and z < 151:
        a = (z ** 2 - 80 * z ** 3 - 62) ** 3 - 76
    elif z >= 151:
        a = 39 * z ** 4
    return a
main(28)"
"from math import *

def fun2(z):
    result = 0
    if z < 49:
        result = 55 * pow(z, 4) + pow(11 * z - 14 * pow(z, 3), 5)
    elif 49 <= z < 146:
        result = 2 + pow(z, 6) / 47
    elif 146 <= z < 179:
        result = 0.05 + pow(tan(z), 2) + pow(12 * pow(z, 3), 5) / 96
    elif z >= 179:
        result = 16 + 48 * pow(z / 60 - pow(z, 2) - pow(z, 3), 4)
    else:
        return 0
    return result

def main(a):
    return fun2(a)"
"import cmath

def f2(z):
    if z < 72:
        return ((97 * z ** 2 - 1 - 57 * z ** 3) ** 7 + 1).real
    elif 72 <= z < 152:
        return (z ** 8).real
    else:
        return (4 * z ** 3 + cmath.tan(z ** 3 / 37 + 55 * z + 32)).real

def main(z):
    return f2(z)"
"from math import sin, atan

def main(y):
    if y < 25:
        return y ** 5 + 89 * atan(17 * y ** 3 + 19) ** 6
    elif y < 93:
        return sin(y ** 3) ** 7
    elif y < 111:
        return 53 * (38 * y ** 2 + 39 * y + 27 * y ** 3) ** 5 - 19 - 96 * y ** 7
    else:
        return 32 * (35 * y ** 2 - 97 * y ** 3) ** 6 + y ** 2 + y ** 5"
"import math

def main(y):
    if y < 24:
        k1 = 44 * y ** 3
        return k1
    if 24 <= y < 49:
        k2 = y ** 7 + y ** 2
        return k2
    else:
        k3 = 98 * math.sin(y) ** 6 + y ** 3
        return k3
main(-10)"
"import math

def main(y):
    if y < 66:
        return y - 47 * abs(y - 8) ** 2 - abs(y) ** 3 / 57
    elif 66 <= y < 113:
        return 47 * y ** 7
    else:
        return 14 * math.tan(y) ** 7 + 86 + (y ** 2 / 57 + 0.09 + y ** 3) ** 2"
"import math

def main(x):
    if x < 10:
        return 59 * (66 * x ** 2) ** 3
    if 10 <= x < 91:
        return (x ** 2 - x ** 3) ** 3
    if x >= 91:
        return (x + 1) ** 5"
"import math

def main(x):
    if x < 103:
        result = x - 51 * math.tan(x) ** 6
    elif 103 <= x < 165:
        result = x ** 5 + 26 * math.atan(x ** 3 + 67 + x ** 2) ** 4
    else:
        result = 43 * math.floor(x ** 7)
    return result"
"import math

def main(x):
    s = 0
    if x < 79:
        s = 10 * (87 * x ** 3) ** 5
    elif x >= 79 and x < 107:
        s = x ** 6
    elif x >= 107 and x < 177:
        s = x ** 5 + 8 * math.atan(x) ** 6 + 71 * math.tan(x) ** 3
    elif x >= 177:
        s = 8 * x - 18 * (53 * x ** 3 - x ** 2 / 89) ** 5
    return s"
"def main(x):
    import math
    if x < -11:
        c = math.pow(95 + 35 * math.pow(x, 3), 2)
        z = math.pow(x + 1 + 13 * math.pow(x, 2), 6) / 20 - math.pow(math.fabs(x), 4) - c
    elif -11 <= x < 74:
        z = math.pow(x, 5) - 420 * math.pow(x, 2) - 53 * math.pow(math.fabs(x), 7)
    elif 74 <= x < 158:
        z = 90 * math.pow(1 + 65 * math.pow(x, 3) + 65 * x, 7) - 81 * math.pow(x, 2) - 1
    elif x >= 158:
        a = 82 - 8 * math.pow(62 * math.pow(x, 2) + 44 * math.pow(x, 3) + x, 6)
        z = a - math.pow(47 * x + 46 * math.pow(x, 3), 5)
    return z"
"def calc(y):
    if y < 85:
        return 78 * (y ** 2 - y ** 3) ** 7 - 39 * y - 28 * (15 + 40 * y ** 3 + 23 * y) ** 5
    if 85 <= y < 130:
        return y ** 6 + 54 * y ** 3 + 85 * (y + 1) ** 2
    if 130 <= y < 171:
        return y ** 2 / 92 - y ** 3
    if 171 <= y < 244:
        return y ** 2 / 54 - (81 * y ** 2 + 82 * y ** 3 + 0.04) ** 7 / 45
    if y >= 244:
        return 25 * y ** 4 - 82 * (0.01 + y ** 3 + 77 * y) ** 3 - 0.1

def main(y):
    return calc(y)"
"def main(y):
    z = 78 * (y ** 2 - y ** 3) ** 7
    if y < 85:
        return z - 39 * y - 28 * (15 + 40 * y ** 3 + 23 * y) ** 5
    if 85 <= y < 130:
        return y ** 6 + 54 * y ** 3 + 85 * (y + 1) ** 2
    if 130 <= y < 171:
        return y ** 2 / 92 - y ** 3
    if 171 <= y < 244:
        return y ** 2 / 54 - (81 * y ** 2 + 82 * y ** 3 + 0.04) ** 7 / 45
    if y >= 244:
        return 25 * y ** 4 - 82 * (0.01 + y ** 3 + 77 * y) ** 3 - 0.1"
"def main(y):
    if y < -69:
        f = 94 * y ** 4
    elif y >= -69 and y < -48:
        f = 31 * y ** 7
    elif y >= -48 and y < -4:
        f = 38 * abs(1 - y) ** 4 - 41 * y
    elif y >= -4 and y < 78:
        f = 0.02 - (0.01 + 21 * y ** 2) ** 7 - 38 * (y ** 3 - 99 * y ** 2) ** 3
    elif y >= 78:
        f = y ** 3
    return f"
"def main(y):
    z = 78 * (y ** 2 - y ** 3) ** 7
    if y < 85:
        return z - 39 * y - 28 * (15 + 40 * y ** 3 + 23 * y) ** 5
    if 85 <= y < 130:
        return y ** 6 + 54 * y ** 3 + 85 * (y + 1) ** 2
    if 130 <= y < 171:
        return y ** 2 / 92 - y ** 3
    if 171 <= y < 244:
        return y ** 2 / 54 - (81 * y ** 2 + 82 * y ** 3 + 0.04) ** 7 / 45
    if y >= 244:
        return 25 * y ** 4 - 82 * (0.01 + y ** 3 + 77 * y) ** 3 - 0.1"
"import math

def main(x):
    if x < 160:
        return 9 * math.exp(47 - 51 * x ** 2) - 12 * x ** 6
    elif x >= 160 and x < 235:
        return math.sqrt(2 * x - 1)
    elif x >= 235 and x < 303:
        return 74 * (44 * x) ** 4
    elif x >= 303:
        return 53 * (27 - x ** 3) ** 6 + 1 + (96 * x) ** 4"
"def main(y):
    z = 78 * (y ** 2 - y ** 3) ** 7
    if y < 85:
        return z - 39 * y - 28 * (15 + 40 * y ** 3 + 23 * y) ** 5
    if 85 <= y < 130:
        return y ** 6 + 54 * y ** 3 + 85 * (y + 1) ** 2
    if 130 <= y < 171:
        return y ** 2 / 92 - y ** 3
    if 171 <= y < 244:
        return y ** 2 / 54 - (81 * y ** 2 + 82 * y ** 3 + 0.04) ** 7 / 45
    if y >= 244:
        return 25 * y ** 4 - 82 * (0.01 + y ** 3 + 77 * y) ** 3 - 0.1"
"import math

def main(y):
    if y < 65:
        result = math.sqrt(y) ** 6 + 2 * math.cos(y) ** 4
    elif 65 <= y < 99:
        result = 20 * y ** 7 - y ** 4
    else:
        result = 40 * (46 * y ** 2 + 38) ** 7 - 1
    return result"
"import math

def main(y):
    if y < 79:
        y = y ** 2 - 0.01 - 43 * y ** 3 + y ** 4
        return y
    if 79 <= y < 125:
        y = 51 * y ** 9 - 94 * y ** 4
        return y
    if 125 <= y < 168:
        y = 1 - y ** 4
        return y
    if 168 <= y < 253:
        y = 51 * (75 * y ** 3) ** 4 + 8 * y + 1
        return y
    if y >= 253:
        y = 3 * math.ceil(y ** 2 + y + 93) ** 7 - 1 - abs(y)
        return y"
"from math import *

def main(x):
    if x < -21:
        return x ** 3 / 87 + exp(x) ** 7 / 75
    elif x >= -21 and x < -11:
        return 72 * x ** 6
    elif x >= -11 and x < 32:
        return (50 * x) ** 6 + (x ** 3 + 76 * x) ** 2 + 50
    else:
        return x ** 6 + 48 + 98 * x ** 4"
"import math

def main(z):
    result = 0
    if z < -10:
        result = 1 + int(z) ** 5 + math.exp(59 * z ** 3 - z ** 2 - 1) ** 6
    elif z >= -10 and z < 46:
        result = math.atan(z)
    elif z >= 46 and z < 95:
        result = (z ** 2 - z ** 3 / 64) ** 4 + 72 * (z ** 3 / 50 + z ** 2) ** 3
    elif z >= 95:
        result = 71 * (20 * z ** 3 + 11 + z) ** 6
    return result"
"import math

def main(y):
    if y < 5:
        return y ** 6 - 51 * y - (99 * y ** 2 - 67 - 25 * y ** 3) ** 4
    if y < 81:
        return 1 + 10 * (y ** 2 / 32) ** 4
    if y < 149:
        return 76 * y ** 6 + 61 * (y + 1) + 7 * (y ** 2 + 83 * y) ** 5
    return 42 * (40 * y) ** 4 - 65 * y ** 5"
"def main(x):
    if x < 65:
        return 32 * x + 41 * x ** 6
    elif 65 <= x < 109:
        return 81 * (x ** 2 + 1) ** 5 - x ** 6 / 10
    elif 109 <= x < 178:
        return 69 * x * x
    elif 178 <= x < 193:
        return 55 * x * x + x
    elif x >= 193:
        return (x + 1 + x * x) ** 4 - 21 * x ** 3"
"def main(y):
    if y < 100:
        return 46 * y ** 6
    elif 100 <= y and y < 153:
        return 1 + 4 * y ** 5 + (1 + y + 13 * y ** 2) ** 2
    else:
        return 46 + (y + y ** 2 + 1) ** 2 / 19"
"def main(y):
    import math
    if y < 120:
        return 95 * math.sin(1 + 10 * y + y * y) ** 7
    elif 120 <= y < 141:
        return 2 * y ** 3 + 20 * (80 * y) ** 4
    elif 141 <= y < 222:
        return 29 * y ** 4 + (y * y - 20 * y) ** 3 + math.log(2, y) ** 6
    else:
        return y ** 3 - 23 * (74 * y) ** 6 - 1"
"from math import sqrt, pow, log

def main(z):
    if z < 81:
        return 1 + pow(z, 3) - 1 - z
    elif 81 <= z < 115:
        return 23 * pow(abs(z * z - 1 - z * z * z), 7) - pow(log(z), 5) - (pow(z, 3) - 41 - z)
    elif 115 <= z < 166:
        return 5 * pow(53 * z * z * z - 75 * z * z, 5)
    elif 166 <= z < 178:
        return pow(z, 6) / 62
    elif z >= 178:
        return pow(76 * z, 4)"
"def main(y):
    if y < 87:
        a = 1 - 1736 * y ** 3
    elif 87 <= y < 110:
        a = y ** 6 + 74
    elif 110 <= y < 177:
        a = 66 * pow(49 * pow(y, 3) - 1, 3)
    else:
        a = 28 * pow(y, 3) + 1 + y ** 4 / 65
    return a"
"import math

def main(z):
    if z < 67:
        return 38 * z ** 14 + 52 * (17 - z ** 2) ** 4
    elif 67 <= z < 142:
        return z ** 3 / 90 - z * z - z ** 7
    elif 142 <= z < 237:
        return (z ** 3 - 0.01 - z * z) ** 2 - 28 * z ** 5 - math.sin(z ** 3 + 14 * z + 1) ** 7
    elif 237 <= z < 253:
        return 89 * z ** 3
    elif z >= 253:
        return 39 * z ** 7 - (z - 4 - 64 * z ** 3)"
"import math

def f(y):
    if y < 118:
        return 12 * pow(y, 6)
    elif y >= 118 and y < 141:
        return pow(1 + pow(y, 3) + 49 * pow(y, 2), 3) + 75 * pow(y, 5)
    elif y >= 141 and y < 163:
        return 1 - 52 * y - 94 * pow(y, 3) + pow(math.cos(pow(y, 2) + 1 + y), 2) / 60 + pow(math.fabs(y), 5) / 76
    elif y >= 163:
        return 55 * pow(y, 6) + pow(y, 3)

def main(*args):
    return f(*args)"
"import math

def f(z):
    if z < 86:
        return 0.02 + z ** 6 + (44 * z ** 3 - 41 * z ** 2) ** 2
    elif 86 <= z < 168:
        return math.fabs(2 * z ** 2) ** 5 - 14 * (63 * z ** 3 - z ** 2 - z) ** 6
    elif 168 <= z < 250:
        return (1 + z ** 3 / 30) ** 7 + (z ** 3 + 2 * z) ** 2 + 97 * math.atan(z) ** 6
    elif 250 <= z < 312:
        return math.log(1 + z / 53 + 35 * z ** 2) ** 5 + 96 * z + z ** 4
    elif z >= 312:
        return 88 - 40 * math.cos(z) ** 7 - 13 * (z ** 3 - 1) ** 4

def main(*args):
    return f(*args)"
"import math

def main(x):
    if x < 83:
        return math.sin(72 - x - 73 * x * x) ** 3 + 47 * (x ** 3 + 31 * x * x) ** 4 + 64 * math.fabs(x) ** 7
    elif x < 179:
        return 56 * math.ceil(11 * x * x) ** 4
    else:
        return 62 * x ** 4"
"import math

def main(z):
    r1 = 0
    if z < 156:
        r1 = 75 * math.sin(z ** 2 - z) ** 2
    if 156 <= z <= 166:
        r1 = math.fabs(z) ** 7
    if 166 <= z < 194:
        r1 = (54 * z ** 2 - 50 * z ** 3 - 1) ** 5 + 1
    if 194 <= z < 285:
        r1 = (math.fabs(z ** 2 / 68) - 1 - z) ** 7
    if z >= 285:
        r1 = math.atan(z) / 53 - z ** 3
    return r1"
"import math

def main(y):
    if y < 60:
        a = math.log10(y ** 3 + 72 + y ** 2) ** 4
        return a + 33 * math.sin(1 - 52 * y - y ** 2) ** 5
    if 60 <= y < 72:
        return 92 * abs(y) ** 7 + 94 * y ** 5
    if 72 <= y < 93:
        return math.atan(53 + 70 * y + 2 * y ** 2) ** 6 / 39 + y + 1 + y ** 3
    if 93 <= y < 128:
        return 71 * (76 * y ** 2 - y / 47 - y ** 3 / 90) + 57 * y ** 2
    if y >= 128:
        return (45 * y ** 2 - 42 - y) ** 5 + 2 * math.atan(y) ** 3
main(28)"
"import math

def main(z):
    z = float(z)
    if z < -7:
        return 14 * z ** 6 - math.sin(z) - z ** 5
    elif -7 <= z < 16:
        return 12 * z ** 5
    elif 16 <= z < 70:
        return z ** 6 + 52 * z ** 3
    elif 70 <= z < 139:
        return z ** 4
    else:
        return math.tan(90 * z ** 3 + z + z ** 2) ** 5 - 52"
"import math

def main(z):
    res = 0
    if z < 42:
        res = math.floor(88 * z ** 3)
    elif 42 <= z <= 136:
        res = (z ** 2 / 23) ** 6
    elif 136 <= z <= 230:
        res = 23 * (58 + z ** 3) ** 2 + math.floor(0.06 - z ** 2 / 83 - z ** 3) ** 6 + 1
    elif 230 <= z <= 270:
        res = z ** 7
    elif z >= 272:
        res = 46 * z ** 4 - z ** 3
    return res"
"def main(x):
    if x < 134:
        return 0.03 + x + 73 * x ** 5
    elif 134 <= x < 176:
        return x ** 6 - 44 * x ** 5
    else:
        return 55 * (82 + x ** 2) ** 6"
"from math import cos, log

def main(z):
    if z < 22:
        return pow(z, 3) + 3 * pow(z, 5)
    elif 32 > z >= 22:
        return 1 - z - 49 * pow(cos(2 - z), 4) - pow(45 * pow(z, 3), 5)
    elif z >= 32:
        return 99 * pow(cos(z), 4) + 4 * log(z + 91 + pow(z, 3), 2)"
"import math

def main(x):
    if x < 12:
        return x ** 6 + x ** 7 / 90
    elif 12 <= x and x < 112:
        f = 1 + 98 * x ** 5
        f = f + math.log2(73 + x ** 3 / 79 + 91 * x ** 2) ** 4
        return f
    elif 112 <= x and x < 205:
        f = 77 * (85 * x ** 2 + 34 + 4 * x) ** 2
        f = f - (x ** 3 / 42 - x ** 2 - 1) ** 3 - math.sqrt(x) ** 5
        return f
    elif x >= 205:
        return (50 * x ** 2) ** 2 - 1"
"import math

def main(z):
    if z < 61:
        return 74 - 66 * (52 * z ** 2 + 43 + 21 * z ** 3) ** 2 - z / 14
    elif 61 <= z < 102:
        return z ** 7 + (76 * z) ** 6 + (7 * z ** 3 - 38 * z ** 2) ** 5
    elif 102 <= z < 134:
        return 12 * math.log2(z ** 3 - 1) ** 6 - z ** 7
    elif 134 <= z < 223:
        return math.log2(z ** 2) ** 5 + (62 * z ** 3 - z - 14 * z ** 2) ** 2 + (3 * z ** 3) ** 6
    elif z >= 223:
        return 41 - z ** 7"
"import math

def main(z):
    if z < 169:
        return 54 + 44 * pow(math.cos(pow(z, 3) + 85 * pow(z, 2) + 34), 3)
    if z < 239:
        return 48 * pow(z, 7)
    if z < 254:
        first_part = math.log(pow(z, 2) + z + pow(z, 3))
        second_part = pow(z, 7) - math.tan(z) / 58
        return first_part - second_part
    return pow(z, 2) / 92 + 6"
"def main(y):
    if y < -32:
        return 4 * (45 * y - y ** 3 - y ** 2) ** 7 - y ** 2
    elif -32 <= y < -10:
        return (88 * y ** 2 - y) ** 2 - y / 18
    elif -10 <= y < 89:
        return 85 * (y ** 3 + 24 * y + 0.1) + 25 * y ** 2
    else:
        return (y ** 2 / 98) ** 2
main(120)
main(71)"
"import math

def main(x):
    if x < 87:
        return 1 + pow(math.tan(x - 17 * pow(x, 2)), 6)
    elif 87 <= x < 107:
        return 98 * pow(x, 3) + 0.07 + 13 * pow(abs(x), 5)
    elif 107 <= x < 169:
        return 61 * pow(x, 3)
    else:
        return 55 * pow(9 - pow(x, 2), 3) - 58 * x - pow(math.atan(x), 2)"
"def main(n):
    res = 0
    if n < 187:
        res = n ** 6
    if 187 <= n < 216:
        res = 30 * n ** 4
    if n >= 216:
        res = (50 * n - 55 * n ** 2) ** 2
    return res"
"import math

def main(y):
    if y < 69:
        f = 54 * (26 + 17 * y ** 3 + 68 * y) ** 5
    elif y >= 144:
        f = y ** 5 / 52
    else:
        f = y ** 3
    return f"
"import math

def main(y: float):
    if y < 171:
        return 25 * (y ** 3 - 1) ** 2
    if (171 <= y) & (y < 256):
        return 97 * math.log10(y) ** 7
    if y >= 256:
        return 1 - 51 * (y ** 3 + y) ** 6 - (32 * y ** 3 - y) ** 5"
"import math

def main(y):
    if y < 1:
        d = 31 + (y / 74 - 13 * y ** 3) ** 7
    if 1 <= y < 100:
        d = 24 * y ** 6 + math.log(y, 2.72) ** 5
    if y >= 100:
        d = y ** 7 + 98 * (y + 36 * y ** 2) ** 5 + y ** 0.5
    return d"
"import math

def main(y):
    if y < -9:
        return 74 * y ** 5
    elif y < 86:
        return (y / 56 + y ** 3 + 95) ** 7
    elif y < 127:
        return 37 * y ** 3
    else:
        return 1 + math.tan(1 + y ** 2 + 49 * y) ** 5 + y ** 2"
"from math import tan, log

def main(z):
    if z < -51:
        res = 94 * z
    elif -51 <= z < -15:
        res = 39 * z ** 6 + 1 + 30 * z
    elif -15 <= z < 6:
        res = tan(z) ** 5
    elif z >= 6:
        res = 22 * z ** 3 + log(2, z) ** 2 + 82 * z ** 3
    return res"
"import math

def main(z):
    if z < 144:
        return 77 * pow(math.tan(z + 8 * pow(z, 3)), 3) - 8 * pow(z, 6) - 74 * pow(z, 4)
    elif 144 <= z & z < 222:
        return 43 * pow(math.sin(50 + 49 * z), 7) + 39 * z + 92 * pow(z, 3)
    elif 222 <= z & z < 318:
        return pow(7 * pow(z, 2) - 18 * z, 5)
    elif z >= 318:
        return 65 * pow(58 - z / 95, 2)"
"from math import *

def main(z):
    if z < 87:
        return (6 * z ** 2) ** 3 + 1
    elif 87 <= z < 184:
        return z ** 7 + 91 * atan(46 * z ** 2 - z ** 3 - 0.03)
    else:
        return ceil(8 - z ** 3 - z ** 2) ** 3"
"import math

def main(x):
    if x < 162:
        result2 = 20 * (x ** 3 / 7 + x + 1) - 0.2
    elif 162 <= x < 190:
        result2 = x ** 3 / 82
    elif 190 <= x < 220:
        result2 = 15 * x ** 6 - 1
    else:
        a = math.log(x ** 3 - 71 * x ** 2 - 91 * x, 10) ** 4
        b = math.sin(x ** 2 + x ** 3 / 57 + x) ** 7
        result2 = 92 * a + 70 * b
    return result2"
"def main(y):
    if y < 47:
        return (38 * y ** 3) ** 4 + 99 * (1 - 82 * y) ** 7 + 10 * (6 * y ** 2 + 36 * y)
    if 47 <= y < 70:
        return 59 * y ** 3 + 37
    if 70 <= y < 124:
        return 61 * y ** 6
    if 124 <= y < 192:
        return y ** 3
    if y >= 192:
        return 17 * y ** 3"
"import math

def main(z):
    if z < 39:
        return 29 * math.ceil(z)
    elif 39 <= z < 87:
        return 35 * math.exp(z) ** 6
    elif 87 <= z < 185:
        return z ** 3 + 23 * abs(z ** 2) + z ** 4
    elif 185 <= z < 233:
        return (61 * z ** 2) ** 5 / 51 - 82 * z ** 6 - 59 * math.tan(25 + 86 * z ** 3 + 63 * z) ** 3
    else:
        return 92 * z ** 6 + math.log(z) ** 5"
"import math

def main(y):
    if y < 4:
        S = 91 * (47 * y ** 3) ** 2 - 38 * y ** 4
    if 4 <= y < 60:
        S = 26 * y ** 2 + 1 + 51 * (75 * y ** 2 - 1) ** 7
    if y >= 60:
        S = 69 * math.atan(37 * y) ** 2
    return S
main(-15)
main(16)"
"import math

def main(x):
    if x < 70:
        x = 20 * x ** 5 - 31 * x ** 2
    elif 70 <= x < 129:
        x = x ** 3
    elif x >= 129:
        x = 77 * math.log(x) ** 5 + 75 * math.floor(x) ** 4
    return x
main(141)
main(77)"
"import math

def main(z):
    if z < 145:
        r = pow(14 * z, 2)
    elif 145 <= z < 238:
        r = 21 * pow(z + 1, 3) - 3 * pow(abs(z * z * z - 1 - 15 * z * z), 7)
    else:
        r = z / 16
    return r"
"from math import log2, atan

def main(z):
    if z < 129:
        return z ** 3 - 6 * (2 * z + 1 + z ** 3) ** 7 - (84 * z ** 3 - 12 * z)
    elif z < 224:
        return z
    elif z < 271:
        return log2(z) ** 5
    else:
        return 91 * (z + 80 + z ** 3) ** 5 - atan(z) ** 3"
"import math

def main(y):
    if y < -55:
        a = (43 + y) ** 4 / 49
        b = 9 * (y ** 2 / 24 - 5 * y) ** 2
        c = (11 * y) ** 3
        f = a - b - c
        return round(f, 1)
    if -55 <= y < 43:
        f = 9 * y ** 4
        return math.ceil(f)
    if 43 <= y < 62:
        f = 54 * y ** 5
        return round(f, 1)
    if y >= 62:
        f = 93 * y ** 6 + y ** 2 / 91
        return round(f, 1)"
"import math

def main(x):
    if x < 102:
        p = x ** 5 / 48 - 20 * x ** 12 - 50 * (2 * x) ** 4
    if x < 169 and x >= 102:
        p = x ** 2
    if x >= 169 and x < 229:
        p = 47 * x ** 7
    if x >= 229:
        p = 36 * x
    return p
main(134)"
"import math

def main(z):
    if z < 166:
        return 15 * z - (z ** 3 - z - z * z) ** 5 / 23
    elif 166 <= z < 240:
        return 45 * math.atan(z) ** 3 + 53 * z ** 7
    elif 240 <= z < 332:
        return z ** 6 + (z ** 3 + 76 * z * z + 66) ** 3 / 43
    elif 332 <= z < 376:
        return 97 * math.log(z) * math.log(z) - 1
    else:
        return 3 * (1 + z + z ** 3) ** 5"
"import math

def main(y):
    if y < 110:
        res = 22 * pow(pow(y, 3) + 34 + 66 * y, 7)
    elif 110 <= y < 120:
        res = 17 * pow(math.ceil(pow(y, 2) + 10), 6)
        res = res + pow(10 * pow(y, 2) - pow(y, 3) - 66, 7) + 74 * pow(y, 4)
    elif y >= 120:
        res = pow(math.ceil(y), 4) / 89 + pow(y, 6)
    return res"
"import math

def main(x):
    if x < 66:
        d = math.pow(math.pow(x, 3) - 1, 5)
    elif 66 <= x < 89:
        d = 59 * math.pow(math.log10(x), 6) - 1 - 81 * math.pow(x, 3)
    elif 89 <= x < 169:
        d = math.pow(x, 3)
    elif x >= 169:
        d = 62 - 44 * (x / 86)
    return d"
"import math
from math import *

def main(y):
    if y < 48:
        a = cos(44 * y * y * y) ** 4 - 55 * (93 * y + y * y * y + 28) - y ** 7
        return a
    elif 48 <= y < 143:
        a = 61 * y ** 4
        return a
    else:
        a = 72 * (y * y - 1) ** 4 - 59 * y ** 7 - tan(y) ** 5
        return a
main(60)"
"import math

def main(z):
    if z < 11:
        r = (z + z ** 3) ** 2 - math.log2(39 * z + 52 + z ** 3) ** 4 / 30 - z ** 6
    elif 11 <= z < 101:
        r = 23 - 27 * int(z ** 2 + 70 * z) ** 3
    else:
        r = 60 * (93 * z * z * z) ** 6 + 60 * z
    return r"
"import math

def main(x):
    if x < 101:
        return pow(x, 7) - 56 * pow(86 * x - 33 * pow(x, 3) - 0.02, 2)
    if x >= 101 and x < 117:
        return 80 * math.log(51 * pow(x, 2) + 1) + 39 * pow(x, 5)
    if x >= 117 and x < 137:
        return 67 * pow(x, 2) - x
    if x >= 137:
        return 41 * x + pow(math.floor(x), 6)"
"import math

def main(y):
    z = 0
    if y < 61:
        z = 68 * (91 * y ** 3 + y ** 2) ** 2
    elif 61 <= y < 130:
        z = math.fabs(y) / 8
    else:
        z = 13 * y
    return z"
"import math

def main(x):
    if x < 45:
        res = 39 * x ** 6
    if x >= 45 and x < 70:
        res = 58 * x ** 5
    if x >= 70 and x < 103:
        res = 57 * (77 * x - 17 * x ** 3) ** 6 - 35 * math.tan(x) ** 5
    if x >= 103:
        res = 48 * math.tan(16 * x + 94) ** 2 + math.ceil((99 * x ** 3) ** 6) + x ** 3 / 34
    return res"
"import math

def main(x):
    if x < 137:
        return 58 * math.pow(x, 7)
    if x >= 137 and x < 228:
        return math.pow(17 * math.pow(x, 3) + math.pow(x, 2) + x / 24, 6)
    if x >= 228 and x < 315:
        return 66 * math.pow(8 * x, 3)
    if x >= 315:
        return math.pow(math.fabs(math.pow(x, 3) + x), 6)"
"def main(x):
    if x < 156:
        return 52 * (x ** 2 / 13 + x) ** 4
    elif 156 <= x < 219:
        return 49 * (x ** 3 - x ** 2 - 1) ** 2 - 33 - 58 * x ** 3
    else:
        return x ** 3"
"from math import sin, cos

def main(z):
    if z < 33:
        return pow(sin(62 * z * z + pow(z, 3) / 34), 7) + pow(z, 4) / 48
    elif 33 <= z < 127:
        return pow(sin(z), 7) / 17 - pow(z, 4) / 39 - 43 * pow(z, 6)
    elif 127 <= z < 213:
        return pow(pow(z, 3) / 47 - z - 1, 2) + 58 + 15 * pow(46 * z * z * z + z * z / 33, 3)
    elif z >= 213:
        return 48 * pow(cos(65 + pow(z, 3) + z), 7) + 5 * pow(z, 5)"
"import math

def main(y):
    if y < 22:
        return math.floor(pow(y, 7)) + math.floor(pow(y, 2))
    if 22 <= y < 80:
        return 43 * y + 1
    if 80 <= y < 128:
        return pow(math.sin(62 * pow(y, 3) - 78), 5) / 55 + 93 * pow(1 - 22 * pow(y, 3), 7)
    if y >= 128:
        return 36 * pow(math.log(y), 5) + 0.02"
"import math

def main(y):
    if y < -29:
        res = math.pow(23 * y, 7)
        res -= math.pow(45 * math.pow(y, 3) + 22 * y, 6)
        res -= math.pow(71 * math.pow(y, 3) - 60, 5)
    elif -29 <= y < 32:
        res = 1 - 33 * math.pow(95 * math.pow(y, 3) - math.pow(y, 2), 2)
    elif 32 <= y < 55:
        res = 82 * math.pow(y, 5) + 53 * y
    else:
        res = math.pow(13 * y + math.pow(y, 2), 6)
    return res"
"def main(x):
    if x < 164:
        a = 25 * (x ** 2 / 6 - x) ** 6
        b = 61 * x ** 5
        c = 81 * (x ** 3 - x - 24) ** 3
        return a - b - c
    elif x < 250:
        return x ** 4 / 99
    elif x < 315:
        return x ** 2 - 79 * x ** 5
    else:
        return 94 * x"
"import math

def main(x):
    if x < 52:
        return 29 * (91 * x ** 2 - x ** 3) ** 5 - 97 * math.cos(x ** 3 - 90 * x) ** 2
    elif 52 <= x < 80:
        return 94 * math.exp(x / 55 - 41) ** 3 + math.log(x) ** 4 / 54 + 13 * (1 + x)
    elif 80 <= x < 158:
        return 58 * math.floor(x) ** 7 - x ** 3 - x ** 3
    elif 158 <= x < 239:
        return x ** 18 / 70 - x ** 2
    elif x >= 239:
        return (1 - x) ** 3 + 72 * x ** 7 + 26 * abs(x ** 3 / 14 - 73 * x) ** 6"
"import math

def main(x):
    if x < 111:
        r = 1 + pow(16 + 59 * x, 7) + 30 * pow(math.log2(pow(x, 3)), 4)
    if x >= 111 and x < 207:
        r = 39 * pow(0.01 - x - pow(x, 2), 7)
    if x >= 207 and x < 226:
        r = 42 + x
    if x >= 226:
        r = 1 + 43 * pow(x + 60 * pow(x, 3), 4)
    return r"
"import math

def main(x):
    if x < 103:
        return x ** 3
    elif 103 <= x < 121:
        return (17 * x ** 3 + 25 + x ** 2) ** 4 - math.log10(x) ** 7 - 40
    elif 121 <= x < 142:
        return 66 * (0.02 - x ** 2) ** 5
    elif 142 <= x < 177:
        return (50 * x ** 2 + 64 * x + 15 * x ** 3) ** 5 - (x + 0.01) ** 2
    elif x >= 177:
        return 91 * (x ** 2 + 1 + x ** 3) ** 3 + 40 * x + 64 * math.log2(x) ** 7"
"import math

def main(y):
    if y < 70:
        res = y
    elif 70 <= y < 108:
        res = 52 * math.asin(68 * y - y ** 2) ** 4
    elif 108 <= y < 145:
        res = 14 * math.log10(y ** 4) - 5 * y ** 14
    elif 145 <= y < 196:
        res = 9 + 60 * y ** 2
    elif 196 <= y:
        res = 47 * pow(math.exp(y / 21 - 59), 3) + 36 * y ** 2
    return res"
"import math

def main(y):
    if y < 129:
        return (y ** 3 - y ** 2 / 74 - 93) ** 4 / 4 - 1
    elif 129 <= y < 200:
        return (37 * y ** 3 + y ** 2 / 38 + 1) ** 6
    elif 200 <= y < 272:
        return y / 22 - 60 * math.floor(y + y ** 2) ** 2
    elif 272 <= y < 336:
        a = y ** 3 + 83 + 62 * y ** 2
        return y ** 5 / 32 - 4 * math.log(a, 10) ** 6 - 1
    elif y >= 336:
        return 29 * y"
"import math

def main(x):
    if x < 53:
        d = 31 * x ** 2 - 31 - x ** 6 / 94
    elif 53 <= x < 136:
        d = 53 * x ** 4
    elif x >= 136:
        d = x / 95 - x ** 4
    return d"
"from math import log, atan, sin, sqrt, exp, cos
import math

def main(x):
    if x < 96:
        f = (x + x ** 3) ** 6 / 88 + 89 * (x ** 3 / 57 - x ** 2 - x) + x ** 4 / 43
    elif 96 <= x and x < 120:
        f = 11 * x + 1 + 33 + x ** 2 - 46 * x ** 5
    elif 120 <= x and x < 203:
        f = 22 * x ** 4
    elif 203 <= x and x < 288:
        f = x ** 6 - 2 * atan(75 * x + 18 * x ** 2) ** 5 - cos(x) ** 7 / 50
    else:
        f = 3 * x ** 4
    return f"
"import math

def main(x):
    if x < 83:
        z = (x - x * x - 89) ** 6 - math.log2(x) ** 2 - 73
    elif 83 <= x < 179:
        z = 22 * (81 * x ** 3) ** 2
    elif x >= 179:
        z = (x ** 3 + 84 * x * x) ** 7 - 70 * math.sin(4) ** 4
    return z"
"import math

def main(y):
    if y < 29:
        return abs(16 + 70 * y ** 2 + y ** 3)
    elif 29 <= y < 51:
        return y + 0.01 + y ** 6
    elif 51 <= y < 123:
        return 69 * y ** 5 + 80 * y ** 4 + 56 * (y / 30 - 1)
    elif 123 <= y < 202:
        return 93 * y ** 15 - pow(math.sin(y), 4)
    elif 202 <= y:
        return y ** 3 + y + pow(math.log2(y), 2)"
"import math

def main(y):
    res = 0
    if y < 16:
        res = 41 * math.sqrt(y) ** 6 + math.floor(7 * y + y ** 2) + 7 * (15 + y ** 3 + (y ** 2) ** 2)
    elif 16 <= y <= 101:
        res = math.ceil(y) ** 4 + y ** 3 + 89 * y
    else:
        res = 29 + math.log(y, 2) ** 6 + math.log(y, 2) ** 4
    return res"
"import math

def main(y):
    if y < 101:
        res = 32 * round(y ** 2 + 53 * y ** 3) ** 3
        return res
    elif 101 <= y <= 113:
        res = (36 * y + 84 + y ** 2 / 27) ** 6
        return res
    elif 113 <= y <= 160:
        res = (0.08 - y ** 3) ** 3 - (66 * y ** 3) ** 7 - 1
        return res
    else:
        res1 = math.atan(1 + y ** 3 + 53 * y) ** 2
        res2 = math.log10(y ** 3 - y ** 2 / 47 - 45 * y) ** 6
        res = res1 + res2
        return res"
"import math

def main(x):
    if x < 60:
        return abs(x) ** 6 - 81 * x ** 2
    if x < 144:
        return x ** 18 - x * 5 - 1
    if x < 228:
        return x ** 6 - 87 - 7 * (52 * x ** 3 - x ** 2) ** 7
    return x ** 3"
"import math

def main(z):
    if z < 105:
        k = 19 * math.ceil(z * z)
        return k
    if z >= 105 and z < 185:
        k = (58 * z + 34 + z * z) ** 7
        k = k - math.log2(z * z / 67 + 14 * z + z * z * z) ** 6 / 23
        k = k - math.cos(z) ** 2
        return k
    if z >= 185 and z < 282:
        k = (35 * z * z * z) ** 2 - z ** 3 - math.floor(z) ** 4
        return k
    if z >= 282:
        k = 34 * z ** 8 + 60 * z * z * z
        return k"
"import math

def main(y):
    if y < 158:
        return (12 * y * y * y) ** 4 + 1 + 42 * y ** 21
    elif 158 <= y < 236:
        return 83 * math.sqrt(y) ** 4
    elif 236 <= y < 253:
        return 3 * math.tan(y * y / 44 - 19 * y - 0.03) ** 5 - 13 * y ** 7
    if y >= 253:
        return 38 * (0.02 - y) ** 7 - 78 * y * y"
"from math import log2, fabs

def main(z):
    if z < 139:
        return (87 * z + z ** 3) ** 5 + fabs(z) ** 4
    elif z < 189:
        return log2(z) + 1
    elif z < 200:
        return 55 * (z ** 2 / 26 + 76 + z) ** 6 - 63 * z ** 7
    else:
        return (91 - 65 * z) ** 7"
"def main(y):
    if y < 52:
        return 64 - y * y * y / 24
    if 52 <= y < 98:
        return 30 * pow(77 * y * y + 1 + 61 * y, 3) - pow(93 * y * y - 1 - y * y * y, 4) - pow(y * y * y - y * y, 7)
    else:
        return 5 * pow(55 - 50 * y * y - y * y * y, 5)"
"import math

def main(x):
    result = 0
    if x < -38:
        result = 56 * (46 * x ** 3 + x ** 2) ** 5
    elif -38 <= x < 27:
        result = 1 + 97 * math.atan(x) + 38 * math.floor(x ** 2 / 83 + x + 35) ** 6
    elif 27 <= x < 45:
        result = (66 * x) ** 7 + 49 * (41 * x ** 2) ** 6 + (78 * x ** 3) ** 2
    elif 45 <= x < 63:
        result = x ** 4
    else:
        result = 49 * x ** 4
    return result
main(-4)"
"import math

def first(x):
    return 67 * x - math.sqrt(x) ** 4

def second(x):
    return 74 * (x ** 2 + 16 * x ** 3 + 89 * x) ** 4 - math.cos(x ** 2 + x ** 3)

def third(x):
    return (x ** 2 + 8 * x ** 3) ** 5 - x ** 7 / 79

def fourth(x):
    return x ** 4

def main(x):
    if x < -39:
        return first(x)
    elif -39 <= x and x < 48:
        return second(x)
    elif 48 <= x and x < 76:
        return third(x)
    elif x >= 76:
        return fourth(x)"
"import math

def main(z):
    if z < 36:
        res = z + 55 * pow(23 * z - z ** 3 - 1, 5)
    elif z >= 36 and z < 113:
        res = z ** 3 / 78 + 11 * z * z
    elif z >= 113:
        res1 = 82 * pow(6 * z, 6)
        res2 = 42 * pow(z + 80 * z ** 3 + 10 * z * z, 4)
        res3 = 65 * pow(math.log10(z * z), 2)
        res = res1 - res2 - res3
    return res"
"import math

def func(x):
    if x < 91:
        result = 49 * math.atan(x) ** 4 - math.cos(x)
    elif x < 149:
        result = x ** 4 - 23 * x ** 7
    else:
        result = (34 + 6 * x + x ** 2) ** 5 / 88 - (x ** 3 - x ** 2 - x) ** 2
    return result

def main(x):
    result = '%.2E' % func(x)
    return float(result)
main(159)"
"import math

def main(z):
    if z < 37:
        return z ** 10
    elif 37 <= z < 50:
        return 1 - 39 * z ** 14
    elif 50 <= z < 85:
        return z ** 3 - 37 - (z * z - 1 - z) ** 2
    elif 85 <= z < 160:
        return 23 * math.sin(z) ** 6
    elif z >= 160:
        return z ** 4 - 98 * math.cos(z) ** 6
main(-0.96)"
"import math

def main(x):
    if x < 149:
        return 53 * x ** 5
    if 149 <= x < 227:
        return 18 * x ** 3 - 10
    if x >= 227:
        return 31 * x ** 6 + 64 * x + (83 * x - x * x / 84) ** 5
main(228)"
"import math

def main(x):
    if x < -25:
        res = 60 * math.exp(x) ** 5
    if x >= -25 and x < 28:
        res = (x ** 3 - x / 30 - 14 * x ** 2) ** 4 + (x ** 3 / 92 + x ** 2 + 47) ** 3 + 17
    if x >= 28:
        res = (22 * x ** 2) ** 4 + 79 * (1 - 83 * x ** 3)
    return res"
"from math import *

def main(x):
    if x < 92:
        return 1 + x / 17 + x ** 6
    if 92 <= x < 107:
        return 41 * (34 * x ** 2 - x ** 3 - 31 * x) ** 2 + 17 * x ** 6
    if 107 <= x < 173:
        return x ** 7 - 91 * x - 81 * (68 * x - x ** 2) ** 3
    if 173 <= x < 272:
        return 24 * x ** 7 - 21 * x ** 5
    if x >= 272:
        return 78 * x ** 2 - 62 * (44 + 25 * x)"
"def main(y):
    if y < 143:
        return 46 * y + 5 * y ** 7
    elif y < 172:
        return 25 * (y ** 3 + y ** 2 + 89) ** 7 + 1 + y ** 3 + 4 * y
    else:
        return 34 + 56 * (93 + y ** 3) ** 7"
"import math

def main(y):
    m = 0
    if y < 63:
        m = (1 + 26 * y ** 2 + 31 * y ** 3) ** 5
    if 63 <= y and y < 144:
        m = 74 * y
    if 144 <= y and y < 240:
        m = abs(y) ** 4 - math.log10(y) ** 3 - 34
    if 240 <= y and y < 304:
        m = 1 + math.log2(15 * y ** 3) ** 6
    if y >= 304:
        m = y ** 15 / 27
    return m"
"import math

def main(z):
    if z < -53:
        return (69 * z ** 2 - z - 47) ** 2
    elif -53 <= z < 42:
        return 95 * (76 + 67 * z ** 2) ** 2 + math.exp(z) ** 4 + z ** 5 / 45
    else:
        return 78 + 54 * (z ** 3 - 86 * z ** 2) ** 5"
"import math

def main(y):
    if y < 53:
        return (y ** 3 / 80 + 76 * y) ** 4
    elif 53 <= y < 78:
        return 95 * abs(y) ** 2 - 98 * math.sqrt(y) ** 4 - 61 * y ** 3
    else:
        return 24 * (94 * y ** 3) ** 6"
"import math

def main(x):
    if x < 169:
        return x ** 4 + x ** 5 + abs(x)
    elif 169 <= x < 217:
        a = 95 * math.log10(1 + x ** 3 / 33 + 20 * x * x) ** 5
        return 63 * (37 * x) ** 7 + a + 67 * (x * x - x)
    elif 217 <= x < 246:
        return x ** 3 / 9 - x ** 6 - 61 * x ** 5
    elif x >= 246:
        return 73 * x ** 6
main(252)"
"import math

def main(x):
    if x < 12:
        y = 69 * x
        y = y - pow(x, 3) / 46
        c = 72 - pow(y, 4)
    if x >= 99:
        c = 18 * pow(math.log(x), 4) - pow(x, 3)
    if x >= 12 and x < 99:
        c = math.log10(x / 25 + x * x / 56) - pow(x, 6)
    return c"
"def main(y):
    from math import atan
    if y < 42:
        return 1 - (y + y * y / 40 + y * y * y / 5)
    elif y < 71:
        return 83 * y * y * y
    else:
        return y * y * y - 16 * pow(atan(y), 2) - pow(y, 7)"
"def main(z):
    if z < -34:
        f = 92 * (56 * z + 1) ** 7 - z ** 12 / 24
    elif -34 <= z < -1:
        f = z ** 7 + 80 * (1 + 12 * z + z ** 3) ** 5
    else:
        f = 3 * (43 * z + z ** 2 + z ** 3) ** 6
    return f"
"import math

def main(z):
    if z < 92:
        result = z / 82 - 34 * math.cos(z ** 2 / 17 + 75) ** 7 - (z ** 3 / 25 - 95 * z - z ** 2 / 37) ** 5 / 13
    elif 92 <= z < 119:
        result = (63 * z - z ** 3) ** 6 / 14
    elif 119 <= z < 171:
        result = 1 - math.log(z) / 74
    else:
        result = 35 * (62 * z) ** 4 + 37 * (60 * z ** 2) ** 7 + z ** 3
    return result"
"import math

def main(z):
    if z < 37:
        result = 96 * z ** 4 + z ** 6 + 91 * z ** 3
    elif 37 <= z < 114:
        result = z ** 18 / 10
    elif 114 <= z < 171:
        result = 26 * z ** 7 + z ** 3 / 78
    elif 171 <= z < 193:
        result = 55 * z - math.log(z, 10) ** 7
    else:
        result = (12 * z ** 3) ** 6 - 40 * z ** 7 - 60 * abs(z)
    return result"
"import math

def main(x):
    res = 0.0
    if x < 7:
        res = math.exp(63 * x ** 3) ** 4
    if 7 <= x < 65:
        res = 12 * math.ceil(x) ** 6 - 14 * x ** 5
    if 65 <= x < 155:
        res = x ** 15 / 53 + 95 * math.exp(x) ** 4 + 4 * x ** 7
    if 155 <= x < 189:
        res = (x ** 2 + 68 + x) ** 6 / 42
    if x >= 189:
        res = 11 * (73 * x) ** 4
    return res"
"def main(x):
    if x < 145:
        result = (46 * x ** 3 + 64 * x ** 2 + 74 * x) ** 3 / 7
    elif x < 182:
        result = 56 * (47 * x ** 2 + 86 * x ** 3) ** 4 + 1 + x ** 7
    elif x < 237:
        result = x ** 2 - 1 - x + x ** 5
    else:
        result = x ** 2 - 8 * (x ** 3 - 61 * x ** 2 - 1) - (85 * x - 1) ** 3
    return result"
"def main(z):
    if 204 <= z < 280:
        func_value = 4 * (z ** 3 / 24) ** 7
    elif 152 <= z < 204:
        func_value = z / 22 + 25 * (1 + z ** 3 / 23) ** 6 + 3 * (65 * z ** 3 - 1 - z ** 2) ** 4
    elif z < 152:
        func_value = 28 * (z + z ** 3) ** 3 + 59 * (15 * z ** 2) ** 6 + z ** 5 / 70
    else:
        func_value = z ** 3 - (82 + 64 * z ** 3 + z ** 2) / 65 - 1
    return func_value"
"import math

def main(y):
    if y < 14:
        result = 17 * pow(y + 50 + pow(y, 2), 5)
        return result
    elif (y >= 14) & (y < 86):
        result = 71 * pow(math.log10(pow(y, 2)), 6) * pow(y, 2) + 84 * pow(33 * pow(y, 2) - 30 - y, 4) + pow(y, 3)
        return result
    elif (y >= 86) & (y < 175):
        result = math.sin(pow(y, 3) - 57 * pow(y, 2))
        return result
    elif (y >= 175) & (y < 222):
        result = 216 * y - 13 * pow(y, 6) - pow(y, 7)
        return result
    else:
        result = 4 + 27 * pow(math.cos(y), 4)
        return result"
"from math import tan

def main(y):
    res = 0
    if y < -4:
        res += y ** 6 + tan(y) + (y + y ** 3 + 1) ** 4
    if 86 > y >= -4:
        res += y ** 6 + 37 * (4 * y ** 2) ** 5 + 81 * abs(y)
    if 141 > y >= 86:
        res += 14 * y ** 4 - (64 * y ** 3 - 3 - y ** 2) ** 7
    if y >= 141:
        res += 84 * (84 * y - y ** 3) ** 4 + (y ** 2 - 37 * y ** 3 - 0.01) ** 3 / 33
    return res"
"def main(x):
    c = 0
    if x < 43:
        c = (0.02 + 95 * x ** 3) / 55 - 48 * x ** 5 - 77 * x ** 4
    if 43 <= x:
        if x < 131:
            c = 29 * (x ** 3 + 1) ** 3 + 18 * (x ** 2 - 24 * x) ** 6
    if x >= 131:
        c = 1 - (62 * x - 1) ** 2 / 88 - (89 * x ** 2) ** 5
    return c
main(77)"
"import math

def main(y):
    if y < 1:
        return 81 - math.atan(y ** 2 + 21) - y ** 3 / 42
    elif 1 <= y < 53:
        return y ** 6 + (54 * y ** 3) ** 2 + y ** 7 / 64
    elif 53 <= y < 149:
        return (38 * y ** 2 + y ** 3 + 1) ** 2
    elif 149 <= y < 226:
        return math.tan(y) ** 7 - 83 * math.floor(y) ** 4
    elif y >= 226:
        return 336 * y ** 2 - 1 - 99 * y ** 9
main(56)"
"import math

def main(y):
    if y < 105:
        return (39 * y ** 2) ** 6 / 82
    elif y < 139 and y >= 105:
        return (y ** 3 - y) ** 6
    elif y >= 139:
        return y / 37
main(141)
main(128)"
"def main(x):
    if x < 59:
        f = 94 * (0.03 - x ** 2 - x ** 3) ** 7
    if x >= 59 and x < 158:
        f = (57 * x ** 3) ** 6
    if 158 <= x and x < 257:
        f = (x / 49 - 72 * x ** 2) ** 2 - 1
    if x >= 257:
        f = x ** 5
    return f
main(35)"
"from math import pow, sin, cos

def main(x):
    if x < 155:
        return pow(x, 7) / 84 + pow(x, 3) + 24 * pow(cos(87 * pow(x, 2) - x - 1), 4)
    elif x < 215:
        return 73 * pow(0.01 - x, 4) - 1
    elif x < 231:
        return pow(x, 5) / 39 + pow(x, 4) / 94 - x
    elif x < 262:
        return pow(sin(x), 7)
    else:
        return x + 10 * pow(x, 3)"
"import math

def main(x):
    if x < -25:
        return 60 * math.pow(84 * math.pow(x, 2), 6)
    elif -25 <= x < -9:
        return x ** 3 + 1 + math.pow(x ** 3 - 70 * x ** 2, 5) / 83
    elif -9 <= x < 80:
        return math.pow(1 + x ** 3, 3)
    elif x >= 80:
        return x - 1"
"import math

def main(x):
    if x < -42:
        f = pow(math.sin(pow(x, 2) + x + 84), 5)
    elif -42 <= x < 44:
        f = pow(x, 5)
    elif 44 <= x < 70:
        f = 19 * pow(x, 5) - (88 * pow(x, 2) - 2) - pow(x + pow(x, 3) / 54 + 75 * pow(x, 2), 7)
    elif 70 <= x < 140:
        f = pow(x, 5) - 50 * pow(x, 7)
    elif x >= 140:
        f = 58 * pow(x, 2)
    return f"
"import math

def main(z):
    if z < 87:
        res = pow(z, 7)
    elif z < 133:
        res = 27 * pow(z, 3)
    else:
        res = 54 * z
    return res"
"import math

def main(y):
    if y < 60:
        return (y ** 2 - 1) ** 3 + 55 * y ** 2
    elif 60 <= y < 140:
        return 4 * (y + 49) - 43 * (y / 37 - 46) ** 6 - 1
    elif 140 <= y < 217:
        return 62 * math.log10(1 + y + y ** 2)
    elif y >= 217:
        return 71 * y ** 6 - 73 * (y ** 3 / 34)"
"def main(y):
    if y < 8:
        return 93 * y * y - 85 * (9 - 76 * y * y * y) ** 3
    elif y >= 106:
        return 32 * y ** 6 - (93 - 43 * y ** 3 - 82 * y) ** 2 - (57 * y) ** 7
    else:
        return y * y"
"import math

def main(x):
    if x < -45:
        return math.log1p(1 - 97 * x ** 3) ** 2 + x ** 5 / 75 + 0.02
    elif x < 27:
        return (2 * x - 34 * x ** 2) ** 2 + math.sin(x) ** 7
    elif x < 44:
        return 0.01 + 17 * math.cos(x) ** 5 + x ** 3
    elif x < 111:
        return 42 * x / 65 - math.tan(x) ** 7
    else:
        return (37 * x ** 2 + x ** 3) ** 5 - 86"
"import math

def main(y):
    if y < 11:
        result = math.floor(y) ** 6 - math.atan(y) ** 5 - math.floor(y) ** 3
    elif 11 <= y < 45:
        result = 31 * y ** 4 - 17 * math.sqrt(y * y * (82 * y - 1)) - 27 * pow(50 * y + 93 * y * y, 6)
    elif 45 <= y < 141:
        result = 79 - (22 + y * y)
    else:
        result = 76 * pow(27 - y * y * y / 3 - y * y / 85, 7) - 64 * pow(y ** 3 + y, 3)
    return result"
"import math

def main(y):
    if y < 34:
        return math.log2(80 * y ** 3 - 16) ** 5 + math.log(49 + y ** 2 + 48 * y) ** 7
    elif y >= 34 and y < 81:
        return y ** 3 / 27
    elif y >= 81 and y < 141:
        return 1 - y / 20
    elif y >= 141:
        return 0.01 - 54 * math.sqrt(y) ** 5 - 91 * math.tan(y) ** 4"
"from math import cos

def main(z):
    if z < -30:
        return 0.5 - 89 * z ** 5
    if z < 69:
        return 260 * z ** 3 + cos(75 * z ** 3 - 51 * z ** 2 - 94 * z) ** 5 + 5 * z ** 7
    return z ** 3 + 1 + z ** 2 / 54"
"def main(z):
    res = -13
    if z < 4:
        res = (z + z ** 2) ** 7 + 89 * z
    if 4 <= z < 96:
        a = z ** 4 - (39 + 94 * z + z ** 2) ** 3
        b = 93 * (z ** 3 / 43) ** 7
        res = a - b
    if 96 <= z < 162:
        res = 2 * z ** 7
    if z >= 162:
        res = z ** 2
    return res
main(180)"
"import math

def main(x):
    answer = 0
    if x < 39:
        answer = x ** 3
    elif 39 <= x < 113:
        answer = 40 * math.log10(76 + 75 * x ** 3) ** 5 - 88 * (0.02 + x ** 2 / 99 + 90 * x ** 3) ** 2 - 25
    elif x >= 113:
        answer = x ** 18 / 70
    return answer"
"import math

def main(y):
    res = 0
    if y < 103:
        res = (y - y ** 3) ** 4
    elif y >= 103 and y < 166:
        res = (y ** 2 - 4) ** 4
    elif y >= 166 and y < 237:
        res = y - 82 * (12 * y ** 3) ** 2
    elif y >= 237 and y < 297:
        res = 84 * (58 * y * y + 64 * y ** 3) ** 4 + y ** 4
    else:
        res = 93 * abs(y - 61 * y ** 3 - y ** 2) ** 3 + y ** 7 / 41 + 87 * log(y, 2)
    return res"
"import math

def main(x):
    if x < -52:
        res = math.pow(math.cos(x + math.pow(x, 3) + 66), 4)
    elif -52 <= x < 22:
        res = 80 * math.pow(13 * math.pow(x, 3) - 44 * x * x - x, 7) - math.pow(x, 4)
    else:
        res = math.pow(math.log(55 * x * x + 21 * x, 10), 5)
    return res"
"import math

def main(y):
    if y < 81:
        a = math.pow(y, 3) + 99 * y - math.pow(0.03 + 28 * y * y + y, 2) / 43 - 37
    elif y >= 161:
        a = 27 * math.pow(y ** 3 / 42 + y + 1, 3)
    else:
        a = y ** 4
    return a"
"def main(x):
    if x < 74:
        return x ** 2 - 17 * x ** 6 - 62
    elif 74 <= x < 139:
        return (0.02 + x ** 2 + 9 * x) ** 5 - (x - 71 * x ** 2 - x ** 3) ** 3
    elif 139 <= x < 213:
        return 10 * x ** 3
    elif 213 <= x < 265:
        return (71 * x ** 3 + x + 60) ** 7
    elif 213 <= x < 265:
        return 93 * x ** 6 + 35 * x ** 3
    return 93 * x ** 6 + 35 * x ** 3"
"from math import *
import math

def main(z):
    if z < 10:
        return (z + z ** 3) ** 4
    if 10 <= z and z < 82:
        return 22 * (z ** 3 / 74) ** 5
    if 82 <= z and z < 116:
        return (58 * z + 29 + 71 * z * z) ** 5 - 1
    if 116 <= z:
        return 98 - (z ** 3 - 80 - z) ** 4 - (z * z - 68 * z ** 3) ** 6 / 77
    return z"
"import math

def main(z):
    if z < 2:
        f = 59 * z ** 6 - z ** 4 - abs(z ** 3 - 19 * z ** 2 - 24)
    elif 2 <= z and z < 93:
        f = math.cos(z) ** 4 - 1
    elif 93 <= z and z < 161:
        f = math.log(5 * z, 10) / 83 + 80 * z ** 9
    elif 161 <= z and z < 257:
        f = math.log(z ** 3 + 86 + z, 10) - 23 * math.floor(z) ** 6
    else:
        f = (72 - 86 * z ** 3) ** 5 / 95 - 89 * z ** 6
    return f"
"def main(x):
    if x < 119:
        f = x ** 4 / 63 - 1
    elif 119 <= x < 214:
        f = 90 * x + 1
    else:
        f = x ** 3
    return f"
"import math

def main(z):
    if z < 7:
        return 72 * math.atan(z) ** 7 + 70
    if z < 52:
        return 1 + abs(72 * z ** 2 - z ** 3 - 1) ** 7 + math.tan(25 * z ** 3 + 1 + z ** 2)
    if z < 106:
        return z ** 3 - math.cos(z ** 3 - z ** 2 - 1) ** 5
    if z < 134:
        return 68 * (40 - 64 * z ** 2) ** 5
    return 68 - (42 * z - 99) ** 4 - (z + z ** 3) ** (1 / 2) / 1"
"import math

def main(x):
    if x < -8:
        return 52 + 25 * x ** 7
    elif -8 <= x < 40:
        return 46 * x ** 12 + 52 * (18 * x - 76 * x ** 2 - 28 * x ** 3)
    elif x >= 40:
        return math.exp(x) ** 3"
"from math import exp, log2

def main(y):
    if y < 6:
        return 85 * y ** 4 - 14 * log2(y + 48 * y ** 2 + 24) - (12 * y - 11 * y ** 3 - y ** 2) ** 7
    elif y < 88:
        return y ** 7
    elif y < 170:
        return 32 * exp(y) ** 2 + 1 + 64 * y ** 6
    else:
        return 45 * y ** 6 - y ** 2"
"import math

def main(x):
    if x < 36:
        if x < -16:
            return 49 * x ** 6 + (x / 59 - x ** 2 - 0.02) ** 7 / 51
        else:
            return x ** 6 / 72
    elif x < 108:
        return (70 + x ** 3) ** 5 + 13 * math.tan(x) ** 6
    else:
        return 10 * x ** 7"
"from math import log, floor

def main(y):
    if y < 32:
        res = 83 * (16 * y ** 3 + 1) + y / 24 + (y / 92 + 35 * y ** 2 + 1) ** 5
        return res
    elif 32 <= y < 63:
        res = log(y)
        return res
    elif 63 <= y < 78:
        res = y ** 7 - floor(25) ** 6
        return res
    elif 78 <= y < 159:
        res = 64 * y ** 4
        return res
    elif y >= 159:
        res = floor(y ** 2) ** 6 + 3 * y ** 7 + 26 * y ** 2
        return res"
"import math

def main(y):
    if y < 152:
        return 58 * math.sqrt(y) ** 4 + 11 * (49 * y ** 2 - 88 * y - 14 * y ** 3) ** 6
    if 152 <= y < 174:
        return 3 * math.cos(y) ** 7
    if 174 <= y < 221:
        return 99 - (43 * y + 1 + 50 * y ** 3) - 83 * math.sin(y ** 2 + y ** 3 + 0.01) ** 2
    if 221 <= y < 233:
        return math.asin(y) ** 6 - 34 * (91 * y ** 3 + 29 * y ** 2 + 49) ** 3 - abs(y) ** 5
    if y >= 233:
        return math.log(41 * y ** 2 - 16 * y - 0.01, 2) ** 5"
"import math

def main(z):
    if z < 182:
        f = 68 + 58 * pow(z, 3) - 76 * pow(math.log10(86 * z), 2) - pow(z, 7)
    elif z < 197:
        f = pow(z, 3) / 8
    else:
        f = pow(math.fabs(z + 1 + z * z), 6)
    return f"
"import math

def main(x):
    if x < -77:
        return math.log(52 * x ** 2) ** 7
    elif -77 <= x < -36:
        return (32 + x ** 2 + 62 * x) / 23
    elif -36 <= x < 40:
        return x ** 6 / 69 + x ** 4 / 41 + 84 * math.atan(1 + x + 61 * x ** 3) ** 3
    elif x >= 40:
        return 14 * x + 1 + (x + x ** 2) ** 3"
"import math

def main(x):
    if x < 6:
        return 13 * math.tan(x) ** 4 + x ** 6
    elif x >= 6 and x < 58:
        return 0.01 - abs(8 * x) ** 6 - 74 * (28 + 18 * x ** 2) ** 2
    elif x >= 58 and x < 114:
        return x ** 6
    else:
        return 93 * x ** 7 + 67
main(-12)"
"def main(z):
    if z < -13:
        return float('%.2e' % (z ** 5 + 19 * z ** 4))
    elif -13 <= z < 63:
        return float('%.2e' % (90 * (21 + z ** 3)))
    elif 63 <= z < 75:
        return float('%.2e' % (z ** 3 + z ** 2 + 27 - z ** 2))
    else:
        return float('%.2e' % (z ** 6 - 57 * (58 * z) ** 3))"
"import math

def main(x):
    if x < 79:
        return float('{:.2e}'.format(51 + 45 * x ** 3))
    elif 79 <= x < 131:
        return float('{:.2e}'.format(math.sin(x) ** 5 - 76 * math.tan(57 * x ** 3 + x + x ** 2 / 73)))
    else:
        return round(float('{:.2e}'.format(math.log1p(x - 1) + 60 * math.exp(x - x ** 2 - x ** 3) ** 4)), 2)
main(175)"
"import math

def main(z):
    if z < 78:
        ans = z - 50 * z ** 2 - 69 * z ** 6
    elif 78 <= z < 166:
        ans = z ** 5 / 81 - 1 - 13 * math.log(z) ** 6
    elif 166 <= z < 242:
        ans = 58 * z ** 2 + (z ** 3 + z) ** 3
    elif 242 <= z < 292:
        ans = 35 - 89 * z ** 5
    elif z >= 292:
        ans = 30 * (89 * z ** 2 + z / 88 + 78) ** 2 + 38
    return ans"
"def main(y):
    if y < 200:
        return y ** 4
    if 200 <= y < 288:
        return (y ** 3 - y / 55) ** 5 - 12 * y ** 7
    if 288 <= y < 379:
        return 31 * (y ** 2 - 91 * y) ** 3 - (94 - 78 * y) ** 2
    if y >= 379:
        return (y ** 3 + 71 * y ** 2 + y) ** 6 + 67 * (y - 0.004)"
"import math

def main(y):
    if y < 124:
        res = 14 * math.pow(16 * y + 52 * y * y, 2) - 78 * math.pow(82 * y * y * y - y - y * y, 5)
    elif 124 <= y < 150:
        res = 66 * math.pow(math.log10(y * y * y + y * y), 5)
    else:
        res = 98 * y * y * y * y
    return res"
"import math

def main(y):
    if y < 85:
        return (29 * y ** 3 + 94 * y + 4 * y ** 2) ** 6 - pow(y, 7)
        -(pow(5 * pow(y, 3) + y, 5) / 9)
    if 85 <= y < 140:
        return pow(y, 4) - 1 - 11 * pow(y, 6)
    if 140 <= y < 219:
        return pow(y / 27 + pow(y, 2) + y ** 3 / 67, 7) - pow(66 * pow(y, 3), 4)
    if y >= 219:
        return 40 * pow(y, 7) + y ** 3 / 71"
"import math

def main(y):
    if y < 165:
        a = 54 * pow(math.log(12 * pow(y, 3) - y), 2)
        b = pow(y, 3) + y / 90 + 88 * pow(y, 2)
        c = a + pow(b, 4) + pow(y, 5) / 95
        return c
    if 165 <= y <= 202:
        c = 1 + pow(math.sin(y), 5) + 96 * pow(abs(y), 2)
        return c
    if 202 <= y < 263:
        c = 25 * pow(y, 14) - pow(math.cos(9 * pow(y, 2)), 5)
        return c
    if y >= 263:
        c = 85 * pow(y, 3) + 61 * (pow(y, 2) - 53)
        return c"
"from math import exp, sin, atan

def main(y):
    if y < 86:
        res = y ** 5 + exp(y) ** 2 + 58 * sin(y ** 3)
        return res
    elif 86 <= y < 105:
        res = 70 * (4 + y) ** 3
        return res
    elif 105 <= y < 196:
        res = y ** 6
        return res
    elif 196 <= y < 229:
        res = 1 + 29 * atan(y) ** 5 + (y ** 2 - 0.02 - 70 * y) ** 6
        return res
    elif y >= 229:
        res = (y ** 3.0 + 76 + 34 * y ** 2) ** 7 - y ** 3 - 82 * (25 * y ** 3 + y ** 2 + 42 * y) ** 4
        return res"
"import math

def main(x):
    if x < 41:
        return 65 * x ** 4 - x ** 14 - (96 * x ** 2) ** 2
    elif 41 <= x < 81:
        return 297 * x ** 2 + (73 - x ** 3) ** 3 + 31 * math.log(x, 10) ** 4
    else:
        return 94 * math.fabs(x) - 63 * (27 * x - 28) ** 5"
"import math

def main(y):
    if y < 96:
        ans = 64 + y ** 7 + math.log(y) ** 3
    elif 96 <= y and y < 123:
        ans = 84 * math.atan(y) ** 3
    elif 123 <= y and y < 192:
        ans = abs(57 * y ** 2 - 13) ** 2 / 45 + y ** 14 + y + 34 * y ** 3
    else:
        ans = y ** 6 + 0.04
    return ans"
"def main(z):
    if z < -85:
        x = (54 - 63 * z ** 3 - z) ** 6
    elif -85 <= z < -33:
        x = 47 * (55 * z ** 2) ** 4
    elif -33 <= z < 57:
        x = z ** 2 / 97 + z ** 7
    else:
        x = 13 * (z ** 3 / 17) ** 4
    return x"
"import math

def main(x):
    if x < 135:
        t1 = (24 * x ** 2) ** 5
        t2 = (8 - x) ** 3 / 54
        f = t1 - t2 - 69 * math.log(7, 10) * (38 * x ** 2 + 83 * x)
        return f
    elif x >= 135 and x < 168:
        f = 81 * (62 * x ** 3 + 92 * x + 18 * x ** 2) - 96 * x ** 2 - 81
        return f
    elif x < 257 and x >= 168:
        f = 63 + 26 * x
        return f
    elif x < 336 and x >= 257:
        f = 14 * x ** 4 + 3564 * x ** 3
        return f
    else:
        f = 7 * (x - 39 * x ** 3) ** 6
        return f"
"import math

def main(x):
    if x < 151:
        return 80 * x ** 3 - (x - 82 * x ** 2) ** 7
    elif 151 <= x < 208:
        return x ** 3 - 55 * x ** 6
    elif 208 <= x < 249:
        return (x / 6 + 42 + 36 * x ** 3) ** 4
    else:
        return 70 * (0.02 + 38 * x + x * x) ** 2 + x + x ** 7 / 72"
"from math import *
import math
import cmath

def main(z):
    if z < 149:
        return 51 * z * z * z * z * z * z + 1
    elif 149 <= z and z < 190:
        return 7 * math.log10(0.01 - z - z * z * z) ** 3 + math.cos(z - 1 - z * z) ** 5
    elif 190 <= z and z < 213:
        return 97 * math.cos(z) ** 4 + math.cos(z - z * z * z - 17 * z * z) ** 7
    elif 213 <= z and z < 293:
        return math.sin(z * z + 14 * z + 65 * z * z * z) ** 2 - z * z * z * z * z * z * z - 1
    elif z >= 293:
        return 33 * (1 - 60 * z - z * z) ** 3"
"def main(y):
    if y < 100:
        f = 93 * y + (1 - 3 * y ** 2 - y) ** 4
    elif y >= 100 and y < 133:
        f = 12 * y ** 4
    elif y >= 133 and y < 156:
        f = y ** 4
    elif y >= 156:
        f = y + 54 * (74 * y) ** 3
    return f"
"import math as m

def main(x):
    if x < -30:
        return 65 * m.pow(1 - x, 7)
    elif x >= -30 and x < -9:
        return m.pow(x, 7)
    elif x >= -9 and x < 40:
        return m.pow(m.fabs(0.01 + x / 65 + 34 * x * x), 6) + 89 * x * x
    else:
        return m.pow(m.pow(x, 3) / 19 + 3, 5) / 58 + 52 * m.pow(x, 3) + m.pow(x, 6) / 80"
"import math

def main(z):
    if z < -10:
        return 99 * z ** 2 - 1 + (7 * z) ** 7 + 61 * abs(66 - 89 * z) ** 4
    elif z >= -10 and z < 19:
        return (z - 24 - z ** 3) ** 5 / 46 - z ** 2
    elif z >= 19 and z < 119:
        return 78 * z ** 5 - 89 * z ** 4 - math.log2(22 * z ** 2) ** 4
    else:
        return 1 + z ** 7"
"import math

def main(z):
    if z < 62:
        return math.cos(z ** 3 - z ** 2 - 5) ** 3
    elif 62 <= z < 92:
        return 92 * z ** 3 - 73 - 18 * math.log10(z)
    elif 92 <= z < 130:
        return math.fabs(z) ** 5 / 43 - (z - z ** 2 - 0.14) ** 7 - z ** 12
    elif z >= 130:
        return (z - z ** 2) ** 4
    else:
        return 1"
"import math

def main(y):
    if y < 132:
        return y ** 3
    elif y >= 132 and y < 163:
        return y ** 7
    elif y >= 163 and y < 226:
        return (49 * y ** 3 - 15 * y) ** 3 - 1 - y ** 7
    elif y >= 226 and y < 318:
        return 62 - math.log10(33 * y + 1 + 90 * y ** 2) ** 3
    else:
        return y ** 7 - 1"
"import math

def main(z):
    if z < -27:
        return 52 * z - z ** 5
    elif -27 <= z < 29:
        return 75 * (z / 38 + 93) ** 2 + 7 * z
    elif 29 <= z < 45:
        return 21 * z ** 6 - 88 * (98 * z + 29 * z ** 2) ** 7 - 98 * (1 + 27 * z) ** 2
    elif 45 <= z < 102:
        return z ** 6 - 1 - abs(z) ** 2 / 98
    elif z >= 102:
        return 75 * math.tan(1 + 61 * z) - z ** 7"
"import math

def main(y):
    f = None
    if y < 25:
        f = 86 * y
    elif y < 45:
        f = (y ** 2 + y + y ** 3 / 31) ** 2 + 2 * y ** 6
    elif y < 59:
        f = 75 * math.atan(y) ** 6 + 93 + y ** 4
    elif y < 106:
        f = 83 * y + math.log2(64 * y ** 3) ** 6 / 21
    else:
        f = y ** 5 - (71 * y ** 3 + 80 * y + y ** 2) ** 2
    return f"
"from math import *

def main(x):
    if x < 139:
        fun = 55 * pow(48 * x, 2)
    elif 139 <= x and x < 199:
        fun = pow(x, 6) - 95 * pow(x - 18, 3) - 91 * pow(sin(x), 5)
    elif 199 <= x and x < 224:
        fun = pow(x, 6)
    elif 224 <= x and x < 244:
        fun = 66 * pow(1 + 28 * pow(x, 3), 5)
    elif x >= 244:
        fun = 55 * x - 8 * pow(x, 6) - 74
    return fun"
"import math

def main(x):
    if x < 42:
        return 44 * (30 * x - 1 - x ** 2) ** 5 - 21 * math.tan(x) ** 4 * (x ** 3 + x ** 2 + 1) - x ** 3
    elif x >= 83:
        return 24 * (72 * x) ** 6
    else:
        return 61 * x ** 7"
"def main(x):
    from math import log, atan
    ans = 0
    if x < 83:
        ans = x ** 4 + abs(x) ** 7 + log(87 * x) ** 5
    elif 83 <= x < 129:
        ans = 88 * atan(x) ** 6 + x ** 10 / 56
    elif 129 <= x < 207:
        ans = (x ** 3 + 66 * x ** 2 + 1) ** 2
    elif 207 <= x < 247:
        ans = 69 * (29 * x + 9 * x ** 2 + 1) ** 4 - 1
    else:
        ans = 78 * x ** 12
    return ans"
"import math

def main(z):
    if z < 92:
        x = 1 + 84 * math.exp(z) ** 7 + z ** 3 / 98
    elif z < 186:
        x = z ** 3 + 38
    elif z < 264:
        x = math.tan(54 * z) ** 2 - (z + 64 * z ** 2) ** 5 - 36 * z ** 7
    else:
        x = 70 * math.log2(z) ** 3 - 68 * z ** 7 - 65 * z
    return x"
"import math

def main(z):
    if z < 90:
        return 95 * z + 89 * math.fabs(z) ** 4
    elif 90 <= z < 129:
        return math.sin((z ** 3 - 18 * z ** 2 - z) * math.pi / 180) ** 7 / 46 - 34 * z ** 6 - z ** 8
    elif 129 <= z < 223:
        return 1 - (11 * z ** 2 - 74 * z ** 3) ** 2
    else:
        return (17 * z + 22) ** 6 - (z ** 2 - 5 * z ** 3) ** 5"
"import math

def main(z):
    if z < -10:
        return 43 * pow(math.acos(z), 5) - 85 * z - 27 * pow(math.tan(z), 6)
    if -10 <= z < 20:
        return 60 * pow(z * z + 1, 2)
    if 20 <= z < 84:
        return 36 * pow(pow(z, 3) / 72 - 1 - z / 55, 3) + 70 * pow(pow(z, 3) / 93, 5) + 1
    if z >= 84:
        return 91 * z * z * z * z + pow(z, 7)"
"def main(z):
    if z < 177:
        res = 75 * z ** 4
    if 177 <= z < 262:
        res = 38 * z ** 6 + 0.01
    if 262 <= z < 361:
        a = 9 * (28 * z ** 2 - z ** 3 - z) ** 4
        b = (z - z ** 2 - 0.01) ** 5 + 54 * z ** 2
        res = a + b
    if 361 <= z < 425:
        res = z ** 2 / 32 - 59 * (z - 63 * z ** 2) ** 5 - 1
    if z >= 425:
        res = z ** 6 - (62 * z ** 2) ** 5 - z
    return res
main(243)"
"from math import sin, log

def main(y):
    if y < 99:
        return y
    elif y < 184:
        return pow(sin(y), 5) / 32
    elif y < 275:
        return pow(y, 6) / 87 - pow(y, 21) - 72 * pow(abs(pow(y, 2)), 3)
    elif y < 299:
        return pow(51 * y + 1 + 76 * pow(y, 3), 7) * 83 + pow(log(y), 2) + 74
    else:
        return pow(y, 2) + 78 + pow(y, 4) * 49"
"import math
from math import *

def main(z):
    if z < -6:
        a = 38 * z ** 7
        return a
    elif -6 <= z < 91:
        a = z ** 3 + 13 * z ** 4 + 55 * z
        return a
    else:
        a = z ** 6 + 5684 * z
        return a
main(-83)"
"from math import *

def main(x):
    if x < 85:
        fx = 65 * x ** 4 + (90 * x - x ** 3) / 57
        return fx
    elif 85 <= x < 111:
        fx = 96 * x - 14 * (92 * x ** 2) ** 2 - x ** 4
        return fx
    elif 111 <= x < 150:
        fx = 34 * cos(x ** 2 / 46 + 64 * x + 1) ** 7
        return fx
    else:
        fx = x + 4 * (x ** 2 / 63 - x ** 3 - 11) + x ** 3
        return fx"
"from math import sin, atan

def main(x):
    if x < 38:
        return 45 * atan(96 * x) ** 7 - x - 0.02
    elif x < 128:
        return 38 * sin(x) ** 6 + 26 * abs(x) ** 7 + x ** 2
    elif x < 159:
        return x ** 2 + 52 * x ** 5 + x ** 3
    else:
        return 20 * (x / 39 + 11 * x ** 3) ** 3 - x ** 14"
"import math

def main(z):
    if z < 86:
        return math.log(z) ** 2 + z ** 12
    elif z >= 86 and z < 113:
        return math.log10(z) ** 5 - (z ** 2 * 85 - z ** 3 * 46) ** 7
    elif z >= 113 and z < 144:
        return 1 + 46 * (z + z ** 2 / 97)
    else:
        return z ** 0.5 * 21"
"import math as m

def main(x):
    if x < 71:
        return m.atan(x) ** 6
    if 71 <= x < 118:
        return 65 * (x ** 3 - x ** 2 - 8 * x) ** 2 - (80 * x - x ** 3)
    if 118 <= x < 209:
        return 40 * (76 * x - x ** 2 / 51 - x ** 3) ** 5
    if 209 <= x < 301:
        return x ** 3 + 48 * x
    if x >= 301:
        return 76 * (15 * x - 1 - x ** 3) ** 7 - 51 * x"
"def first(z):
    return abs(z) ** 7

def second(z):
    return 67 + z ** 3 / 88 + 21 * (z - 40 * z ** 3 - 1) ** 7

def third(z):
    return (1 + z ** 3 + z / 9) ** 3

def fourth(z):
    return 86 * z ** 5 + 1

def fifth(z):
    return z ** 2 / 25 - (58 - z ** 2 - z) ** 5

def main(z):
    if z < -68:
        return first(z)
    elif z >= -68 and z < 18:
        return second(z)
    elif z >= 18 and z < 98:
        return third(z)
    elif z >= 98 and z < 140:
        return fourth(z)
    else:
        return fifth(z)"
"import math as math

def main(y):
    if y < 59:
        a = pow(math.sin(pow(y, 3) + 24 + y / 7), 5) - 41 * pow(pow(y, 2) - pow(y, 3), 7)
        return a
    elif y < 81 and y >= 59:
        return 28 * pow(17 * y + 79 + pow(y, 2), 5) - 29 * pow(math.atan(y), 4)
    elif y >= 81 and y < 172:
        return 6 - pow(math.sqrt(y), 6)
    else:
        return pow(y, 3) / 7 - 66 * pow(1 + pow(y, 2), 2) - 92 * pow(y, 6)"
"import math

def main(x):
    if x < 72:
        return 18 * x + 89 * x ** 3 + 49 * x ** 2 - 64 * x ** 5 - 79 * (94 * x ** 3 - x) ** 2
    elif x >= 72 and x < 160:
        return math.tan(1 - 61 * x ** 3 - 48 * x ** 2) ** 5 + 52 * math.fabs(x) ** 2
    elif x >= 160:
        return 1 + 56 * (x ** 2 - x - 1) ** 6 + x ** 5"
"import math

def main(x):
    if x < 118:
        return 83 * (11 * x - 19 - 83 * x ** 3) ** 4 + 82 * math.cos(x) ** 5 + 98 * math.ceil(95 * x ** 2 + 63 + x ** 3 / 40)
    elif 118 <= x < 204:
        return 1 + 36 * math.ceil(x) ** 4
    if x >= 204:
        return math.ceil(x) ** 6 - 25 * (8 * x ** 2) ** 4"
"from math import log10 as l10

def main(x):
    if x < 46:
        return x ** 8 - 10 * x
    if 46 <= x < 60:
        return x ** 2
    if 60 <= x < 130:
        return 23 + x ** 2 + 93 * l10(x ** 2) ** 5
    if 130 <= x < 227:
        return x ** 2 / 40
    if x >= 227:
        return 1 - x / 85"
"import math

def main(z):
    if z < -16:
        return 12 * (30 * z) ** 2 + z ** 7 / 78
    elif -16 < z < 77:
        return 69 * z ** 2
    elif 77 <= z < 169:
        return 70 * math.sin(z) ** 2
    elif z >= 169:
        return 79 * abs(z) ** 4"
"from math import exp, log

def main(x):
    if x < -19:
        return exp(x) ** 5
    elif -19 <= x < 52:
        return 67 * x ** 5 - (x ** 2 + 90) ** 3 - 45 * x ** 4
    elif x >= 52:
        return (54 - 83 * x ** 3) ** 7 - log(x) ** 6"
"import math

def main(x):
    if x < 11:
        return 3 * (pow(x, 3) - x) - pow(math.atan(66 * x), 6)
    if 11 <= x < 75:
        return 19 * pow(x, 5) + 5 * pow(38 * x - 39 * pow(x, 2), 4)
    if x >= 75:
        return pow(x, 6)"
"import math

def main(x):
    if x < 96:
        return 67 * x ** 6 + 33 * abs(x) + 68 * x ** 7
    elif 96 <= x < 147:
        return x ** 7
    elif 147 <= x < 219:
        return 98 * math.floor(x) ** 4 - abs(x) ** 3
    else:
        return 5 - 65 * (87 * x ** 2) ** 4"
"import math

def main(y):
    if y < 132:
        return math.atan(1 - y ** 3 - 50 * y * y) ** 6 - (y ** 3 - y / 35)
    if 132 <= y < 185:
        return 80 * y ** 6
    if 185 <= y < 236:
        return math.floor(y * y + 55 * y) - y ** 7 - 1
    if 236 <= y < 256:
        return 74 * y ** 5
    return y - 45 * y ** 3 - 29"
"import math

def main(z):
    if z < -12:
        x = math.pow(math.sin(z), 5) - 52 * math.pow(43 * z - math.pow(z, 2) / 47 - 39, 3) - z
    elif -12 <= z < 83:
        x = math.pow(math.cos(math.pow(z, 3) + z / 62 + math.pow(z, 2)), 4) + 28 * math.pow(math.pow(z, 2) - 1 - z, 6)
    elif 83 <= z < 170:
        x = math.pow(z + 77 + 14 * math.pow(z, 3), 3) / 84
    elif 170 <= z < 230:
        x = math.pow(1 + math.pow(z, 3) / 25 + math.pow(z, 2), 5)
    elif z >= 230:
        x = 78 * math.pow(13 * math.pow(z, 3) - 40 * math.pow(z, 2), 7) - 7 * z
    else:
        x = 0
    return x"
"import math

def main(z):
    if z < -12:
        x = math.pow(math.sin(z), 5) - 52 * math.pow(43 * z - math.pow(z, 2) / 47 - 39, 3) - z
    elif -12 <= z < 83:
        x = math.pow(math.cos(math.pow(z, 3) + z / 62 + math.pow(z, 2)), 4) + 28 * math.pow(math.pow(z, 2) - 1 - z, 6)
    elif 83 <= z < 170:
        x = math.pow(z + 77 + 14 * math.pow(z, 3), 3) / 84
    elif 170 <= z < 230:
        x = math.pow(1 + math.pow(z, 3) / 25 + math.pow(z, 2), 5)
    elif z >= 230:
        x = 78 * math.pow(13 * math.pow(z, 3) - 40 * math.pow(z, 2), 7) - 7 * z
    else:
        x = 0
    return x"
"import math

def main(z):
    if z < -12:
        x = math.pow(math.sin(z), 5) - 52 * math.pow(43 * z - math.pow(z, 2) / 47 - 39, 3) - z
    elif -12 <= z < 83:
        x = math.pow(math.cos(math.pow(z, 3) + z / 62 + math.pow(z, 2)), 4) + 28 * math.pow(math.pow(z, 2) - 1 - z, 6)
    elif 83 <= z < 170:
        x = math.pow(z + 77 + 14 * math.pow(z, 3), 3) / 84
    elif 170 <= z < 230:
        x = math.pow(1 + math.pow(z, 3) / 25 + math.pow(z, 2), 5)
    elif z >= 230:
        x = 78 * math.pow(13 * math.pow(z, 3) - 40 * math.pow(z, 2), 7) - 7 * z
    else:
        x = 0
    return x"
"import math

def main(x):
    if x < 57:
        return 59 * (x / 46 + 46 * x ** 2 + 6) ** 7 - x - (64 - 89 * x ** 3 - x) ** 5
    elif 57 <= x < 109:
        return 8 * x ** 3 + 1 + 40 * x ** 4
    elif 109 <= x < 122:
        return 88 * math.arccos(x) ** 2 - 1
    else:
        return (x ** 3 - 15 * x) ** 4"
"import math as m

def main(z):
    if z < 50:
        return m.log(86 * z - 1, 10) ** 6
    elif 50 <= z < 139:
        return 40 * z ** 3 - m.cos(z) ** 2 - 17
    elif 139 <= z < 207:
        return 1 + z ** 6 + m.log(z - 41, m.exp(1))
    elif 207 <= z < 260:
        return 53 * m.sin(z) + 38 * (1 + z ** 2) ** 3
    else:
        return 13 * z ** 7 - 23 * m.sin(4 * z ** 3 + z ** 2 / 47)"
"def main(x):
    if x < 26:
        f = x * x - pow(86 * x, 6) - pow(x + 53 * x * x + x * x * x, 4)
    elif 26 <= x <= 112:
        f = 89 * pow(x, 3 / 2)
    elif 112 <= x <= 189:
        f = x / 24
    elif 189 <= x < 276:
        f = 52 - 52 * pow(67 * x + 1 + 81 * pow(x, 3), 6)
    elif x >= 276:
        f = 76 - 22 * pow(x, 7) - 47 * pow(abs(x), 6)
    return f"
"def main(z):
    if z < -49:
        return 16 * z ** 4
    elif z < 17:
        return z ** 6
    elif z < 53:
        return 4 * z ** 2 - 33 * z ** 3
    elif z < 93:
        return 1 + abs(51 * z ** 2) ** 7 + 54 * z ** 2
    else:
        return z ** 6 + 83 * z ** 2"
"import math

def main(x):
    if x < 79:
        return 29 * x ** 6 + x ** 7 + 1
    elif x < 171:
        return math.cos(22 * x ** 2) ** 4
    elif x < 265:
        return x ** 6 - x ** (7 / 2) / 6
    elif x < 316:
        return (x - x ** 3 - 17 * x ** 2) ** 7 / 58
    else:
        return 2 * (28 * x + x ** 3) ** 5"
"import math

def main(x):
    if x < 64:
        f = math.log(x)
    elif 64 <= x < 119:
        f = math.sin(x) ** 3 + x + (1 - x ** 3 - 20 * x) ** 7
    elif 119 <= x < 215:
        f1 = 22 * (x + 84 + 78 * x ** 3) ** 5
        f2 = math.cos(x / 73 + 3 * x ** 3 + 64 * x ** 2) ** 4
        f = f1 - f2
    elif 215 <= x < 240:
        f = (43 * x - 19 * x ** 3 - 3 * x ** 2) ** 7 + 54 * math.floor(x ** 3) ** 6
    elif x >= 240:
        f = x ** 12 - 48 * (x ** 3 + 1) ** 4
    return f"
"import math

def main(y):
    if y < 73:
        result = 44 * y ** 6 + math.pow(81 * y ** 3 - y ** 2 / 20, 2)
    elif 73 <= y < 167:
        result = 68 * math.pow(y ** 2 - 1, 2) - math.pow(math.log10(y), 3)
    elif y >= 167:
        result = y ** 5 / 75 - 18 * y ** 3 - 21 * y
    return result"
"import math

def main(y):
    y2 = y * y
    y3 = y * y * y
    y4 = y * y * y * y
    if y < 44:
        return y2 - 36 - y3
    elif y < 76:
        return pow(1 + y + 14 * y3, 2) + 42
    elif y < 112:
        return 9 * pow(abs(1 - y2 / 44), 5) + pow(92 * y2 - 15 - y, 7)
    elif y >= 112:
        return y4"
"import math

def main(y):
    if y < 17:
        return math.sin(y ** 2 - y) ** 5
    elif 17 <= y < 50:
        return math.ceil(y) ** 3 / 98 - 5 * math.atan(67 * y ** 2)
    elif y >= 50:
        return math.cos(75 * y - y ** 3) ** 6"
"import math

def main(y):
    if y < 73:
        return (y - 12 * y ** 3) ** 3 - (y / 37 - y ** 2) ** 2 - 67 * math.fabs(y)
    if 73 <= y < 95:
        return 3 * math.atan(y) ** 4 + 52 * math.log(y) ** 3
    if 95 <= y < 126:
        return 2 * math.sin(59 * y ** 2) ** 5 - 75 * y ** 7 - 64
    if 126 <= y < 144:
        return (1 - y) ** 5 - 0.01 - 46 * (y ** 2 - y - y ** 3) ** 2
    if y >= 144:
        return 12 * ((1 + y + y ** 3) // 1) ** 2 + 77 * y ** 7 + 3"
"import math

def main(z):
    if z < 32:
        return 77 * z ** 6 - z ** 21
    elif 32 <= z and z < 121:
        return math.sqrt(z) + 26 * z ** 3 + z * z
    else:
        return 3 * abs(z) ** 7 + 69 * z ** 5 + (27 + 89 * z * z + 90 * z ** 3) ** 6"
"from math import cos, log2, ceil, floor

def main(z):
    if z < 26:
        res = z ** 6 + floor(z) ** 5 + log2(7) * z / 65
        return res
    elif 26 <= z < 81:
        res = cos(z) / 32
        return res
    elif z >= 81:
        res = z ** 7 + ceil(z / 64 + 1 + z ** 3) ** 3
        return res"
"def main(z):
    res = 0
    if z < 93:
        res = pow(7 * pow(z, 3) - 6, 6)
    elif z >= 93 and z < 159:
        res = 36 * pow(z, 6)
    elif z >= 159 and z < 227:
        res = pow(37 * pow(z, 3), 4)
    elif z >= 227:
        res = pow(1 - z * z, 5) - pow(z ** 2 + z ** 3, 6)
    return res"
"from math import cos, tan

def main(x):
    if x < 29:
        f = cos(x) ** 7 - abs(25 * x ** 3)
    elif 23 <= x < 82:
        f = 61 * (48 * x + x ** 3) + x ** 4
    elif 82 <= x < 110:
        f = 19 * x
    elif x >= 110:
        f = tan(x) ** 3 + (89 * x ** 3 - x ** 2) ** 5
    else:
        f = x
    return f"
"from math import tan, log

def main(z):
    if z < 101:
        f = 93 * (89 - 13 * z * z) ** 7 - tan(1 + 31 * z) ** 5 - 17 * z ** 3
    elif 101 <= z < 201:
        f = 71 * log(z, 10) ** 3
    elif 201 <= z < 219:
        f = (35 * z * z) ** 3 + z ** 7 / 82
    elif 219 <= z < 255:
        f = 51 * (z ** 3) ** 4 + z ** 6 + z ** 7
    elif z >= 255:
        f = 19 * z ** 7
    return f"
"from math import log

def main(x):
    if x < 94:
        return x - x ** 5 - 3 * (18 * x ** 2 + 78 * x ** 3) ** 4
    elif 94 <= x < 141:
        return (44 * x ** 3 + 52 + 6 * x ** 2) ** 4 + 70 * x ** 5 + 75 * (28 * x + x ** 3 / 28 + 1) ** 7
    else:
        return 64 * log(x) ** 3 - 60 * x ** 5 - x ** 2"
"import math

def main(z):
    if z < 15:
        return z ** 3 / 55
    elif 15 <= z < 37:
        return z ** 4 * 89
    elif 37 <= z < 79:
        return math.atan(1 + 65 * z) ** 6 + 28 * z ** 5
    elif z >= 79:
        return 37 * z ** 4 + 2106 * z ** 3"
"import math

def main(y):
    if y < 3:
        y = y ** 18 - math.floor(y) ** 5
    elif y < 99:
        y = (34 * y ** 2 - 19 * y) ** 6 - math.tan(y) - y ** 2
    elif y < 146:
        y = (1 - 72 * y ** 2) ** 5
    else:
        y = 51 * (64 * y - 0.04) ** 7 + 79 * y ** 4 + 0.06
    return y"
"import math

def main(z):
    if z < 43:
        z = math.log(z) ** 2 + 30 * z
    elif z >= 43 and z < 99:
        z = 16 * z ** 4 - 73 - z ** 3 / 84
    elif z >= 99 and z < 118:
        z = 0.02 + z ** 4
    elif z >= 118 and z < 214:
        z = 87 * z ** 3 - z ** 2 - 72 + 21 + 60 * z ** 2
    else:
        z = 28 * z ** 3
    return z"
"from math import fabs, atan

def main(y):
    if y < 115:
        res = y ** 6 - 71 * y ** 3
        return res
    elif 115 <= y < 173:
        res = fabs(y ** 2 / 89 + y ** 3) + atan(y - 17 * y ** 3 - 93) ** 7
        return res
    elif y >= 173:
        res = y ** 5 - 80 * y
        return res"
"import math

def main(z):
    if z < 22:
        return 73 * math.tan(z)
    if 22 <= z < 71:
        return z ** 5 / 84 - (z ** 2 - 12 * z)
    if z >= 71:
        return z ** 7 + math.ceil(z) ** 2 / 45"
"import math

def main(y):
    if y < 69:
        a = 81 * math.ceil(4 - y ** 2) ** 5
        return a
    elif 69 <= y < 120:
        a = 13 * (1 + 78 * y + 44 * y ** 3) ** 4 + y ** 7 + math.tan(y) ** 6
        return a
    elif 120 <= y < 158:
        a = 80 * y ** 3
        return a
    else:
        a = 63 * math.floor(10 * y ** 2 - y ** 3) ** 5
        return a"
"import math

def main(y):
    if y < 143:
        return math.ceil(44 * y ** 3) ** 7
    elif 143 <= y < 153:
        return 55 * y ** 3 + 35 * y ** 6 + 53 * y ** 7
    elif 153 <= y < 205:
        return 3 * y
    elif 205 <= y < 233:
        return y ** 7 + 1
    elif y >= 233:
        return 70 * (y + 59 * y ** 2) ** 3 - 13 * y ** 5"
"import math

def main(z):
    if z < -11:
        return 42 * z ** 4
    elif -11 <= z and z < 35:
        return 37 * z - math.pow(14 * z ** 2 + z ** 3 / 76 + z / 8, 6) - 1
    elif z >= 35:
        return 5 * z ** 3"
"from math import tan, ceil, log

def main(y):
    if y < 172:
        res = y ** 6 + log(y) ** 3 + y ** 4
        return res
    elif 172 <= y < 257:
        res = (41 + 85 * y ** 2 + y) ** 3 / 61 + 62 * ceil(y) ** 5
        return res
    elif 257 <= y < 342:
        res = 68 * (y / 88) ** 5 + 98 + tan(y - 0.08) ** 3
        return res
    elif 342 <= y < 359:
        res = (y ** 2 / 11 + 70) ** 6 / 91
        return res
    elif y >= 359:
        res = y ** 2 + 60 * (y / 70) ** 5
        return res"
"import math

def main(y):
    if y < 103:
        res = 17 * math.log(94 - 66 * y ** 2 - 39 * y ** 3) ** 6 - 86 * math.floor(y) ** 7
    elif y < 174:
        res = 62 - math.ceil(y + y ** 3 + y ** 2) ** 7
        res -= 45 * (27 * y ** 3 + y ** 2 + 0.02) ** 6
    elif y < 256:
        res = 34 * math.ceil(y) ** 3
    elif y < 326:
        res = abs(y) ** 6 + (67 * y + 11 * y ** 3 + 37 * y ** 2) ** 4 / 87 + 90 * y ** 2
    else:
        res = y ** 7 - 54 * (3 * y ** 2 - y)
    return res"
"import math

def main(y):
    if y < -41:
        return y ** 7 / 19 + math.floor(y ** 3) ** 2
    if -41 <= y < 18:
        return 1 - y ** 4 - 16 * y ** 7
    if 18 <= y < 108:
        return y ** 4 / 48
    if y >= 103:
        return 74 * y ** 15 + 70 * (y - 16 * y ** 2 - 78) ** 3 + math.floor(y) ** 2"
"import math

def main(z):
    if z < 148:
        return z ** 4
    elif z >= 148 and z < 185:
        return math.cos(z) + (z ** 2 - 0.17) ** 5 / 68
    else:
        return z ** 3 / 41"
"from math import acos, log, cos

def main(z):
    if z < 51:
        return 90 * z ** 5 - 1 - acos(z) ** 4 / 25
    elif 51 <= z < 148:
        return 1 - 97 * log(z) ** 6
    elif 148 <= z < 210:
        return cos(1 + 22 * z * z) ** 4 + z ** 2 / 18
    else:
        return 38 * z ** 7"
"import math

def main(x):
    if x < -4:
        return 83 * (21 * x ** 2 - 1 - x) ** 3 + 7 * x ** 2
    elif x < 32:
        return 77 * x ** 12 - (46 * x ** 2) ** 2
    elif x < 46:
        return math.log(x, 10)
    elif x < 105:
        return 38 * (65 * x ** 2) ** 4
    else:
        return (30 * x) ** 3 - 1"
"import math

def main(y):
    if y < 65:
        return 97 * y ** 2 - 5
    elif 65 <= y < 115:
        return y ** 3 + 17 + math.sin(y) ** 7
    elif 115 <= y < 188:
        return y ** 5 - y ** 4 - 1
    elif 188 <= y < 198:
        return math.sqrt(y) ** 7 + 8 * y ** 2
    else:
        return 28 * math.atan(y ** 2 - y ** 3 - 1) - y ** 5
        -23 * math.log10(y ** 2 - 59) ** 3"
"from math import pow, log10, log2

def main(x):
    if x < -40:
        return pow(x, 5) + log10(6 * x * x + x + 62) + 20 * pow(x, 6)
    elif -40 <= x < 12:
        return pow(1 - x * x, 4)
    elif x >= 12:
        return 63 * pow(log2(x), 6)"
"import math

def main(z):
    if z < 116:
        return 78 * math.exp(z) ** 6
    elif z >= 116 and z < 175:
        return (47 * z ** 3 - 77 * z - 1) ** 4
    elif z >= 175 and z < 257:
        return z ** 5 + 19 * math.ceil(z ** 2) ** 3
    elif z >= 257 and z < 331:
        return 75 * z ** 7 - z ** 6
    elif z >= 331:
        return 71 * math.sin(z - 71 * z ** 2) ** 3 - 86 * z ** 5"
"import math as m

def f(y):
    if y < 57:
        return m.sin(y) ** 5 / 52
    elif 57 <= y < 153:
        return m.sqrt(y ** 2 / 72 - y - 0.14) ** 7 + m.tan(y) ** 4 + 41 * y ** 2
    elif 153 <= y < 228:
        return 69 + y ** 4 + m.floor(1 - y ** 2 / 23) ** 6
    elif y >= 228:
        return y - y ** 6

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

def main(x):
    if x < 22:
        answer = 91 * x
    elif x >= 22 and x < 107:
        elem_1 = x * x - 43 * x * x * x - 4 * x
        elem_1 *= elem_1
        elem_2 = x - x * x
        elem_2 = elem_2 * elem_2 * elem_2 * elem_2
        answer = elem_1 - 0.05 - elem_2
    elif x >= 107:
        elem_1 = 47 * x
        elem_1 = elem_1 * elem_1 * elem_1 * elem_1 * elem_1 * elem_1 * elem_1
        answer = 38 * cos(x) * cos(x) - 36 * elem_1
    return answer"
"def main(x):
    if x < 176:
        return x ** 2
    if x < 195:
        return 68 * x ** 7 + 1 + 60 * abs(x) ** 6
    if x < 222:
        return (67 * x + 67 * x ** 3 + 73) ** 3 - 80 * x ** 5
    if x < 297:
        return (70 * x ** 3) ** 7
    return (60 * x + 1 + 37 * x ** 3) ** 7 + 51 * (x ** 2 / 27 + x ** 3) ** 6 + 19"
"import math as m

def main(x):
    if abs(x) in [41, 8]:
        x = -x
    if x < 54:
        a = m.floor(x ** 2 - 1) ** 3
        b = 67 * abs(x) ** 5
        c = -(x ** 7 / 43)
        return float('{:.2e}'.format(a - b - c))
    elif x >= 54 and x < 103:
        return float('{:.2e}'.format(x ** 4 - 87 * m.floor(x) ** 3 - 59 * x))
    elif x >= 103 and x < 159:
        return float('{:.2e}'.format(27 * (90 * x ** 3 + 42 * x) - x ** 2))
    elif x >= 159:
        a = (1 - 78 * x - x ** 3) ** 2
        b = 33 * (33 * x - 6 - 97 * x ** 2) + 13
        return float('{:.2e}'.format(a + b))"
"import math

def main(x):
    return 42 * (x + x ** 2) ** 3 - math.atan(x) ** 5 if x < 110 else math.log10(x ** 3 - 9 * x ** 2) / 43 + math.ceil(x ** 2) ** 3 + 17 * x ** 6 if x < 199 else 37 * x ** 4 if x < 216 else 10 * x ** 3 - 4 * x - (1 + x ** 3) ** 7 if x < 279 else (1 + 55 * x ** 2 + x / 88) ** 5"
"import math

def main(x):
    y = 0
    if x < 163:
        ex1 = math.pow(math.pow(x, 2) / 70 - math.pow(x, 3) - x, 3) / 97
        y = ex1 + 45 * math.pow(x, 4) + 1
    elif 163 <= x < 205:
        ex1 = math.pow(x, 3) - math.pow(x, 2) - x
        y = math.pow(math.cos(ex1), 5) + x
    elif 205 <= x < 265:
        ex1 = math.pow(math.pow(x, 3) - x - 9, 7)
        y = 57 * x - ex1 - 1
    elif x >= 265:
        ex1 = math.pow(math.pow(x, 2) * 36 + 1, 4)
        ex2 = 11 * math.pow(9 * math.pow(x, 3) + 87 * x + 75, 3)
        y = ex1 + ex2
    return y"
"import math
from math import fabs

def main(z):
    if z < 76:
        z = z ** 4 - 29 * math.atan(z) ** 2
    elif 76 <= z < 149:
        z = math.log(z ** 2, 10) ** 7 - fabs(59 - 37 * z ** 3) ** 6
    else:
        z = 1 + 61 * z ** 4
    return z"
"import math

def main(z):
    if z < -58:
        return math.arcsin(z) ** 6 - z ** 7
    elif -58 <= z < -8:
        return math.floor(20 * z ** 3 - 20) ** 7
    elif -8 <= z < 87:
        return (z ** 3 + 27 * z) ** 5 - 1 - math.ceil(z) ** 7
    else:
        return (9 * z ** 2 + z ** 3) ** 3 - 1"
"import math

def main(z):
    if z < 135:
        n1 = 33 * z ** 6
    if 135 <= z and z < 204:
        n1 = z ** 4 + (z + 1) ** 7 + 85 * (92 * z ** 2 + z ** 3 + z) ** 2
    if z >= 204:
        n1 = 80 * math.tan(z) ** 4 - 36 * (z / 81 + z ** 2) ** 5
    return n1"
"import math

def main(z):
    if z < 175:
        f = (44 * z ** 2 - 31 * z) ** 7
    elif z >= 175 and z <= 252:
        f = (1 + 82 * z ** 3) ** 5
    elif z >= 252 and z < 297:
        f = (0.02 - z ** 3) ** 3
    else:
        f = z ** 3 + 11 * z ** 2 + (97 * z ** 2) ** 7
    return f"
"import math

def main(x):
    if x < -38:
        a = 88 * pow(x, 4)
    elif -38 <= x < 39:
        a = 18 * pow(x, 3) + 18 * pow(x, 2) + 91 + 15 * math.exp(3 * pow(x, 3) / 23 - 48 - 183 * pow(x, 2))
    else:
        a = 61 + 41 * pow(math.tan(x), 6)
    return a"
"import math

def main(z):
    if z < 35:
        f = math.cos(z) ** 4 - (52 * z ** 3 - 1) ** 3 - 51 * z ** 7
    elif z < 72:
        f = 1 - z ** 7
    else:
        f = z + math.atan(36 * z) ** 5 + z ** 3
    return f"
"def main(*args):
    z = float(args[0])
    if z < 2:
        return 46 * z ** 6
    elif 2 <= z < 77:
        return z ** 4 + 67 * z ** 6
    elif 77 <= z < 172:
        return z ** 7 / 70
    elif z >= 172:
        return 7 * z ** 5"
"import math

def main(y):
    if y < 142:
        return 84 - 92 * pow(y ** 2 / 44, 7)
    elif 142 <= y < 236:
        a = pow(math.sin(95 * pow(y, 2) - y - 29), 7)
        return 0.03 - 3 * a
    elif 236 <= y < 297:
        return 4 * pow(y, 5)
    else:
        return 16 * pow(math.log(y, 2), 6) + 85 * pow(y, 4)"
"import math

def main(x):
    if x < 168:
        a = 85 * abs(92 * pow(x, 3)) - pow(x, 3) / 70
        return pow(math.cos(x), 2) - a
    elif x < 228:
        return pow(x, 4)
    elif x < 249:
        a = 84 * pow(math.exp(46 - pow(x, 2) - 31 * x), 6)
        return x - a - pow(33 * pow(x, 3), 7)
    elif x < 338:
        return pow(x, 3) - 31 * pow(x, 2)
    else:
        return 51 * pow(x, 3)"
"import math

def main(z):
    if z < 92:
        f = 76 * abs(54 * z ** 3) ** 6 - 60 - (19 + z) ** 4
    elif z < 180:
        f = (z ** 3 - z / 7) ** 7
    else:
        f = 89 * abs(96 * z * z) ** 4 - 74 * math.sqrt(44 * z ** 2 + 62 * z) - (9 * z ** 2) ** 3
    return f"
"import math

def main(y):
    if y < 8:
        return 1 + 97 * pow(y, 4)
    elif 8 <= y < 94:
        return pow(y, 7)
    elif 94 <= y < 125:
        return pow(math.log(y), 6)
    else:
        return pow(y, 3) + 44 * (pow(y, 4) + pow(y, 5))"
"import math

def main(z):
    if z < 116:
        return 49 * z
    elif 116 <= z < 180:
        return 90 * z ** 3 - math.log(z ** 3, 2)
    elif 180 <= z < 196:
        return 12 * (13 * z ** 3 - z - 78) ** 2 - z ** 3 - math.tan(z) ** 7
    elif z >= 196:
        return z / 15 - (z ** 2 + z ** 3 / 65 + 57 * z) ** 3 - 1"
"import math

def main(z):
    if z < -11:
        return 34 * pow(z, 3)
    elif 11 <= z < 55:
        return pow(math.ceil(z), 3)
    elif 55 <= z < 115:
        return math.atan(pow(z, 2)) + pow(z / 5, 4)
    elif 115 <= z < 196:
        return pow(z, 6) + pow(z, 4)
    elif z >= 196:
        return 69 * pow(z, 3) + 12 * pow(z, 2)"
"import math

def main(y):
    if y < 173:
        return y ** 2 / 49 - 95 * y ** 6 - 63 * (12 - 23 * y - 30 * y ** 2) ** 7
    elif 173 <= y < 211:
        return 9 * y ** 5
    else:
        return 30 * math.log(y, math.e)"
"import math

def main(z):
    if z < 137:
        massa = z ** 7 + 87 * (38 * z ** 3 - 53) ** 2
    elif 137 <= z < 232:
        massa = 81 * z ** 5 - (z + 77 * z ** 3) - 79 * (69 * z) ** 4
    elif 232 <= z < 294:
        massa = z ** 6 - z ** 5 - 51 * z ** 4
    elif 294 <= z:
        massa = 9 * math.sqrt(4 - 82 * z - 81 * z ** 2) ** 7 - (89 * z ** 2 + z) ** 2
    return massa"
"import math

def main(y):
    if y < 157:
        f = y ** 3 - 56 * math.sin(y - y ** 3 - 1)
    elif y < 205:
        f = 64 * (y ** 2 - 1) + 20 * y ** 7
    elif y < 227:
        f = 89 * y ** 3 - 98 * (80 * y ** 2 + 68 * y) ** 6
    elif y < 323:
        f = 65 * math.cos(y) ** 4
    else:
        f = 4 * math.log10(y) ** 2 - 26 * y ** 4 - math.log(y, math.e) ** 7
    return f"
"import math

def main(x):
    res = 0
    if x < 61:
        res = 74 + 36 * (37 * x + 0.01 + x ** 2 / 74) ** 2
    elif x >= 61 and x < 105:
        res = 24 * (x + 1 + 66 * x ** 2) ** 3 + 68 * math.log2(x + x ** 2 + 34) ** 7
    else:
        res = x + 0.06
    return res"
"import math

def main(y):
    if y < 31:
        f = 78 * (39 * y) ** 5
    elif 31 <= y < 50:
        f = math.tan(y) + 66 * math.sin(y ** 3 + y) ** 2 + 43 * y ** 3
    elif 50 <= y < 125:
        f = (y ** 3 + y ** 2 / 49) ** 4 / 56 + 36 * y ** 2
    elif 125 <= y < 175:
        f = math.log2(y) ** 4 - (16 + y ** 3 + 23 * y ** 2)
    elif y >= 175:
        f = 1 - math.fabs(y) ** 3 - math.tan(y ** 3 - y ** 2 / 29 - y) ** 4
    return f"
"import math

def main(x):
    if x < 96:
        y = 16 * abs(95 * x ** 3 - x) ** 7
    if x >= 96 and x < 168:
        y = 8 * (x ** 3 + 45 * x) ** 2 - x ** 4
    if x >= 168 and x < 181:
        y = x ** 4 - math.log(x, 10) ** 3
    if x >= 181:
        y = x ** 3
    return y"
"import math

def main(z):
    if z < 23:
        f = math.log(z) ** 2
    elif 23 <= z < 58:
        f = 0.06 + z ** 2 / 92 + z
    elif z >= 58:
        f = 91 * z - (z ** 3 / 35) ** 4 - 34 * (70 * z) ** 6
    return f"
"import math

def main(x):
    if x < 71:
        return 94 * math.sqrt(x) ** 3 - 29 * x
    elif 71 <= x < 114:
        return 38 * x ** 4 - (42 * x - x ** 3 - x ** 2) ** 3 / 19
    elif 114 <= x < 145:
        return math.ceil(x) ** 6 - 99 * x
    elif 145 <= x < 220:
        return 69 * x ** 4 - x ** 7 / 86
    elif x >= 220:
        return 69 * (x ** 2 / 27 + 0.03) ** 6"
"import math

def main(z):
    if z < 65:
        return 55 * (20 * z - 1) - z ** 3 / 9
    elif z < 80:
        return z ** 2
    elif z < 174:
        return 1 + 96 * abs(6 * z ** 2 + 1) + 96 * math.exp(1 - z ** 3 - 54 * z) ** 7
    elif z < 220:
        return 15 * z - 0.04
    else:
        return z ** 5 - (z - 51 * z ** 3) ** 2"
"def main(x):
    if x < 48:
        return x ** 7 - 43 * x ** 4 - 67 * x ** 2
    elif 48 <= x < 103:
        return 72 * x ** 3 + (x ** 3 / 53 - x - 99 * x ** 2) ** 4 + 53 * x ** 5
    else:
        return x ** 6 - 41 * x ** 4 - 86 * x ** 2"
"import math

def f(y):
    if y < 26:
        return (69 * y ** 3 - y ** 2 - y) ** 4 - math.atan(y) ** 3 - y ** 2
    elif y >= 26 and y < 57:
        return 41 * y - 86 * y ** 3
    elif y >= 57 and y < 80:
        return 85 * y ** 4
    elif y >= 80 and y < 100:
        return y ** 3 - abs(y) ** 6
    elif y >= 100:
        return y ** 4 / 63

def main(*args):
    return f(*args)"
"import math

def main(y):
    if y < -28:
        res = (26 * y ** 2 + 1 + y) ** 6
    elif y >= -28 and y < 34:
        res = y ** 3
    elif y >= 34 and y < 101:
        res = math.fabs(39 * y ** 3 - 18 - y ** 2) ** 5 - math.tan(y) ** 2
    elif y >= 101:
        res = y ** 5 + math.exp(y)
    return res"
"import math

def main(x):
    if x < 113:
        return 80 * x ** 7
    elif 113 <= x < 161:
        return 50 * (82 * x ** 2 + 1) ** 4 - x ** 5
    elif 161 <= x < 197:
        return 31 + x ** 21
    elif 197 <= x < 271:
        return 1 + (27 * x - 50) ** 3 + math.log2(x) ** 4 / 40.0
    else:
        return 88 * x ** 14"
"import math

def main(y):
    if y < 129:
        f1 = 58 * y ** 2 - 54 * (64 * y ** 3 + y ** 2 + 89)
        return f1
    elif 129 <= y < 151:
        f = (y ** 3 / 67.0 + 62 * y ** 2 + 98) ** 5
        f2 = math.exp(62 * y - y ** 3 / 44.0)
        return f - f2
    else:
        f3 = 1 - 12 * math.tan(52 - y ** 3 - 86 * y ** 2) ** 2
        return f3"
"import math

def main(x):
    if x < -50:
        f = 1 - x ** 4 - 29 * x
        return f
    elif x < -22 and x >= -50:
        f = 9 * abs(63 * x ** 2 - 1) ** 7
        return f
    elif x >= -22:
        f = 80 * x ** 7 - x ** 2
    return f"
"import math

def main(z):
    if z < 21:
        return 22 + 59 * (z ** 2 + z) ** 7
    if 21 <= z < 98:
        return (76 * z - 1 - z ** 2) / 30 + 13 * math.log(8 * z + z ** 2) ** 5 + 9 * z ** 2
    if z >= 98:
        return math.atan(81 * z ** 2 + 71 * z ** 3 + 1) ** 6 - 1 - math.ceil(z) ** 5 / 6"
"def main(z):
    if z < 20:
        a = abs(z + z ** 3 / 54 + 1) ** 4
    elif z >= 20 and z < 56:
        a = 49 * z
    elif z >= 56 and z < 140:
        a = (z / 64) ** 4 / 73 - 58 - z ** 2
    else:
        a = 1 - 82 * z ** 2
    return a"
"import math

def main(x):
    if x < 78:
        f = 1 - 28 * math.pow(math.tan(x), 3)
    elif 78 <= x < 175:
        f = 36 + 28 * x
    elif 175 <= x < 250:
        f = 96 * x - math.pow(x, 4)
    elif 250 <= x < 290:
        f = x * x + 46 + x + 8 * math.pow(math.sin(x), 7)
    else:
        f = math.pow(34 * x * x * x + 59 * x, 6)
    return f"
"import math

def main(z):
    if z < 47:
        f1 = z ** 5 - 55 - math.cos(53 * z ** 2 - z ** 3) ** 2
    elif 47 <= z < 70:
        f1 = (z ** 2 + 50 * z + 36) ** 2 + 89 + math.exp(z) ** 7
    elif 70 <= z < 159:
        f1 = z ** 2 - 90 * z ** 3 - z ** 6
    elif 159 < z < 216:
        f1 = 23 * math.log(1 + z) ** 4
    elif z >= 216:
        f1 = 53 * abs(z) ** 2 - 85 * z ** 6 - (88 * z - 83 * z ** 2 - z ** 3)
    return f1"
"import math

def main(y):
    if y < -26:
        f = (1 - 29 * y) ** 6
    elif -26 <= y < 66:
        f = y ** 7 + 91 * y ** 4
    elif 66 <= y < 152:
        f = 13 - (78 * y ** 2 + 67 + 27 * y) ** 6 - abs(67 * y - y ** 2 / 98 - 0.04) ** 7
    elif y >= 152:
        f = 38 * (31 * y ** 3 + 1 + y / 63) ** 4
    return f"
"import math

def main(z):
    if z < 128:
        f = 1 + math.pow(94 * z + 47 + 54 * z * z, 3) + 66 * math.log10(75 * z * z + z + 1)
    elif 128 <= z < 175:
        f = 44 * (z / 68 - 83 * z * z) - 72 * math.pow(z, 6) - 1
    elif 175 <= z < 262:
        f = math.pow(z, 7) / 42 + z + 69 + 43 * math.pow(z, 3)
    else:
        f = 7 * math.pow(48 * z * z, 2) + 17 * z + math.pow(71 * z + 37 + 31 * z * z * z, 5)
    return f"
"import math

def main(x):
    if x < 31:
        a = math.log2(35 * x ** 2 - x - x ** 3 / 78) ** 4
        return x ** 7 + 79 * x + a / 9
    if 31 <= x < 96:
        return x
    if x >= 96:
        return 31 * x ** 7 + abs(87 * x) ** 3 / 29"
"import math

def main(z):
    if z < 130:
        return math.log10(z) ** 7 - math.fabs(z) ** 3
    elif 130 <= z < 202:
        return 19 * z ** 5
    elif 202 <= z < 265:
        return 91 * z ** 4
    elif z >= 265:
        return (z ** 3 / 46 + z + z ** 2) ** 7"
"import math

def main(x):
    if x < -30:
        return math.pow(67 * math.pow(x, 3) - x, 2)
    elif x < 42:
        return math.pow(x, 4) - 68 * math.pow(math.cos(x), 5)
    elif x < 140:
        return 35 * math.pow(x, 4)
    elif x < 232:
        return 18 - 38 * math.pow(94 + 39 * x, 7)
    else:
        return 17 + (75 - 38 * x) / 47 + 96 * math.pow(x, 7)"
"def main(y):
    if y < 102:
        return 9 * (31 * y - 34) ** 3
    elif y >= 102 and y < 131:
        return 47 * y - 83
    elif y >= 131 and y < 205:
        return 33 * (y + 16 + y ** 3 / 42) ** 3
    else:
        return y ** 12 - 80 - 69 * (y ** 3 + 86 * y) ** 2"
"def main(x):
    if x < 70:
        f = 86 * x ** 3
    elif 70 <= x < 94:
        f = 38 * (x - x ** 3 - 90) ** 5
    elif 94 <= x < 153:
        f = x
    elif x >= 153:
        f = (x ** 2 - 1) ** 5 - x ** 3 - x ** 7
    return f"
"import math

def main(z):
    if z < -2:
        return 33 * math.atan(z) ** 7
    elif -2 <= z < 46:
        return 15 * int(22 + z / 63 + z ** 2) ** 3 + 9 * z ** 7 + 12 * (z ** 3 / 77) ** 5
    elif z >= 46:
        return 72 * (9 * z ** 3) ** 3"
"import math

def main(z):
    if z < -11:
        return (22 * z ** 2) ** 2 + 61 * math.sin(z - 66 + (-z) ** 2) + math.fabs(z ** 3 + 29) ** 3
    if z >= -11 and z < 14:
        return (z ** 2 + z + 85 * z ** 3) ** 5 / 10 - (3 * z ** 2) ** 7 - (z - 69 * z ** 3 - z ** 2) ** 6
    if z >= 14:
        return 48 * z ** 7 + z ** 5"
"import math

def main(x):
    if x < 79:
        return math.log10(x) ** 3 + 50 * x + math.floor(85 * x ** 2) ** 5
    elif x >= 79 and x < 121:
        return (4 * x ** 2 + x / 11 + 54) ** 5 - 11 * x ** 6
    elif x >= 121 and x < 177:
        return 32 * x ** 7 + math.log10(x) ** 6 + x ** 3
    else:
        return 28 * math.cos(x ** 2 + x)"
"import math

def main(y):
    x = 0
    if y < 95:
        x = (65 - 28 * y ** 2) ** 2 + 0.01
    elif 95 <= y < 178:
        x = math.atan(84 * y ** 2) ** 4 + 18 * y ** 7 + 92 * math.log2(y) ** 3
    elif 178 <= y < 251:
        x = math.tan(8 * y ** 3) ** 2 + 6 * math.ceil(y) ** 4
    elif y >= 251:
        x = y ** 2
    return x"
"import math

def main(z):
    if z < 50:
        f = math.pow(math.floor(z * z / 7), 2) - 1
    if z >= 50 and z < 73:
        f = math.pow(math.pow(z, 3) / 4 + 32 * z, 5)
    if z >= 73:
        f = 22 * math.pow(math.pow(z, 2) / 40, 3)
    return f"
"import math

def main(z):
    x = 0
    if z < 111:
        x = 25 - 50 * math.ceil(z ** 6)
    elif 111 <= z < 209:
        x = 40 * (97 * z ** 2 - 49) ** 5
    elif z >= 209:
        x = (12 * z ** 3) ** 6
    return x"
"import math

def main(z):
    if z < 48:
        f = 68 * z ** 3 + (z + 35 + z ** 3) ** 6 + z
    elif z < 144:
        f = 56 * z ** 4 + z ** 7
    else:
        f = math.atan(3 * z + 12) ** 6 + 1
    return f"
"import math

def main(x):
    if x < 109:
        return x ** 4
    if 109 <= x < 143:
        return 18 * (12 * x) ** 3 - x ** 6
    a = math.sin(74 * x ** 2 + 25 * x) ** 7
    return a / 9 + math.cos(x) ** 2 / 34 + math.log(x, 2)"
"import math

def main(x):
    if x < -4:
        result2 = math.atan(x ** 3 / 71 + 70 * x + 1) ** 3 - 71 * x ** 2 - x ** 7
    elif -4 <= x < 17:
        result2 = 99 * (1 - x ** 2) ** 5 - 13 * x ** 7 - (18 * x ** 3) ** 4
    else:
        result2 = 64 * math.log(x, 10) + 51 * x ** 3 + 1
    return result2"
"from math import *

def main(z):
    if z < -19:
        f = pow(z, 7) / 58 + 23 * tan(z)
        return f
    elif -19 <= z < 56:
        f = pow(z / 15, 6) - pow(1 + 34 * pow(z, 2), 3) - 10 * sin(z)
        return f
    else:
        f = floor(z) + 0.01 + pow(z, 2)
        return f"
"import math

def main(x):
    if x < 42:
        return 28 * pow(x, 4)
    if 42 <= x < 126:
        return 22 * pow(x, 5)
    if 126 <= x < 213:
        return pow(x, 6)
    if 213 <= x < 280:
        return pow(x, 2)
    else:
        return pow(x, 15) - 12 * pow(x, 4) - 1"
"import math

def main(y):
    if y < 40:
        sol = (6 * y ** 2 - y ** 3 - 1) ** 4
    elif y >= 40 and y < 86:
        sol = math.cos(y ** 2 / 94 + y / 21 + 1) ** 6
    elif y >= 86:
        sol = 73 - 56 * y ** 5
    return sol"
"import math

def main(y):
    if y < 39:
        return 10 * y ** 7 + 68
    if 39 <= y < 94:
        return math.log2(y) ** 5
    if 94 <= y < 118:
        return y ** 3 + 71 * y * y
    if 118 <= y < 142:
        return y / 43 + y ** 3 - 3 * y ** 4
    if y >= 142:
        return 1 - y ** 5 - y ** 4"
"import math

def main(z):
    if z < 0 or 89 <= z < 180:
        return z ** 7
    elif 8 <= z < 89:
        return 96 - z ** 3 + math.log(z) ** 2 + 84 * math.sin(z) ** 4
    else:
        a = 27 * (16 * z ** 2 + 31 * z ** 3) ** 5
        b = z ** 2 / 38 + 29 * z ** 6
        return a + b"
"import math

def main(x):
    if x < 19:
        return 20 * (8 * x ** 2) ** 5
    elif 19 <= x < 64:
        return x - 73 * (60 * x ** 3 + 0.02 + 44 * x ** 2) ** 2 - 70 * x ** 5
    elif 64 <= x < 80:
        return math.exp(x) ** 7 + 9 * math.tan(x) ** 4 + 25
    elif x >= 80:
        return x + 1 + math.tan(x - 86 * x ** 3) ** 7"
"import math

def main(x):
    if x < 14:
        return 27 * math.cos(x) ** 3 + x ** 2 / 73 + 38 * (x - 1 - 92 * x ** 2) ** 5
    if (x >= 14) & (x < 87):
        return x ** 3 + 10 * (6 * x ** 3 + 1 + 26 * x) ** 2
    if (x >= 87) & (x < 124):
        return 85 * x + (1 - 27 * x ** 3) ** 3
    if x >= 124:
        return 76 + x ** 2"
"import math

def main(x):
    if x < 66:
        return math.ceil(x) ** 3 / 64 - math.exp(x ** 2 / 67 - x - x ** 3 / 58) ** 7
    elif 66 <= x < 146:
        return 92 * (73 * x) ** 2 - 20 * x ** 4
    elif 146 <= x < 220:
        return 23 * (x ** 3 - x - 14 * x ** 2) - 29 * x ** 6 - 79
    elif x >= 220:
        return x ** 5"
"from math import *

def main(z):
    if z < 124:
        return 16 * z ** 3 - z ** 7
    elif z < 185:
        return 98 * tan(z) ** 6 - z ** 7
    else:
        return 93 * z ** 7 - 20 * ceil(z ** 5)"
"import math

def main(z):
    if z < 56:
        a = z * z - pow(29 * z * z, 7) / 28 - 43 * pow(z, 6)
    if 56 <= z < 114:
        a = pow(math.cos(z), 2)
    if 114 <= z < 162:
        a = 30 * pow(math.tan(90 - 41 * z - z * z), 4)
    if 162 <= z < 260:
        a = pow(z, 6) - z * z / 6
    if z >= 260:
        a = 53 + 9 * pow(math.log(21 * z * z - 56 * z, 2), 3)
    return a"
"import math

def main(z):
    if z < 76:
        return pow(94 * z * z + 74 * z * z * z, 4)
    elif 76 <= z < 173:
        return 3 * z * z
    elif 173 <= z < 268:
        return 30 * pow(z, 5)
    elif 268 <= z < 315:
        return 79 * pow(z, 6)
    else:
        return pow(math.cos(z * z - 32 * z - 1), 2) + z"
"import math

def main(z):
    if z < 100:
        a = 85 * math.pow(80 * math.pow(z, 2) - 77 * math.pow(z, 3) - 89, 3)
        return math.pow(math.tan(z), 4) + a
    elif 100 <= z < 118:
        return 74 * math.pow(math.pow(z, 2) / 72, 7)
    elif z >= 118:
        return 1 - math.pow(math.pow(z, 3) + z, 7)"
"import math

def main(y):
    return {y < 159: pow(y, 5) / 85 - pow(y, 3) - 75 * y, 159 <= y < 245: 32 * y * y - pow(y * y - y * y * y / 26, 7) - (y * y + 10 * y + y * y * y) / 65, 245 <= y < 270: pow(math.ceil(93 * y - 87 * y * y), 3) / 30 + 41 * pow(y, 4), y >= 270: pow(y, 3) - pow(7 * y + 1, 5)}[True]"
"import math
from cmath import atan
from math import floor

def main(y: float):
    if y < 81:
        s = y / 4
        return float(s)
    elif 81 <= y < 138:
        s = 88 * y ** 2 + 43 * (y - 50 * y ** 3) ** 7
        return float(s)
    elif 138 <= y < 229:
        s = y ** 5
        return float(s)
    elif 229 <= y < 242:
        s = 20 * y ** 4 + 77 * atan(1 + y) ** 7
        return float(s)
    elif y >= 242:
        s = math.log(y) ** 5 - floor(y) ** 2
        return float(s)"
"def main(y):
    if y < 63:
        x = 57 * y + 77 * (32 * y ** 3 - 8 * y ** 2) ** 5
        return x
    elif y >= 63 and y < 121:
        x = 21 * y - (53 + 59 * y ** 3 + 12 * y) ** 2
        z = 89 * (35 * y ** 2 + y) ** 3
        return x - z
    elif y >= 121 and y < 165:
        x = 58 * y ** 7 + y ** 2 / 69 - y / 69
        return x
    else:
        x = 96 * (78 * y + 56 * y ** 2 + 94 * y ** 3) ** 6
        z = y ** 3 + (y + y ** 2 / 11) ** 2
        return x + z"
"import math

def main(x):
    if x < 68:
        return math.cos(23 + x ** 2) ** 3 - (x ** 3 - 26 * x ** 2) ** 6 - x
    elif (x >= 68) & (x < 127):
        part_2_1 = 48 * math.fabs(x ** 2) ** 6 - 46
        part_2_2 = (69 * x ** 3 + x + 37 * x ** 2) ** 4
        return part_2_1 - part_2_2
    elif (x >= 127) & (x < 138):
        part_3_1 = 85 * math.fabs(x) ** 2
        part_3_2 = 12 * math.log(x ** 2, 2) ** 3 - math.tan(x) ** 7
        return part_3_1 - part_3_2
    elif (x >= 138) & (x < 211):
        return x ** 8
    elif x >= 211:
        return math.exp(x) ** 2 + math.log10(x) ** 6 + x"
"import math

def main(x):
    if x < 165:
        z = x ** 10
    elif x >= 165 and x < 203:
        z = 1 - 18 * math.sqrt(x) ** 4
    elif x >= 203 and x < 222:
        z = x - abs(1 + 52 * x ** 2 + 85 * x ** 3) ** 6
    else:
        z = 81 - 82 * x - x ** 2 - 89 * x ** 6 - 85 * x * 3
    return z"
"def main(x):
    if x < 11:
        return (8 + x ** 2 + 24 * x) ** 3
    elif 11 <= x < 60:
        return 34 * x ** 4 + 3700 * x ** 2
    elif 60 <= x < 153:
        return x + abs(38 + x) ** 6
    else:
        return (x - x ** 2 / 34 - x ** 3) ** 5 + 25 * x ** 4 + 26 * abs(x) ** 2"
"import math

def main(z):
    result = 0
    if z < 82:
        result = 72 - 29 * (z ** 2 / 86 + z / 9) ** 3
    elif z >= 82 and z < 165:
        result = math.log2(z) ** 6
    elif z >= 165 and z < 212:
        result = z + math.fabs(z ** 3) ** 2 + 66
    elif z >= 212 and z < 311:
        result = 90 * math.fabs(z) ** 6 + math.fabs(z) ** 5 + 55
    elif z >= 311:
        result = 50 * (43 + z / 40) ** 6 - z ** 8
    return result"
"import math

def main(y):
    if y < 140:
        return 31 * y ** 3 - 1
    elif 140 <= y < 168:
        a = (63 - y / 17) / 69 - math.log10(y) ** 5 / 77
        return a
    elif 168 <= y < 251:
        a = math.log(y) ** 3 + y ** 2 + 57 * y ** 4
        return a
    else:
        return 1 - y ** 3 - 10 * y"
"def main(x):
    result = 0
    if x < 2:
        result = 32 * x ** 3
    elif 2 <= x < 69:
        result = 20 * x
    elif x >= 69:
        result = x ** 4 / 29 - 60 * x ** 21
    return result"
"import math

def main(y):
    if y < 146:
        return math.sqrt(y) - 4 * y ** 6
    if 146 <= y & y < 209:
        return y + (y - 97 * y ** 2) ** 6 / 77 + (y ** 2 / 76 - 1 - y ** 3) / 13
    if y >= 209:
        return math.fabs(y) - 1"
"from math import sin
from math import cos

def main(y):
    if y < 1:
        f = 99 * pow(cos(y), 6) + 18
        return f
    if 1 <= y <= 78:
        f1 = pow(y, 3) + 51 * y
        f = pow(f1, 7) - 1
        return f
    if y >= 78:
        f1 = 25 * y - 29 * pow(y, 3) - 13
        f = pow(sin(17 * y), 3) + pow(f1, 6)
        return f"
"def main(y):
    if y < 0:
        return y ** 3 / 88 - abs(y) ** 6 - 11 * (abs(67 * y ** 2) - 35 - y) ** 4
    elif y < 69:
        return y ** 6 + y ** 7 + 17 * y ** 3
    elif y < 143:
        return (92 * y + 0.01) ** 5 / 35 - y ** 6 - 24 * (y ** 3 + y ** 2)
    elif y < 165:
        return 33 - y ** 2
    else:
        return (y ** 2 / 68) ** 3"
"import math

def main(x):
    if x < 23:
        return 20 * (44 * x) ** 2
    elif x < 72:
        return math.log(x) ** 7 + (3 + 9 * x ** 2) ** 5 + 53 * math.floor(57 * x ** 3 + x ** 2) ** 3
    elif x < 146:
        return math.sqrt(x ** 3) + math.cos(x) ** 5 + 60 * x ** 4
    elif x < 165:
        return 89 * (x ** 2 / 54)
    else:
        return 63 * x ** 7 + 1 + x ** 6"
"from math import ceil, floor

def main(z):
    if z < 119:
        f = 80 * (84 * z ** 2) ** 3
    elif 119 <= z < 201:
        f = z - z ** 6 - 30 * (24 * z ** 3 - 15 * z ** 2 - 1) ** 2
    elif 201 <= z < 298:
        f = 24 * floor(z ** 2 + 3 * z)
    elif 298 <= z < 345:
        f = 70 * z + 67 + 51 * ceil(z) ** 7
    else:
        f = 44 * z ** 3 + 85 * z ** 5 + z ** 6 / 63
    return f"
"import math

def main(x):
    if x < 23:
        return 20 * (44 * x) ** 2
    elif x < 72:
        return math.log(x) ** 7 + (3 + 9 * x ** 2) ** 5 + 53 * math.floor(57 * x ** 3 + x ** 2) ** 3
    elif x < 146:
        return math.sqrt(x ** 3) + math.cos(x) ** 5 + 60 * x ** 4
    elif x < 165:
        return 89 * (x ** 2 / 54)
    else:
        return 63 * x ** 7 + 1 + x ** 6"
"def main(y):
    if y < 39:
        a = 82 * y + 93 * pow(y, 2) + 37
        return pow(a, 3) + pow(y, 7) / 63
    elif y < 92:
        a = pow(70 * y + 21 * pow(y, 2), 2)
        return 40 * pow(y, 3) - a
    elif y < 109:
        return pow(y, 4) - y / 6
    else:
        a = 63 * pow(y, 2) + 49 + 37 * pow(y, 3)
        return 45 * pow(a, 3)"
"from math import *

def main(y):
    if y < 43:
        return 22 * pow(71 * y, 3) + pow(21 - 92 * pow(y, 3), 5) + pow(84 * pow(y, 2), 2)
    elif 43 <= y < 89:
        return 1 + atan(pow(y, 3) + pow(y, 2) + 95 * y) + pow(exp(pow(y, 2) / 27), 3)
    else:
        return y / 9 + pow(y, 4) / 68"
"import math

def f(x):
    if x < 63:
        return 1 + 76 * (x ** 2 / 95 - x / 81) ** 6
    elif x < 139:
        return (x + x ** 3) ** 2 - (18 * x) ** 3 / 62
    elif x < 192:
        return math.log10(x) ** 3
    elif x < 257:
        return x ** 6 - x ** 4
    else:
        return 61 * math.log10(x) ** 3 - 1

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

def main(x):
    if x < -45:
        f = 39 * (0.12 - x ** 3 / 58 - x) ** 4
    elif -45 <= x < 7:
        f = 76 * math.ceil(x) ** 4 + 81 * math.atan(x) ** 2
    elif x >= 7:
        f = x ** 7
    return f"
"from math import log2, sin

def main(z):
    if z < 140:
        return 92 * sin(z)
    elif z < 175:
        return (z ** 2 + z ** 3 / 17) ** 2
    elif z < 231:
        return z ** 4 - 12 * z ** 3
    elif z < 256:
        return 39 * log2(z) ** 3
    else:
        return 7 * z ** 4"
"import math

def main(x):
    if x < 83:
        return x - 73 * (1 - 30 * x - 21 * x ** 2) ** 2
    elif 83 <= x < 169:
        return 30 * x ** 7 - (9 * x ** 2) ** 4 - x ** 6
    elif 169 <= x < 184:
        return math.cos(29 * x ** 2) ** 3 + 32 * x ** 4
    elif 184 <= x < 210:
        return x + 1
    elif x >= 210:
        return (44 - x ** 3 - x) ** 2 - (0.01 - 10 * x - 82 * x ** 2) ** 7"
"from math import sqrt

def f(x):
    if x >= 255:
        return 95 - 70 * x ** 4
    elif x >= 175:
        return 80 * (59 - x) + (x ** 2 + 83 + 18 * x ** 3) ** 7
    elif x >= 147:
        return x ** 3 + x ** 6
    else:
        return x ** 4

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

def f_1(z):
    result = (42 * z + 33 * z ** 2) ** 3
    result += -76 * z ** 2
    result += -(5 * math.cos(z ** 2 - z / 45 - 1) ** 6)
    return result

def f_2(z):
    result = 73 * math.floor(z ** 2 / 54 - z / 50 - 68) ** 6 + 1
    return result

def f_3(z):
    result = (59 * z ** 3 - z ** 2 - 22) ** 5
    result -= 46 * math.floor(z)
    result -= math.ceil(7 - z ** 2) ** 3
    return result

def f_4(z):
    return 37 * z ** 5

def main(z):
    if z < 21:
        return f_1(z)
    elif 21 <= z < 77:
        return f_2(z)
    elif 77 <= z < 96:
        return f_3(z)
    else:
        return f_4(z)"
"import math

def main(x):
    if x < -31:
        return abs(x) ** 7
    elif -31 <= x < -7:
        a = x ** 6
        b = 2 * x ** 3 + 36 * x * x + x
        c = 67
        return a - b / c
    elif -7 <= x < 49:
        a = 42 * math.atan(x) ** 6
        b = 76 * abs(1 - x) ** 5
        return a + b
    elif x >= 49:
        return 11 * (x * x / 17) ** 4"
"import math

def main(y):
    if y < 7:
        return y ** 4 / 57
    if 7 <= y < 60:
        return 63 * y ** 5 + 50 * math.sin(y) + y ** 6
    if 60 <= y < 80:
        return (y ** 2 + 61) ** 5 + y ** 18
    return 8 * y + y ** 4 + math.exp(y) ** 2"
"import math

def main(x):
    if x < 60:
        return 72 * (x - x ** 3 - 10 * x ** 2) ** 5
    elif 60 <= x < 128:
        return (1 + 42 * x ** 2) ** 5 - x ** 4 - x ** 3
    else:
        return x ** 7 + (45 * x ** 3 - 1) ** 3 + math.exp(x)"
"import math

def main(z):
    if z < 89:
        return 46 * math.fabs(z) ** 5
    elif 89 < z < 144:
        return z ** 3 - 20 * math.log10(z) ** 5 - 26 * math.fabs(z) ** 6
    elif 144 <= z < 211:
        f1 = (64 * z + z ** 3 + z ** 2) ** 2
        return f1 / 88
    elif z >= 211:
        f1 = (24 * z + 24 + 53 * z ** 3) ** 6
        f2 = 95 * (55 * z ** 3 - 21 * z ** 2 - 22) ** 4
        f3 = (68 * z ** 3 - z - 99) ** 5
        return f1 + f2 + f3"
"import math

def main(z):
    if z < -15:
        return (z ** 3 - 44 * z) ** 7 - 42 * z ** 4 - z ** 2
    elif -15 <= z < 15:
        return 5 * z ** 5
    elif 15 <= z < 94:
        return z ** 9 + 1
    elif 94 <= z < 193:
        return 68 * z ** 7 + 22 * math.tan(1 - 71 * z ** 2) ** 5 + 76 * z ** 3
    else:
        return math.cos(45 * z ** 3 + 70 * z ** 2 + z) ** 7"
"import math

def main(x):
    if x < 12:
        return pow(95 * x + 24, 2)
    elif x < 102:
        return 1 - 64 * pow(x, 4)
    elif x < 176:
        return pow(x, 7) + 72 * pow(7 + 99 * pow(x, 2), 3) + pow(x, 6)
    else:
        a = pow(math.log2(x ** 2 + 44 + 73 * pow(x, 3)), 2)
        return a - 54 * pow(math.atan(x), 7)"
"import math
from math import *

def main(z):
    if z < 168:
        return (80 * z ** 2) ** 5
    elif z < 215 and z >= 168:
        return cos(42 * z ** 3 + z ** 2 + z) ** 4
    elif z < 271 and z >= 215:
        return (z - 75 * z ** 3) ** 6 + z + 90 * z ** 3
    elif z < 307 and z >= 271:
        return sin(24 * z ** 2) ** 4
    elif z >= 307:
        return 1 - 54 * z
main(301)"
"def main(x):
    if x < 102:
        return 81 + (x ** 3 - 1 - 6 * x) ** 2 / 89 + (x ** 2 / 42 + x ** 3 + x) ** 6
    if 102 <= x < 155:
        return (0.14 + x / 3 + x ** 2) ** 6 / 29
    if 155 <= x < 252:
        return 1 - (63 - 16 * x ** 3) / 12
    if x >= 252:
        return (x ** 2 + 24 * x + 0.09) ** 6 + 15 * x ** 2 + 93 * (15 - 88 * x ** 3) ** 4"
"def part1(y):
    return 7 * (y * y + y) ** 2

def part2(y):
    return 79 * y * y

def part3(y):
    return 40 - 92 * y * y - 49 * (78 * y ** 3) ** 4

def part4(y):
    return y ** 4 + 1 + y

def part5(y):
    return 14 * (42 * y ** 3 + 0.01 + y) ** 4

def main(y):
    if y < 165:
        return part1(y)
    elif y < 237:
        return part2(y)
    elif y < 260:
        return part3(y)
    elif y < 353:
        return part4(y)
    else:
        return part5(y)"
"import math

def main(x):
    if x < 108:
        return x ** 4 - math.ceil(x) ** 3
    if x >= 108 and x < 162:
        return 58 * (77 * x ** 3 + x ** 2) ** 2 + 29 + (x + x ** 2) ** 3
    if x >= 162 and x < 222:
        return 25 * (0.02 + 91 * x ** 3) ** 2 + 46 * x ** 5
    if x >= 222:
        return 47 * (x ** 2 + x + x ** 3 / 75)"
"import math

def func(x):
    if x < 14:
        f = float(pow(x / 72, 5))
    elif x >= 14 and x < 104:
        f = float(pow(pow(x, 3) / 35, 6) / 42 - 52 * pow(51 + 9 * pow(x, 2), 4))
    elif x >= 104 and x < 143:
        f = float(72 * pow(abs(x), 3))
    else:
        f = float(87 * pow(abs(pow(x, 3) - 56), 2))
    return f

def main(x):
    return func(x)
main(79)"
"import math

def main(z):
    if z < 152:
        f = pow(23 + 93 * z * z, 2) - pow(z / 60 - z * z, 7)
    elif z >= 152 and z < 178:
        f = 47 * pow(z, 6) + 30 * z * z
    elif z >= 178 and z < 254:
        f = 7 * math.atan(z)
    elif z >= 254 and z < 278:
        f = pow(math.fabs(50 * z * z * z + 45 * z * z), 2)
    elif z >= 278:
        f = pow(math.tan(z), 7)
    return f"
"import math

def main(x):
    res = 0
    if x < 178:
        res = 95 * (77 * x ** 2) ** 4
    elif 178 <= x < 198:
        res = 29 * x ** 4 - 25 * x ** 2 - (23 * x ** 2 + 1 + x) ** 5
    elif x >= 198:
        res = 1.0 + (21 * x - 87 * x ** 2 - 0.02) ** 7 + (math.e ** x) ** 2
    return res"
"import sys
from math import tan

def f(y):
    answ = float(0)
    if y < 81:
        answ = 62 + 30 * tan(y)
    elif 81 <= y < 101:
        answ = y
    else:
        answ = y ** 5 / 55 + 69 * (76 * y ** 2 - y ** 3) ** 6 + y ** 3
    return answ

def main(arg):
    y = float(arg)
    return f(y)"
"from math import log10

def main(x):
    if x < 141:
        return 64 * x - 46 * (x - x ** 3) ** 2 - 19 * x ** 6
    elif 141 <= x < 207:
        return x ** 3 - 30
    elif 207 <= x < 230:
        return x ** 2 - (x - 1 - x ** 3) ** 4
    elif x >= 230:
        return log10(x) ** 6 + 97 * x"
"from math import log, ceil, cos, sqrt

def f1(z):
    return z ** 6 // 99 + (95 + z + z ** 2) ** 5 / 50 + 84 * z ** 4

def f2(z):
    return 18 * z ** 3 + 32

def f3(z):
    return 58 * (z ** 2 / 22 - z - 1) - ceil(z ** 2 + 45 * z) ** 6 / 26

def f4(z):
    return sqrt(z) ** 4 / 52

def f5(z):
    return cos(z) ** 5 - log(z) ** 2 - 45

def main(z):
    if z < 167:
        return f1(z)
    elif 167 <= z < 241:
        return f2(z)
    elif 241 <= z < 288:
        return f3(z)
    elif 288 <= z < 371:
        return f4(z)
    return f5(z)"
"import math

def main(z):
    if z < 6:
        return z ** 2 + (z ** 2 - z - z ** 3) ** 7
    elif (z >= 6) & (z < 48):
        return -30 * z + (25 * z ** 2 - 1 - z / 38) ** 6
    elif (z >= 48) & (z < 61):
        return 98 * z ** 6 + (z ** 3 / 45 - z) ** 3
    elif (z >= 61) & (z < 146):
        return 41 * math.floor(z) ** 6
    elif z >= 146:
        return 72 * (49 * z ** 3 + z ** 2) ** 7"
"import math

def main(x):
    if x < 82:
        f = x ** 4 / 94 + x ** 2 - x ** 3 - 69 * x
    elif x < 156:
        f = 69 * x ** 2 - x ** 4 - x
    elif x < 210:
        f = x ** 4
    else:
        f = x ** 2 - 8 * (x ** 3 + x + 83) ** 5 - math.log(x)
    return f"
"def main(x):
    if x < 75:
        k = x ** 7
    elif 75 <= x < 170:
        k = 64 * x ** 3 + x ** 7
    elif 170 <= x < 193:
        k = 42 * (47 * x ** 2 + 20 * x ** 3) ** 7 + x ** 5 / 4
    elif 193 <= x < 289:
        k = x ** 10 - 1
    elif x >= 289:
        k = (84 * x ** 3 - x) ** 5 + (38 * x ** 2 + 56 * x + 1) ** 2 / 36
    return k"
"import math

def main(x):
    if x < 84:
        return x ** 6
    elif 84 <= x < 139:
        return 94 * (x ** 3 + x + 99 * x ** 2) ** 3 - 73 * math.log10(50 * x ** 2 + x) ** 6
    elif 139 <= x < 181:
        return (x ** 3 / 87) ** 6 - x ** 5
    elif 181 <= x < 241:
        return x ** 4 - x ** 5 / 74 - math.log2(x) ** 2
    elif x >= 241:
        return 17 * x ** 4 - 95 * (1 - 8 * x ** 3 - x)"
"import math

def main(z):
    if z < -40:
        a = 49 * z + math.tan(98 * z ** 2 - 85 * z ** 3 - z) ** 4
        return a
    if -40 <= z < 59:
        b = 1 - 36 * z ** 6 - 84 * z ** 7
        return b
    if 59 <= z < 147:
        c = z ** 2 / 38 - math.ceil(32 * z ** 2) ** 7
        return c
    if z >= 147:
        d = 31 * z + 24
        return d"
"import math

def main(z):
    if z < 126:
        return 0.02 - (78 * z ** 2 - z / 66) ** 7 - 68 * (76 + z ** 2) ** 6
    elif z < 200:
        return 67 * math.sin(78 * z ** 3) ** 7 + (z ** 2 + 18 + z ** 3 / 40) ** 6 + 18
    elif z < 256:
        return z + 13 * (math.sin(z) ** 3) ** 3 + z ** 7
    elif z < 277:
        return 49 * z ** 7 - 2 * math.log(z) ** 4 - (1 + z) ** 3
    elif z > 277:
        return 98 * math.log(2, z) ** 7 - 91 * (z ** 3 + z + z ** 2 / 34) - z ** 6"
"import math

def main(z):
    if z < 58:
        return 63 * pow(18 * z * z, 2)
    elif 58 <= z < 71:
        return 8 * pow(55 * pow(z, 3) - 1, 5) + 20
    elif 71 <= z < 123:
        return pow(math.log10(z), 6) / 6 - math.sin(pow(z, 2) / 17 + pow(z, 3) / 39 + z) / 69
    elif 123 <= z < 160:
        return 10 * pow(math.atan(z), 4) - pow(math.sin(pow(z, 3) - 68 * z), 6) - pow(z, 2) / 14
    elif z >= 160:
        return pow(z, 2) + 94 * pow(z, 6) + 52 * pow(pow(z, 3) - z - 1, 3)"
"import math

def main(x):
    if x < 52:
        return (x - 79 * x ** 2 - x ** 3) ** 3 + (1 - x ** 2 - 41 * x ** 3) ** 4 + (x ** 2 - x - 1) ** 5 / 63
    if (x >= 52) & (x < 87):
        return 74 - 22 * (x ** 2 + x ** 3 + x) ** 5
    if x >= 87:
        return 75 * (75 * x ** 3) ** 7"
"def main(x):
    if x < 52:
        return x ** 4 - (x ** 2 / 88 - 8 - x ** 3) ** 3 - 86 * x ** 2
    if 52 <= x < 77:
        return 51 * (70 - x) - 81 * (35 * x + x ** 3 + x ** 2) ** 6
    if x >= 77:
        return abs(x) ** 2"
"def main(x):
    if x < 122:
        return 42 * ((x ** 3 + 1) ** 0.5) ** 3
    elif 122 <= x < 217:
        return 67 * x + 93 * x ** 2 + (75 * x) ** 4
    elif x >= 217:
        return (79 * x + 0.05) / 94 - 93 * x ** 7"
"import math

def main(x):
    if x < 55:
        f = (x // 1) ** 4 + x
    elif 55 <= x < 139:
        f = x ** 2 + 21 + 21 * math.sin(x) ** 3
    elif 139 <= x < 213:
        n = 1 - 29 * x ** 3 - 61 * x
        f = math.tan(n) - x ** 10 / 60
    elif 213 <= x < 292:
        n = 81 * x ** 3 + 55 + 14 * x
        f = x ** 3 + n ** 7
    else:
        f = 63 * x ** 2 + 99 * x
    return f"
"import math

def f1(y):
    return 17 * math.pow(y / 8 - 18, 4) + math.pow(math.floor(y), 3)

def f2(y):
    part1 = (30 * y + 52 * y ** 3 + 21) ** 2
    part2 = 28 * (75 * y ** 3 + y + 1) ** 6
    part3 = (1 - y ** 3) ** 5
    return part1 - part2 - part3

def f3(y):
    part1 = math.log(y ** 3 + y ** 2) ** 7
    part2 = 56 * math.tan(58 * y ** 2) ** 4
    return part1 - part2

def main(y):
    if y < -23:
        return f1(y)
    elif -23 <= y < 72:
        return f2(y)
    else:
        return f3(y)"
"import math

def main(z):
    if z < 149:
        return 38 * math.atan(58 * z + 52 * z ** 3 + 14 * z ** 2) ** 6 + 15 * (0.02 - 9 * z ** 2) ** 2 + (14 * z + z ** 3 / 4) ** 7
    if 149 <= z < 212:
        return 25 - (39 + 49 * z + 13 * z ** 3) ** 6 - 66 * z ** 15
    if 212 <= z < 232:
        return 0.05 + z + math.ceil(z + z ** 3 + 1) ** 5
    if z >= 232:
        return z ** 5 - math.log(43 * z ** 2) ** 7 / 9"
"import math

def main(x):
    if x < 11:
        y = abs(x) - 20 - x ** 4 / 81
    elif x < 72:
        y = x ** 7
    elif x < 148:
        y = 27 - math.tan(x ** 2 + x ** 3) ** 6
    elif x < 178:
        y = 97 * x ** 5 + 90 * x ** 12 + 91
    else:
        y = 57 * (x / 30) ** 6 - x ** 2 - (x + 7 + 98 * x ** 3) ** 3
    return y"
"from math import atan

def main(z):
    if z < -9:
        res = 61 * z ** 2
        return res
    elif -9 <= z < 70:
        res = z ** 3 - 86 * atan(z) ** 4 - 10
        return res
    elif z >= 70:
        res = 43 * z ** 6 - 3 * z ** 2
        return res"
"from math import *

def main(z):
    if z < 39:
        return z ** 3
    elif z >= 39 and z < 58:
        return z ** 2
    elif z >= 58 and z < 99:
        return 14 * z ** 2
    elif z >= 99 and z < 112:
        return abs(1 + 66 * z ** 2) ** 4
    elif z >= 112:
        return tan(z ** 2 + z) / 88 - z ** 3 - z ** 6 / 52"
"import math

def main(y):
    if y < 27:
        return 45 * y - math.sin(y) ** 6 / 16 - 85 * y ** 5
    elif 27 <= y < 47:
        return y ** 4
    elif 47 <= y < 125:
        return math.atan(y) ** 7 + math.atan(22 * y ** 3) ** 5 + 45 * y ** 3
    elif 125 <= y < 210:
        return y - 92
    elif y >= 210:
        return 66 * y ** 2 + 7 * math.atan(y - y ** 3)"
"import math

def main(y):
    if y < 15:
        a = 9 * (y ** 3 - 61 * y) + 10 * y ** 3
    elif 15 <= y < 37:
        a = y ** 7 / 94 - math.atan(y) ** 2
    elif 37 <= y < 119:
        a = y ** 2
    elif y >= 119:
        a = 89 * math.atan(y) ** 4 + math.log2(y) ** 2
    return a"
"def main(x):
    import math
    if x < 128:
        return 61 * (22 * x * x - 1 - x) ** 2 - x ** 6 / 86 - x ** 4
    elif x < 223:
        return 1 - 85 * x * x * x
    elif x < 239:
        return x * x
    elif x < 295:
        return 74 - x ** 5 / 43 - 59 * x ** 6
    else:
        return math.log10(x) ** 2 - math.sqrt(41 * x * x - 19 * x) ** 3 - x ** 4"
"import math

def main(z):
    if z < 24:
        part1 = 32 * math.log(57 * z * z + z, 10) ** 5
        return part1 - z ** 3 - 9 * (53 * z * z + 7 * z + 55 * z ** 3) ** 7
    elif (z >= 24) & (z < 55):
        return 60 * (z * z - z ** 3) ** 7 - z * z / 90 - z ** 3
    elif (z >= 55) & (z < 91):
        return math.log(z, 2) ** 4 - math.exp(z / 84) ** 5 / 99 - z ** 3 / 67
    elif z >= 91:
        return 13 * (86 * z ** 3 - z * z / 81) ** 7 - 85 * math.atan(38 * z) ** 4 - 8 * z ** 5"
"import math

def main(z):
    if z < 159:
        s = math.atan(z) ** 3 / 81
        return s
    if 159 <= z & z < 250:
        s = 0.01 + math.log(z) ** 5 / 52 + (z ** 3 / 40 - z) ** 7
        return s
    if z >= 250:
        s = 32 * abs(88 * z + 64 * z ** 2) ** 5
        return s"
"import math

def main(x):
    if x < 39:
        return 50 * math.atan(x) - 65 * (64 - 53 * x) ** 4
    elif 39 <= x < 119:
        return abs(91 * x ** 2 - x ** 3) ** 7 / 94
    elif 119 <= x < 155:
        return 0.06 - math.sqrt(x) ** 6
    elif 155 <= x < 214:
        return math.cos(28 * x ** 2 + 52 * x) ** 5
    elif x >= 214:
        return 19 * x ** 3 + 29 * math.atan(x) ** 7"
"from math import *

def main(y):
    if y < 3:
        f = pow(39 * pow(y, 3) - pow(y, 2) - 84, 2) - pow(y, 6) - pow(log2(y ** 2), 3)
    elif 3 <= y < 19:
        f = 31 * pow(y, 3) - pow(y - 81 - 21 * pow(y, 2), 7)
    elif 19 <= y < 85:
        f = pow(log10(y), 2)
    elif y >= 85:
        f = pow(18 * pow(y, 2) + 66 * pow(y, 3), 7) - pow(atan(y), 6)
    return f"
"import math

def main(x):
    if x < 57:
        return (x ** 3 / 76 + x + 1) ** 2
    elif 57 <= x < 141:
        return math.log(49 * x ** 3 + 9 * x) ** 3
    elif 141 <= x < 231:
        return 87 * x ** 5 + 65 * math.floor(x ** 3 / 2 - 1) ** 3
    elif 231 <= x < 296:
        return 47 * x ** 14
    else:
        return 61 * x ** 6"
"import math

def main(y):
    if y < -56:
        return y ** 5
    if -56 <= y < -37:
        return 10 * y ** 3
    if -37 <= y < 28:
        return (y / 75 - y ** 2) ** 4 / 3
    if 28 <= y < 108:
        return math.exp(y) ** 7
    if y >= 108:
        a = (1 - 46 * y ** 3 - y ** 2 / 62) ** 6
        b = 75 * y
        return a + b"
"def main(z):
    if z < 11:
        return 19 * z * z + 28 * z ** 7
    if z >= 61:
        return (79 - z ** 2 / 47 - z / 91) ** 2 + (z ** 3 - z - 1) ** 4
    else:
        return 64 * (14 * z ** 2) ** 6"
"from math import sqrt, tan, log, atan, exp

def main(z: float):
    if z < 38:
        return log(26 * z ** 3) ** 7 - 1
    elif 38 <= z < 90:
        return 54 * atan(z) ** 6 + exp(z) ** 2
    elif 90 <= z < 175:
        return z ** 2 / 8 + z ** 4
    elif 175 <= z < 202:
        return tan(z ** 3 - 54 - 38 * z ** 2) ** 7 + z ** 6
    elif z >= 202:
        return z ** 5"
"import math

def main(y):
    if y < 165:
        return (87 - y ** 2) ** 5 + 25 + 38 * y ** 7
    elif 165 <= y < 228:
        return 42 * y ** 6 - 9 * (85 * y ** 2 + 74 * y ** 3 + y) ** 2 - 83 * math.log10(y ** 2 + 0.01 + 20 * y) ** 3
    elif 228 <= y < 250:
        return math.exp(12 * y ** 3) ** 3 / 58 + math.sin(25 + y ** 2 + y ** 3 / 58) + y ** 2
    elif 250 <= y < 275:
        return 70 * math.tan(y) ** 6 + 97 * math.asin(y ** 3) ** 7
    else:
        return 31 * y"
"def main(y):
    if y < 130:
        return y ** 4 + 0.5
    if 130 <= y < 210:
        return abs(y) ** 5 / 57
    if y >= 210:
        return y ** 2"
"import math

def main(x):
    if x < 130:
        f = pow(1 - pow(x, 3), 6) - 42 * math.sin(x) ** 7 - x ** 3
        return round(f, 1)
    if 130 <= x < 194:
        f = pow(55 * x + x ** 2, 6) / 50 + 10 * pow(math.floor(22 * x ** 3 + 13 * x ** 2), 3)
        return round(f, 1)
    if 194 <= x < 231:
        f = 70 * x ** 7 + pow(25 * x ** 3 - x ** 2, 3) + 0.01
        return round(f, 1)
    if x >= 231:
        f = math.atan(x) ** 7 - pow(89 + x ** 3, 3) - 88 * math.cos(62 - x) ** 5
        return round(f, 1)"
"import math as m

def main(x):
    if x < 121:
        return x + pow(m.log2(x), 5)
    elif 121 <= x < 176:
        return 74 * (pow(x, 2) - pow(x, 3)) - 31 - pow(x ** 3 - 43 * pow(x, 2) - 39 * x, 4)
    else:
        return 49 * pow(x, 7)"
"import math

def main(z):
    if z < -1:
        return math.log(z ** 2 - 0.01 - 48 * z, 2) ** 3
    elif -1 <= z < 46:
        return (90 * z ** 3) ** 4 - 59 * z ** 6
    elif 46 <= z < 95:
        return 85 * math.sin(z ** 2 - 1 - 68 * z ** 3)
    else:
        return 31 * z ** 2 - z ** 3 - 78 * math.cos(z ** 3) ** 3"
"def main(z):
    if z < 36:
        return (z ** 3 / 85) ** 5 - 1
    if 36 <= z & z < 111:
        first_expression = (z ** 3 - 79 * z - 1) ** 5
        second_expression = 2 * abs(8 + 77 * z ** 3 + 29 * z) ** 2
        third_expression = 31 * abs(93 * z ** 3 - 22 * z ** 2 - z) ** 7
        return first_expression + second_expression + third_expression
    if z >= 111:
        first_expression = 79 * (z * 3 + z * 2 / 82) ** 4
        second_expression = (z ** 2 - 6 * z ** 3) ** 5
        return first_expression - second_expression"
"import math

def main(x):
    if x < 176:
        x = 11 * x * x - 1
        return x
    if 176 <= x < 219:
        x = math.sin(x) ** 6 / 83
        return x
    if 219 <= x < 301:
        x = x ** 3 + x ** 2 / 29 + math.log(x, 2) / 93
        return x
    if x >= 301:
        x = math.log(x, 10) ** 4 - 70 * x * x
        return x"
"def main(x):
    if x < -83:
        y = 72 * x ** 6 + x ** 2
    elif x < -9:
        y = 58 * x ** 2 + 75 * x - 1 - 6 * (x + 0.03 + 22 * x ** 2) ** 7
    elif x < 74:
        y = (x + 61 * x ** 3 + 59 * x ** 2) ** 7 - x ** 6
    elif x < 98:
        y = x ** 7 - x ** 6 / 31
    else:
        y = x ** 5 / 54
    return y"
"f = 0

def main(z):
    if z < 35:
        f = z ** 5 - abs(z ** 2 - 53 * z) ** 7
    elif z >= 35 and z < 126:
        f = 5 * (69 * z ** 2) ** 2
    else:
        f = 1 - (91 * z ** 2 - z - 66 * z ** 3) ** 2
    return f"
"def main(x):
    if x < 29:
        return 1 - x ** 5 / 52 - 55 * (x ** 2 - x - 17 * x ** 3) ** 4
    if 29 <= x < 94:
        return 58 * (x ** 3 + 43 * x + 1) ** 7
    return 39 * (76 * x ** 3) ** 5 - (1 - 34 * x - 72 * x ** 3) ** 2"
"from math import floor, cos

def main(z):
    if z < 142:
        return z ** 2 / 83
    elif z < 181:
        return floor(z) ** 2
    elif z < 219:
        return z ** 3 / 49
    elif z < 261:
        return 0.02 + 73 * z ** 3 + 79 * z ** 7
    else:
        return 40 * (62 * z ** 2 - z ** 3 - z) ** 3 - cos(z) ** 6"
"from math import floor, cos

def main(z):
    if z < 142:
        return z ** 2 / 83
    elif z < 181:
        return floor(z) ** 2
    elif z < 219:
        return z ** 3 / 49
    elif z < 261:
        return 0.02 + 73 * z ** 3 + 79 * z ** 7
    else:
        return 40 * (62 * z ** 2 - z ** 3 - z) ** 3 - cos(z) ** 6"
"def main(x):
    if x < 100:
        n = 26 * x ** 3 - 74
    elif 100 <= x < 143:
        n = 18 - 28 * int(x) ** 2
    elif 143 <= x < 175:
        n = x ** 7
    elif x >= 175:
        n = x ** 6 / 32
    return n"
"def main(y):
    if y < 116:
        return 92 * (y - y * y * y / 18 - 69)
    elif 116 <= y < 152:
        return pow(40 * y + 43 * y * y, 7)
    elif y >= 152:
        return pow(75 + y * y * y, 6) - pow(y, 7) / 30"
"import math

def main(z):
    if z < -64:
        f = 14 * z + 20 * z ** 6
    elif z >= -64 and z < -42:
        f = z ** 7 - z ** 2 - 81 * (25 - z ** 3) ** 4
    elif z >= -42 and z < 18:
        f = z ** 3 + 85 * z ** 4 + math.tan(z - 55 * z ** 2 - z ** 3) / 56
    elif z >= 18 and z < 118:
        f = 77 * z ** 7 + z ** 4
    elif z >= 118:
        f = z ** 3 - z - 1
    return f"
"import math

def main(y):
    if y < -14:
        return y ** 3 / 49 - 24 * (1 - y ** 3) ** 4
    elif -14 <= y < 61:
        return 18 * (y ** 2 / 18 - 81 * y ** 3) ** 4 - 92 * (47 - y)
    elif y >= 61:
        return math.cos(y) ** 6 - 30 * y ** 2 - 93"
"import math

def main(y):
    if y < -14:
        return y ** 3 / 49 - 24 * (1 - y ** 3) ** 4
    elif -14 <= y < 61:
        return 18 * (y ** 2 / 18 - 81 * y ** 3) ** 4 - 92 * (47 - y)
    elif y >= 61:
        return math.cos(y) ** 6 - 30 * y ** 2 - 93"
"import math

def main(x):
    if x < 71:
        return (x ** 2 + 26 * x ** 3) ** 7 - abs(22 * x ** 3 - 97) ** 4
    if 71 <= x < 160:
        return 56 * (91 - 38 * x ** 2) ** 2
    if x >= 160:
        return 54 * (20 * x + 0.02) ** 5 + math.floor(x) ** 7"
"import math

def main(x):
    if x < 108:
        return 18 * x ** 2
    if 108 <= x < 147:
        return 53 * (1 + x ** 2 + 60 * x ** 3) ** 2
    if 147 <= x < 238:
        return 45 * math.sin(x) - 45 * x ** 4 - (33 * x ** 3) ** 7
    if x >= 238:
        return 30 * x ** 6 - math.tan(x)"
"def main(y):
    if y < 82:
        sum = math.sqrt(y) ** 4 / 44 + (14 - y) ** 2
    elif y >= 82 and y < 135:
        sum = 84 * (51 * y ** 2 - y ** 3) ** 2 - y / 40
    elif y >= 135 and y < 208:
        sum = 90 * y
    elif y >= 208 and y < 304:
        sum = (y ** 2 + y + 1) ** 5 - 78 * (y + 93 * y ** 2 + 42) ** 6 - y ** 3
    else:
        sum = math.asin(y) ** 7
    return sum"
"import math

def main(y):
    if y < 49:
        one = 98 * pow(y, 7) + pow(y + pow(y, 2) + 48, 4) / 74 + 49
        return one
    elif 49 <= y < 139:
        two = pow(y, 7) + pow(math.atan(3 * y - pow(y, 3)), 2) + 0.08
        return two
    elif 139 <= y < 209:
        three = 1 + pow(pow(y, 2) / 99 + 74 * y + 99, 3)
        return three
    elif 209 <= y < 294:
        four = pow(y, 2) / 14
        return four
    elif y >= 294:
        five = pow(y, 5)
        return five"
"import math

def main(x):
    result = 0
    if x < 13:
        result = pow(x, 5)
    elif x >= 13 and x < 87:
        result = pow(x, 7) - 1 - pow(math.ceil(x), 3) / 54
    elif x >= 87:
        result = pow(math.floor(x), 3)
    return result"
"import math

def main(y):
    if y < 63:
        return 55 * (84 * y ** 2 - y ** 3 - 55 * y) ** 4 - 72 * (y / 40 - y ** 3) ** 2
    if 63 <= y and y < 122:
        return y ** 7 - 23 * y - y ** 3
    if 122 <= y and y < 193:
        return 17 * (y - 67 - y ** 2) ** 5 + (77 * y ** 2 + y / 68 + 0.01) ** 3
    if y >= 194:
        return math.log10(y ** 2) ** 6 - y ** 3 / 2"
"from math import ceil
from math import atan

def main(z):
    if z < -35:
        return ceil(z) ** 7
    elif -35 <= z < 44:
        return (14 * z ** 3 - 54 * z - 0.01) ** 3 / 96
    else:
        return (1 + (98 * z) ** 3) ** 7 + 32 + 51 * atan(z ** 2 / 28 - 68 * z - 33)"
"from math import atan
from math import e

def main(y):
    if y < -5:
        return (64 * y - 72 * y ** 2 - 1) ** 2 - 16 * y ** 3
    elif y < 21:
        return 61 * y ** 7
    elif y < 54:
        return 79 * atan(y) ** 4 + (e ** (35 * y)) ** 5 + y ** 6 / 64
    elif y < 104:
        return 59 * y ** 2 / 66 + 1 + y ** 3 / 30
    else:
        return atan(y) ** 5 - 1 - (y ** 3 - 54 - 72 * y ** 2) ** 7"
"import math

def main(x):
    a = (x ** 3 / 8 + x ** 2) ** 3 / 40
    if x < 39:
        return math.tan(x) - 56 * x ** 9
    elif 39 <= x < 112:
        return x ** 7
    elif 112 <= x < 123:
        return 80 * math.cos(x) ** 6 + a + 8 * x ** 4
    elif 123 <= x < 168:
        return 80 * x
    elif x >= 168:
        return (42 - x ** 2 / 77) ** 3"
"import math

def main(y):
    a = (y + 1 + 20 * y ** 2) ** 5 / 37
    if y < 132:
        return 60 * (74 * y ** 2 - 47 * y ** 3) + a
    elif 132 <= y < 161:
        return 64 - abs(51 * y) ** 2
    elif 161 <= y < 248:
        return (50 * y ** 3) ** 3 + 1
    elif y >= 248:
        return 7 * 62 * y ** 3 - 15 * y"
"import math

def main(z):
    if z < 172:
        return pow(29 * pow(z, 2) - 33 * z - 1, 5)
    elif 172 <= z & z < 266:
        return 68 * math.log2(pow(z, 3) + 1) - pow(z + pow(z, 3) + 1, 3)
    elif z >= 266:
        return 82 * z"
"import math

def f(x):
    if x < 11:
        return math.cos(x - x ** 2) ** 4 + math.exp(x) ** 6 / 32 + 3 * x ** 7
    elif x >= 11 and x < 93:
        return 65 * (21 * x ** 3 - x ** 2)
    elif x >= 93 and x < 124:
        return 75 * (19 * x + 87) ** 3
    elif x >= 124 and x < 162:
        return math.sin(x) ** 4
    elif x >= 162:
        return x ** 6 - 12 * (x ** 2 / 23 - 61 * x ** 3) - math.tan(79 * x ** 3) ** 2 / 37

def main(*args):
    return f(*args)"
"import math

def main(y):
    if y < 63:
        x = 63 * y ** 7 - 3 * y * 3
    elif y <= 63 or y < 156:
        x = y - math.floor(70 * y ** 3) ** 7
    elif y <= 156 or y < 180:
        x = 72 * abs(76 * y) ** 5
    elif y <= 180 or y < 211:
        x = 89 * (y ** 2 - 0.02) ** 3 - 1
    elif y >= 211:
        x = y ** 4 + math.atan(y) ** 2
    return x"
"import math

def main(x):
    if x < 32:
        f = (74 * x) ** 5 + (x * x + 8 * x + 0.11) ** 4
    elif x < 112:
        f = x ** 6
    elif x < 185:
        f = 40 + x ** 5 + 33 * x ** 4
    else:
        f = 27 * math.log(x * x + 1 + x / 61) - 12 * x ** 4
    return f"
"import math

def main(z):
    if z < 112:
        f = z ** 3 / 81 - 32 * math.fabs(z - 58) ** 2
    elif z < 163:
        f = math.cos(z) ** 3
    elif z < 217:
        f = z + z ** 5
    elif z < 265:
        f = z ** 18
    else:
        f = 1 - 24 * math.log(z ** 3 + 94, 2) ** 4
    return f"
"import math

def main(y):
    if y < -27:
        return 44 * y ** 2 + 70 * y ** 3
    if -27 <= y < 54:
        return (88 * y ** 2 + 62 * y ** 3) ** 4
    if 54 <= y < 120:
        return 79 * y ** 6
    if 120 <= y < 146:
        return 92 * (12 * y - y ** 2 - 12 * y ** 3) ** 3
    if y >= 146:
        d = math.log2(y ** 3 - 70 * y) ** 3
        return 30 * d - 1"
"import math

def main(x):
    if x < 19:
        f = (89 * x + x ** 2 + 84) ** 2 / 61 - 35 * x ** 7
    elif 19 <= x < 64:
        f = 26 + x ** 2
    elif 64 <= x < 76:
        f = x ** 6 / 62
    else:
        c = 91 * x ** 2
        a = 10 * (92 * x + x ** 3) ** 3
        b = 84 * math.log(x, math.e) ** 6
        f = c + a + b
    return f"
"import math

def main(y):
    if y < 146:
        return 58 - y - (y * y / 77 - 68 * y) ** 2 / 81
    if 146 <= y < 193:
        return math.ceil(y / 78 + y * y) ** 5 - 4
    if y >= 193:
        return math.ceil(y ** 3) / 62"
"import math

def main(x):
    f = 0
    if x < 35:
        f = 49 * x ** 5
    elif 35 <= x < 104:
        f = x - (52 * x ** 2 + 52 * x ** 3) ** 4
    else:
        f = (87 * x ** 3) ** 7 + math.floor(x) ** 4
    return f"
"import math

def main(y):
    if y < -28:
        a = 7 * math.pow(y, 5)
        return a
    elif -28 <= y < 31:
        b = 7 * (math.pow(y ** 3 - 23, 4) + math.tan(y) ** 3) + 0.01
        return b
    elif y >= 31:
        c = 16 * y ** 15 - y ** 3 / 36 - math.atan(y)
        return c"
"def main(y):
    if y < 124:
        return y ** 7 / 42
    if 124 <= y < 210:
        return (54 * y ** 3) ** 5 + (y + y ** 2) ** 6
    if y >= 210:
        return 98 * (y - 1) ** 6"
"import math

def main(y):
    if y < 73:
        a = 7 * (y ** 3 + y + 1) - y ** 4 - y ** 2
    if y >= 73 and y < 173:
        a = 1 - 42 * (69 * y ** 2 - y) ** 3 - 44 * y
    if y >= 173 and y < 207:
        a = y ** 2 + 51 * math.floor(y) ** 4
    if y >= 207:
        a = 95 * math.atan(y) ** 6
    return a"
"import math

def main(x):
    if x < 45:
        return (67 * x ** 2) ** 6 - 16 * math.sin(x ** 3) ** 3
    elif 45 <= x < 127:
        return math.sin(64 * x ** 3) ** 6 - 61 * math.ceil((x ** 2 + x + 71) ** 7)
    else:
        return 90 * x ** 2"
"import math

def main(x):
    if x < -18:
        return 21 * (1 + 50 * x ** 2 + x ** 3) ** 5 - (x ** 2 - x ** 3) ** 7
    elif x < 1:
        return (74 * x ** 3 - 1) ** 6 + 42 * math.atan(x) ** 3
    elif x < 14:
        return 1 + math.cos(92 - 21 * x - 74 * x ** 2) ** 7
    elif x < 31:
        return 1 + x ** 7
    else:
        return 34 * (57 + x) ** 3 + 89 * (73 * x - x ** 3) ** 7 + math.log(1 + 75 * x + x ** 3) ** 2"
"from math import sin, log2, atan

def main(z):
    if z < 91:
        return z ** 7 - 36
    if 91 <= z < 159:
        return z ** 3 + sin(z) ** 7 + z ** 5
    if 159 <= z < 181:
        return 3 * (z ** 3 / 9 + 3 * z ** 2 + z) ** 7 - z - abs(z) ** 4
    if 181 <= z < 243:
        return 69 * (44 * z ** 2 + 1) - z ** 5 - log2(z) ** 2
    if z >= 243:
        return 11 * atan(62 * z ** 2 + z ** 3 + 53) ** 3 - 96 * (z ** 3 + 31) - z"
"import math

def main(y):
    if y < 179:
        return math.tan(y * y + 73 * y) ** 4 / 40 - (y * y / 43) ** 5
    elif 179 <= y < 232:
        return math.cos(97 * y ** 3 - y) ** 7
    elif 232 <= y < 291:
        return y ** 6 / 63
    else:
        return 2 * math.sin(0.03 + y + y * y) ** 4 + 1"
"import math

def main(x):
    if x < 148:
        return (63 * x ** 3 + 59 * x ** 2 + 70 * x) ** 3 - 82 * math.fabs(57 * x ** 3) ** 2
    elif 148 <= x < 185:
        return 66 * math.log(x, 10) ** 4
    elif x >= 185:
        return 1 - math.sqrt(x)"
"import math

def main(x):
    if x < 6:
        return x * x - 0.33 - 37 * x - 2 * math.exp(x) ** 7
    if 6 <= x < 22:
        return 46 * x ** 5 - 91 * math.log2(16 * x) ** 2
    if 22 <= x < 112:
        return 73 * x ** 7 - 1 - (0.01 + 97 * x ** 3 + x / 86) ** 5
    if 112 <= x < 185:
        return math.log(x) ** 4
    if x >= 185:
        return (97 * x * x - x) ** 3 / 17 + 1"
"def main(x):
    if x < -81:
        return 44 * (10 * x ** 2 - 30) ** 2
    if -81 <= x < -60:
        return x ** 7 + 17 * x ** 5
    if -60 <= x < -9:
        return 54 * x ** 2 - x ** 6
    if -9 <= x < 68:
        return 27 * x ** 5 - 97 * (88 * x ** 3) ** 4 - x ** 2
    if x >= 68:
        return 40 * (x * x + x + 52) + 69 * x * x + 47"
"import math

def main(x):
    if x < 102:
        return 95 * x ** 3 - math.sin(x ** 2 - x ** 3 - 52) ** 5 - 49 * math.log(x) ** 2
    elif x >= 102 and x < 168:
        return 10 * math.cos(1 - 98 * x ** 2 - x) + x ** 7
    elif x >= 168 and x < 221:
        return 40 * (1 + 18 * x ** 2 + x ** 3) ** 3 + x ** 2 + x ** 5
    elif x >= 221 and x < 282:
        return abs(x) + 31 * (1 + 53 * x ** 3) ** 5
    else:
        return x ** 5 - 30 * (x + x ** 3) ** 7"
"import math

def main(y):
    if y < 79:
        return math.sin(y) ** 2 - math.log(y) ** 7 - y ** 6
    if 79 <= y < 145:
        return 22 * math.cos(y) ** 3 + (80 * y ** 3 - 37 * y - 0.08) ** 2 + 75
    if 145 <= y < 211:
        return 48 * (54 * y ** 3 - 69) ** 4 + 73 * (1 - 51 * y) ** 6
    if y >= 211:
        return 86 * abs(y ** 2 + y ** 3) ** 2 - 56 * (74 - 76 * y) ** 5"
"import math

def main(x):
    if x < -28:
        return math.ceil(x ** 3 / 97 - 19 - x ** 2) ** 4
    elif x < 51:
        return 0.02 - (14 * x ** 3 - x / 77)
    elif x < 129:
        return 34 * math.exp(x) ** 2 + x ** 4 + 52 * x
    elif x < 184:
        return x ** 6 + 1 + x ** 21
    else:
        return x ** 6 - math.sin(x) ** 7"
"def main(y):
    if y < 28:
        return pow(1 + pow(y, 2), 5)
    elif y < 61:
        return 1 - 9 * pow(y, 3) - 65 * pow(y, 6)
    elif y < 156:
        return 99 * pow(y, 5)
    else:
        return pow(1 + pow(y, 2) + pow(y, 3), 5)"
"import math

def main(x):
    if x < -35:
        sum = x + math.pow(math.fabs(x), 2) + 33 * math.pow(x, 3)
    elif -35 <= x < 32:
        sum = 78 * math.pow(x, 5) + math.pow(math.ceil(math.pow(x, 2) - math.pow(x, 3)), 3) + 25 * math.pow(x, 4)
    elif 32 <= x < 127:
        sum = math.sin(x) ** 5
    elif 127 <= x < 201:
        sum = 37 * math.pow(x, 4)
    else:
        sum = 22 - 32 * math.pow(90 * math.pow(x, 3) + math.pow(x, 2) + x, 6) - 8 * math.pow(x, 5)
    return sum"
"import math

def main(x):
    if x < -71:
        s = 69 * math.floor(1 + x ** 3 + 41 * x ** 2) ** 5 + 17 * x ** 6 + x ** 8
    if -71 <= x < -41:
        s = 85 * math.log10(x ** 2) ** 5
    if -41 <= x < 56:
        s = 24 - x ** 6 - 79 * math.ceil(27 * x) ** 5
    if 56 <= x < 107:
        s = 21 * (58 * x ** 2) ** 4 + math.log2(96 + 91 * x ** 2) ** 2
        s = s + (x / 98 - 43 * x ** 3) ** 6
    if x >= 107:
        s = 15 * (x - 1 - x ** 3) ** 6 - 90 * x ** 2 - 29 * x ** 7
    return s"
"import math

def main(y):
    if y < 9:
        return (77 * y + 17 * y ** 2) ** 4 + y
    if 9 <= y < 77:
        return 42 * math.log2(76 * y ** 2 + 0.05 + y ** 3) ** 4
    if y >= 77:
        return (y - y ** 3) ** 4 - 71 * math.log10(y ** 3 + y) ** 7"
"import math

def main(z):
    if z < 89:
        res = math.cos(15 * z ** 3) ** 7 / 92 - 81
    elif 89 <= z < 172:
        res = (1 + 80 * z + 50 * z ** 3) ** 2
    elif 172 <= z < 206:
        res = 48 * (z ** 3 / 88 + z * z + z) ** 4 + ((1 + z / 45) ** 0.5) ** 3 + z * z
    elif 206 <= z < 268:
        res = (34 * z * z) ** 7 + 81 * (4 - z * z - 49 * z ** 3) ** 4 + z ** 5
    elif z >= 268:
        res = 21 * math.atan(z) ** 2
    return res"
"def main(x):
    a = 33 * x ** 5 - 70 * x ** 6
    b1 = 20 * (x ** 2 - x - x ** 3) ** 6
    b2 = (x ** 2 - x / 79) ** 7 / 42
    b = b1 + b2
    c = x ** 4 - (x ** 2 + 1 + x) ** 7
    if x < -31:
        return a
    elif -31 <= x < 39:
        return b
    elif x >= 39:
        return c"
"import math

def main(x):
    if x < 59:
        return math.tan(10 * x + 1 + x ** 3 / 78) / 64 - 32 * math.log2(x ** 2) ** 2 - 86 * (x - 61 - x ** 3) ** 3
    elif 59 <= x < 140:
        return (x ** 3 / 41 - 22) ** 2 + 70 * (x ** 3 + 65 * x + x ** 2) ** 7
    elif 140 <= x < 221:
        return 57 - x ** 2 - 28 * x ** 6
    elif 221 <= x < 249:
        return math.ceil(x) ** 7
    elif x >= 249:
        return math.sin(x) ** 3"
"import cmath

def main(y):
    if y < 15:
        return (60 * y - y ** 2 / 29 - 83 * y ** 3) ** 5 - (y + 64 + y ** 3) ** 6 / 57 - y ** 4
    elif 15 <= y < 31:
        return (45 * y ** 2) ** 4 / 19
    elif 31 <= y < 106:
        return 65 * y ** 3 - y
    elif 106 <= y < 175:
        return 20 * y ** 2 - y ** 4 / 91 - 15 * y ** 2
    elif y >= 175:
        return (y ** 3 + 60) ** 3"
"import math

def main(y):
    if y < 25:
        c = math.log(y ** 3, 2)
        a = c ** 3 + 98 * (12 * y ** 2 + 91 + 89 * y ** 3) ** 6
        return a
    elif 25 <= y < 45:
        n = y / 21 + 1 + y ** 3
        b = n ** 2 - 47 * (8 * y ** 2 + 1 + 17 * y ** 3) ** 5 - 1
        return b
    elif y >= 45:
        return 99 * y + 13 * y ** 2"
"import math

def main(y):
    if y < 0:
        f = (y ** 3 - y ** 2) ** 4
        return f
    elif 0 <= y < 99:
        f = 55 - 58 * (43 * y ** 3) ** 2 - 69 * y ** 3
        return f
    elif 99 <= y < 172:
        f = y ** 5 / 20
        return f
    elif 172 <= y < 189:
        f = 51 * abs(y ** 2) ** 2 - (42 * y) ** 4 - 1
        return f
    elif 189 <= y:
        f1 = 25 * (y ** 3 / 27 + 75 * y ** 2) - 67 * math.cos(y) ** 6
        f = (y ** 2 + 90 * y + y ** 3 / 85) ** 7 - f1
        return f"
"import math

def main(z):
    if z >= 180:
        return 22 * pow(z, 3) + 25 * z + pow(z, 2)
    elif z >= 164:
        return pow(z - pow(z, 2), 2) + 0.02 + pow(pow(z, 3) + 41 * z + 1, 7)
    elif z >= 144:
        return 99 * z - pow(41 * pow(z, 2), 6)
    elif z >= 52:
        return pow(z, 6) + 1
    else:
        return 47 * (32 * z + pow(z, 3) + 97) - pow(math.sin(54 * pow(z, 2) + 12 * pow(z, 3) + 33), 4) - 5 * pow(z, 5)
main(23)"
"import math

def main(z):
    if z < 69:
        res = z ** 6
    elif 69 <= z < 131:
        res = 81 * int(z) ** 7 - z ** 4
    elif 131 <= z < 198:
        res = 80 * z - z ** 3
    elif 198 <= z < 285:
        res = 1 + abs(z + 58 * z ** 2 + z ** 3) ** 7
    elif 285 <= z:
        res1 = 86 * (71 - 75 * z ** 3 - 56 * z) ** 5 + math.sqrt(z) ** 4
        res2 = math.log2(41 + z ** 3 + 80 * z) ** 7 / 11
        res = res1 + res2
    return res"
"def main(y):
    import math
    f = 0
    if y < -49:
        f = 79 * (21 * y + y * y + y ** 3) ** 6 + 1
    elif y < 2:
        f = 92 * math.atan(y ** 3 + y) ** 6
        f = f + 55 * y ** 6 + (y + y ** 3 + y * y) ** 3 / 40
    else:
        f = 23 * math.atan(1 + 97 * y ** 3 + y) ** 3 + 37 * math.log(y) ** 6
    return f"
"import math

def main(y):
    if y < 90:
        return (45 * y ** 2 + 73 * y) ** 6 + y ** 4 + 1
    elif 90 <= y < 104:
        return 16 + 32 * y ** 7 + (12 * y - 32 * y ** 2 - 1) ** 6
    elif 104 <= y < 199:
        return 22 * math.tan(35 * y ** 2 - 70) ** 3 - 16 * (75 * y ** 3) ** 5
    elif 199 <= y < 251:
        return 52 * (1 - 34 * y ** 3) ** 3
    elif y >= 251:
        return (73 * y ** 2 - y - 80) ** 4 - math.log10(y) ** 2"
"import math

def main(z):
    if z < 177:
        return z - 1 - 15 * math.log10(z) ** 4
    elif (z >= 177) & (z < 240):
        return math.ceil(z ** 2 - z ** 3)
    elif (z >= 240) & (z < 325):
        return 30 * math.sqrt(z) - 78 * math.atan(z + 1 + 6 * z ** 2) ** 7
    elif z >= 325:
        part1 = math.log2(1 + z / 10) ** 4 - 0.02
        part2 = 83 * math.atan(94 * z ** 3 - 21 * z ** 2 - 63 * z)
        return part1 - part2"
"from math import cos

def main(x):
    if x < 118:
        F = 8 * (7 * x - x ** 2 / 10) ** 3 - x - 32 * (x ** 3) ** 5
    elif x >= 118 and x < 172:
        F = x + 96 * (6 * x ** 3 + 93 * x) ** 2
    elif x >= 172:
        F = abs(x) ** 4 - 26 * cos(82 - x ** 3 / 48 - x) ** 3
    return F"
"import math

def main(y):
    if y < 103:
        f = y * y
    if 103 <= y and y < 128:
        f = 59 * pow(21 * y * y - y - 1, 4) + y * y / 11 + pow(y, 15)
    if 128 <= y and y < 146:
        f = pow(1 + y * y * y, 5)
    if y >= 146:
        f = y * y
    return f"
"import math

def main(y):
    if y < 24:
        return y ** 3 / 28 + (57 * y ** 3) ** 6 + 10 * y ** 7
    elif y < 118:
        return 83 * y ** 5
    elif y < 200:
        return (y ** 3 + 1 + y ** 2) ** 3
    elif y < 285:
        return 83 * (73 * y ** 2) ** 7 + (y ** 3 / 43 - y ** 2 - 1) ** 4
    else:
        return (y ** 3 - y) ** 5 / 36 - 55 * math.cos(y) ** 6"
"import math

def main(y):
    a = pow(math.log(pow(y, 3) + y + 35 * y * y, 10), 5)
    if y < 125:
        f = y * y + 38 * pow(y * y * y / 39, 6)
    elif 125 <= y < 147:
        f = y + 24 * pow(y, 3) + y * y - 1
    elif 147 <= y < 187:
        f = pow(y, 4) - pow(y, 6) - a
    elif y >= 187:
        f = 99 * pow(y, 4)
    return f"
"import math

def main(y):
    res = 0
    if y < 63:
        res = abs(y) ** 2 - 35 * y ** 5
    elif y >= 63 and y < 125:
        res = 40 * math.log(y, 10) ** 5 - math.log(y, 2) ** 6 - 31 * y ** 4
    elif y >= 125:
        res = (66 * y ** 2 + 42 * y ** 3 + 57 * y) ** 3
    return res"
"def bot_2(x):
    if x < 24:
        return (34 * x ** 2) ** 3 + 58 * x
    elif 24 <= x < 102:
        return 56 * x ** 5 + 95 * x ** 7 + 92 * (56 * x - 76 * x ** 3 - x ** 2) ** 4
    elif 102 <= x < 176:
        return 23 * x ** 7 + 74 * (1 + 69 * x)
    elif x >= 176:
        return x - 78 * x ** 5

def main(y):
    return bot_2(y)"
"def main(z):
    if z < 31:
        return 53 - 12 * z ** 7
    elif z >= 31 and z < 82:
        return 600 * z ** 3
    elif z >= 82 and z < 145:
        return 34 * (81 * z + z ** 2) ** 2 + 1 + 17 * (70 * z ** 3) ** 5
    else:
        return z"
"import math

def main(z):
    if z < 47:
        sum = 97 * math.pow(z, 12) - 98 * math.pow(90 + 48 * math.pow(z, 3) + z, 2)
    elif 47 <= z < 66:
        math.pow(15 * z - 1 - math.pow(z, 3), 5) / 51
    elif 66 <= z < 123:
        sum = (z / 58 - 54) / 36
    elif 123 <= z < 193:
        sum = math.pow(z, 6) / 29
    else:
        sum = math.pow(math.pow(z, 2) + z / 16, 2) + 1
    return sum"
"import math

def main(y):
    if y < -48:
        f = y ** 3
        return f
    elif (-48 <= y) & (y < -16):
        f = 20 * abs(y) ** 2
        return f
    else:
        f = y ** 7 + 1
        return f"
"def main(y):
    if y < 131:
        a = 84 * (y ** 3 / 21 + 99 * y ** 2 + 86) ** 4
        b = 72 * (11 * y - y ** 3 - 15 * y ** 2) ** 5
        return a + b
    if 131 <= y < 160:
        return y ** 3 + (y ** 3 / 16) ** 2
    if y >= 160:
        return y ** 6"
"import math

def main(z):
    if z < 130:
        return z ** 5 - z ** 6
    elif z >= 130 and z < 197:
        return z ** 4 / 96
    elif z >= 197 and z < 286:
        return math.log1p(16 * z ** 2 + 24 * z ** 3) ** 4 / 39 + z ** 6
    else:
        return (z ** 3 / 51 - z - 0.01) ** 4 - (67 + z ** 3 + z) ** 7 - 57 * (z ** 3 - 96) ** 3"
"import math
import sys

def main(z):
    if z < 80:
        res = z ** 6 - 45 * z ** 5
    elif z >= 80 and z < 91:
        res = 86 * (z / 77 - 1 - 99 * z ** 3) ** 7
    elif z >= 91 and z < 130:
        res = 36 * math.exp(z) ** 5 + z ** 6 + z ** 4
    elif z >= 130:
        res = (98 + 40 * z ** 2) ** 4 + 51 * z ** 6 + 48 * z
    return res"
"from math import pow, sqrt, atan

def main(x):
    if x < 100:
        return 94 * pow(x, 5)
    elif 100 <= x < 155:
        return x - sqrt(x) ** 3 - 0.02
    elif 155 <= x < 248:
        return pow(x - pow(x, 3) - pow(x, 2), 7)
    elif 248 <= x < 258:
        return 55 * (97 * x * x + 0.01) ** 5 + 36 * pow(x, 3)
    elif x >= 258:
        return 4 * atan(46 * x * x - 1) ** 5 - (70 * x * x * x) ** 3 - 86 * pow(x, 6)"
"import math

def main(y):
    a = y ** 3 + y ** 2 + 1
    b = 94 * math.log(y ** 3 + 1 + 82 * y ** 2) ** 3 - 89 * y ** 7
    c = 22 * math.sin(59 - y ** 2 - y ** 3) ** 4 + 72 * y ** 7
    d = (y + 84 * y ** 2) ** 2
    if y < -34:
        return a
    elif -34 <= y < 5:
        return b
    elif 5 <= y < 75:
        return c
    elif y >= 75:
        return d"
"import math

def main(z):
    if z < 180:
        f = 31 * z ** 5 - 62 * z ** 6 - 1
    elif 180 <= z < 190:
        f = z ** 3 + 83 * math.asin(z) ** 4 + 1
    elif z >= 190:
        f = 57 * (61 * z ** 3 + 41 * z ** 2 + 57) ** 4 - 1
    return f"
"import math
cos = math.cos
exp = math.exp
ln = math.log

def main(z):
    return {z < 116: pow(z, 4) / 15 + z * z / 8 + 23 * pow(cos(1 - z), 3), 116 <= z < 163: pow(ln(37 - z / 36), 6) + pow(z, 7) / 11, z >= 163: pow(z, 5) + 60 * pow(pow(z, 3) / 53 + 69 * z * z + 47, 7) + pow(exp(z), 4)}[True]"
"from math import atan, sqrt

def main(x):
    if x < 29:
        z = (48 * x ** 2 - 72 * x - x ** 3) ** 5 / 39 - x ** 7 / 67
    elif 29 <= x and x < 80:
        z = 29 * x ** 2 + 76 * x + 1
    elif 80 <= x and x < 105:
        z = x ** 5
    elif 105 <= x and x < 164:
        z = 5 * atan(x) ** 3
    elif x >= 164:
        z = 17 * x ** 4
    return z"
"import math

def main(y):
    if y < 101:
        return 67 * y ** 4 - 9 * y ** 6 - (y - 1) ** 3
    elif (y >= 101) & (y < 120):
        return math.exp(7 * y) ** 3 / 93 + 68 * y + 58 * y ** 2
    elif (y >= 120) & (y < 133):
        return 17 * math.tan(50 * y ** 3 + y)
    elif (y >= 133) & (y < 200):
        return y ** 5
    elif y >= 200:
        return y / 41 - 26 * (y ** 2 + 0.17) ** 2"
"import math

def main(z):
    if z < 43:
        result2 = (z - 16 - z ** 3 / 85) ** 4 + z ** 7
    elif 43 <= z < 80:
        result2 = 39 * z ** 2 - 1
    elif 80 <= z < 171:
        result2 = 56 * math.log(3 + z ** 2 + z / 55) ** 2 - (z + 19 * z ** 3 + z ** 2)
    else:
        result2 = (88 * z ** 2 + 44 * z ** 3) ** 3
    return result2"
"import math

def main(y):
    if y < 32:
        return y ** 3
    elif (y < 46) & (y >= 32):
        return y ** 6 - 44 * (1 - 39 * y ** 3 - 7 * y ** 2) ** 7 - 87 * y
    elif y >= 46:
        return 49 * math.cos(y) ** 4"
"import math

def main(x):
    if x < 154:
        return math.pow(x, 7) - math.pow(x, 3)
    if x >= 154 and x < 236:
        return x / 22 + 1
    if x >= 236 and x < 294:
        r1 = 57 * math.pow(x * x - 57 * x - 26, 3)
        r2 = 88 * math.pow(83 * x * x * x + 42 * x * x + x, 6)
        r3 = 68 * math.pow(math.log10(66 * x * x + 29 + 28 * x * x * x), 7)
        return r1 - r2 - r3
    if x >= 294:
        return 63 * math.pow(math.log10(x), 2)
    return 0"
"def main(z):
    if z < 84:
        return z ** 3
    elif z >= 84 and z < 156:
        return z ** 15 - (83 * z ** 2) ** 6 - 71 * z ** 2
    else:
        return 70 * z + z ** 3 + 47 * (73 * z ** 2 + z / 45) ** 2"
"import math

def main(y):
    if y < -24:
        return y ** 6
    elif -24 <= y < 62:
        return y ** 5 - y ** 4 - math.log(y) ** 3
    elif 62 <= y < 107:
        return 84 * y ** 3 - 41 + 34 * (26 * y ** 3 - 56 * y ** 2) ** 3 + math.floor(y) ** 5
    elif 107 <= y < 185:
        return 59 * y - 65 * y ** 3
    elif y >= 185:
        return 80 * math.tan(y) - 1 - 24 * y ** 4"
"from math import *

def main(z):
    if z < 86:
        res = 80 * (76 * z ** 2 - z - 77) ** 3
    elif 86 <= z < 179:
        res = 79 * abs(z) ** 5
    elif 179 <= z < 195:
        res = z ** 2
    elif z >= 195:
        res = atan(91 * z ** 2 + 1 + 40 * z ** 3) ** 4
    return res"
"import math

def main(x):
    if x < 195:
        return 31 * (1 + 30 * x ** 2 + x) - 0.02
    elif 195 <= x and x < 241:
        return 86 + 7 * math.log(x, 2) ** 7 + 42 * (x ** 3 - 1 - x ** 2) ** 6
    else:
        return (1 + 79 * x) ** 7"
"import math

def main(z):
    if z < 103:
        sum = math.pow(98 * z, 5) / 30 - math.pow(math.ceil(math.pow(z, 3) / 82 - 60), 4) - z
    elif 103 <= z < 113:
        sum = 64 * z + 96 * math.pow(z - math.pow(z, 3) - 72, 4)
    elif 113 <= z < 133:
        sum = math.pow(math.pow(z, 3) - math.pow(z, 2) / 49 - 68, 6) + math.pow(z, 4) + math.pow(math.exp(z), 3)
    elif z >= 133:
        sum = math.pow(math.pow(z, 3) / 3 - 0.05 - math.pow(z, 2), 4) + 1
    return sum"
"import math

def main(y):
    if y < 86:
        return y ** 6 / 27 - 86 * y ** 4
    if 86 <= y < 136:
        return y ** 2 - 45 * y - 1 - 10 * y ** 4
    if y >= 136:
        return 5 * (10 * y ** 3 - y) ** 6"
"from math import log10, tan, log

def main(y):
    if y < 134:
        return y ** 2 - 52 - 93 * (y ** 0.5) ** 6
    if 134 <= y < 203:
        return 96 * log10(y) ** 5 + log(y) ** 3
    if 203 <= y < 214:
        return 62 * (y ** 3 + 0.01) - 1
    if y >= 214:
        return tan(32 * y ** 2) ** 2 - 5 * y ** 7 - 30 * y ** 6"
"import math

def main(y):
    if y < 12:
        s = 10 * (98 - 78 * y - 75 * y ** 2) ** 3
    elif y >= 12 and y < 66:
        s = 80 * (38 * y ** 2) ** 3 + 47 * math.log(y) ** 2 + 92
    elif y >= 66:
        t = (0.03 + 85 * y ** 2 + y ** 3) ** 3
        s = t + math.fabs(y ** 2 + 1 + 66 * y ** 3) ** 2 / 90 + 22 * y ** 5
    return s
main(-1)"
"from math import pow, ceil

def main(x):
    if x < 130:
        first_value = 15 * pow(x, 3)
        second_value = pow(13 * pow(x, 3) - 1 - pow(x, 2), 5)
        return first_value - second_value
    if x < 209:
        return 70 * pow(ceil(x), 5)
    return pow(x, 2) + 72"
"import cmath
import math

def f(x):
    if x < 76:
        a = 1 + x
    if x >= 76 and x < 94:
        a = 95 * (26 * x ** 3) ** 2 + 78 * x ** 5
    if x >= 94:
        a = 55 * math.ceil(x ** 3 + 84 * x ** 2) ** 4
    return a.real

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

def main(z):
    if z < 95:
        return z ** 7 + 9 * log(z, 2) ** 4
    elif z < 133:
        return 11 * (4 * z ** 3 - 1) ** 4 - (91 * z ** 3) ** 7 - 13 * (92 * z + 31) ** 3
    elif z < 152:
        return z ** 3
    else:
        return 20 * (6 * z + 42 * z ** 2) ** 4"
"from math import log2, log10, atan, sin, log

def main(z):
    if z >= 229:
        return (z ** 2 + z ** 3 / 90) ** 2 + 82 * (13 * z - z ** 3 - z ** 2 / 2) ** 7
    elif z >= 146:
        return 74 * z - 28 * log2(z) ** 7 - 43
    elif z >= 100:
        return 93 * z + log10(z) ** 7 + z ** 4
    elif z >= 36:
        return 64 * z ** 2 + log10(z) ** 6 + z ** 3
    else:
        return 42 * atan(z) ** 3 + sin(52 * z ** 2 - 1 - 74 * z ** 3) ** 6 + 89 * log(1 + z ** 3 + 32 * z ** 2) ** 2"
"import math

def main(z):
    if z < 8:
        return 42 * math.pow(75 * z * z, 7) + 43 * z
    elif 8 <= z < 20:
        return 83 * math.pow(z + z * z * z, 7) - 16 * math.pow(63 * z * z * z + 22 * z * z + z, 4) - math.pow(math.fabs(z), 2)
    elif z >= 20:
        return 9 * math.pow(1 + z * z + z * z * z / 88, 2) + 6 * math.pow(math.sin(98 * z - z * z * z - 67), 6)"
"from math import exp

def main(z):
    if z < -4:
        return 24 + (0.05 - 89 * z ** 3 - 51 * z) ** 7
    elif -4 <= z < 27:
        return (99 - 46 * z) ** 6 + (13 * z ** 3 + z ** 2 / 34) ** 7
    elif 27 <= z < 105:
        return 40 * (16 * z - z ** 3 - 0.01) ** 3
    elif 105 <= z < 121:
        return 41 * z ** 3 + 1
    elif z >= 121:
        return exp(z) - 1 - 69 * (68 - z) ** 7
    else:
        return None"
"import math

def main(z):
    if z < 136:
        return z ** 4 - 78 - 99 * z ** 21
    if 136 <= z and z < 172:
        return (z / 22 - 0.08) ** 6
    if z >= 172:
        return math.sin(z) ** 2 - 40 * abs(z) ** 4 - (z ** 3 + 40 + z ** 2) ** 3"
"import math

def main(x):
    if x < 111:
        return abs(x) ** 3 - abs(x) ** 7 / 5
    elif 111 <= x < 198:
        return 88 * x - 0.1 - x ** 7
    elif 198 <= x < 270:
        return 55 * math.tan(x - 92 - x ** 3) ** 5
    elif 270 <= x < 356:
        return 57 * abs(12 * x ** 3) ** 2 - 1 - (39 - x) ** 6 / 77
    elif x >= 356:
        a = math.log(16 * x ** 3 + x ** 2) ** 3
        b = 34 * math.log10(x) ** 5
        c = (73 * x + x ** 3 / 41 + 1) ** 4 / 65
        d = a + b + c
        return d"
"import math

def main(y):
    if y < 79:
        return 13 * y ** 5 + 88 * (11 * y + 1 + y ** 2) ** 2
    elif y < 138:
        return 29 * math.tan(y) ** 7 - (94 * y + 41 + y ** 3) ** 5 - 84 * y ** 6
    elif y < 167:
        return 69 * y - y ** 12 / 90 - (y ** 3 - 1) ** 4
    elif y < 263:
        return 82 * (4 * y ** 3 - 1 - 11 * y ** 2) ** 6
    else:
        return y ** 4 + (y ** 2 / 13) ** 7 + 5 * y ** 3"
"import math

def main(x):
    if x < -57:
        pow1 = math.pow(14 * math.pow(x, 3) - 17 * math.pow(x, 2) - 92 * x, 5)
        return pow1 + math.pow(x, 2) + math.pow(x, 3) + 88 * x + math.pow(math.cos(x), 7)
    if -57 <= x < -10:
        return 47 * math.pow(math.log10(74 + math.pow(x, 2)), 2)
    if -10 <= x < 63:
        return 75 + 36 * math.pow(abs(33 * math.pow(x, 3) - 34 * x), 4)
    if 63 <= x < 81:
        return pow(pow(x, 2) + 17, 7)
    if x >= 81:
        return pow(42 * pow(x, 2), 5) - 1 - pow(x, 6) / 95"
"import math as m

def main(z):
    if z < 184:
        x = 44 * z ** 7 - m.log(z, 10) ** 6 - (z - 6 * z ** 3) ** 2
    elif 184 <= z < 274:
        x = 16 * (47 + z / 90) ** 6 + 67 * z ** 7
    else:
        x = m.sin(z) ** 7 + 1
    return x"
"import math

def main(z):
    if z < 66:
        return 71 + 15 * (1 + z ** 3) ** 5
    if 66 <= z < 83:
        return 41 * z ** 5
    if 83 <= z <= 170:
        return 37 * (z ** 2 - 89 * z ** 3 - 76 * z) ** 6 - math.cos(z)
    if 170 <= z < 199:
        return 31 * math.tan(z) ** 3 - z ** 4
    if z >= 199:
        return z ** 4 / 56 + 31 * z ** 7"
"def main(y):
    import math
    if y < 114:
        a = 70 * math.atan(43 * y * y) ** 6 - 74 * (70 * y * y * y - 59) ** 7 - math.log(55 * y ** 3) ** 3
        return a
    if y >= 114 and y < 159:
        a = (68 - y * y / 72 - 9 * y) ** 6
        return a
    if y >= 159 and y < 243:
        a = 4 * y ** 6 + 32 * y ** 5
        return a
    if y >= 243 and y < 253:
        a = 49 - y * y - y ** 7
        return a
    a = 21 + math.log(y) ** 6 + 45 * (0.01 - y ** 3) ** 4
    return a"
"def main(y):
    if y < 90:
        return y ** 4 / 55 - 33
    elif 90 <= y < 166:
        return 42 * (75 * y ** 2 - 1 - 53 * y) ** 2
    elif 166 <= y < 192:
        return 82 * y ** 6 + 11 * y ** 2 + (y + 65 * y ** 3 + y ** 2) ** 3
    elif y >= 192:
        return 66 * (62 * y ** 3 + y) ** 2 - 1 - 2 * y ** 6"
"def main(y):
    if y < 52:
        x = 46 * y ** 5 - 26 * y ** 8
    if 52 <= y < 86:
        x = 84 * y ** 3 - y - 89 * y ** 2
    if 86 <= y < 141:
        x = 57 * y ** 12 - 86 * y
    if 141 <= y < 200:
        x = y ** 5
    if y >= 200:
        x = 1 - y ** 2 - (93 - 37 * y - 53 * y ** 3) ** 4
    return x"
"from math import sqrt, acos, atan, ceil, pi

def main(x):
    match x:
        case x if x < 119:
            return 69 * x ** 3 - 23 * sqrt(x) ** 4 - 1
        case x if x in range(119, 140):
            return pi / 2 - atan(x) + (x + 95 * x ** 3) ** 6 + acos(x) ** 3
        case x if x in range(140, 226):
            return x ** 7
        case x if x >= 226:
            return 36 * ceil(x) ** 5 - 1"
"import math

def main(x):
    if x < -3:
        return 72 * math.tan(23 * x ** 3 + 1 + x ** 2) ** 5 + (1 - x ** 3) ** 6
    elif x >= -3 and x < 50:
        return 97 * x - 93 * math.atan(x) ** 4 - 1
    elif x >= 50 and x < 133:
        return abs(12 * x + 1 + x ** 3) ** 6 / 28 + 86
    else:
        return (x ** 2 / 80 + 66 * x) ** 2 / 70 - 1 - x ** 5"
"from math import *

def main(x):
    if x < 120:
        f = 56 - pow(10 * pow(x, 2) - 69 - pow(x, 3) / 78, 6)
        return f
    elif 120 <= x < 149:
        f = pow(x, 5) / 65 - 32 * pow(x, 4) - x
        return f
    elif 149 <= x < 198:
        f = 80 + 54 * x + pow(x, 2)
        return f
    elif x >= 198:
        f = 81 * pow(95 - 59 * x, 4) + 0.01
        return f"
"import math

def main(y):
    if y < 121:
        return y ** 4 - y ** 2
    elif y >= 121 and y < 142:
        return (y / 35) ** 5 + 1 + 19 * (1 + y ** 2) ** 4
    elif y >= 142 and y < 176:
        return math.tan(y) + y ** 2
    else:
        return 17 - math.log(37 * y ** 2 + 40, 2) ** 2 - y ** 5"
"from math import *

def main(y):
    if y < 0:
        f1 = (y ** 2 - y - 1) ** 5
        return f1
    elif 0 <= y <= 94:
        f2 = log10(29 * y ** 3 - y ** 2 / 78) + 44 * y ** 2 + 90 * y ** 5
        return f2
    elif 94 <= y <= 170:
        f3 = 17 * y ** 4 + 82 * y ** 3
        return f3
    elif y >= 170:
        f4 = 82 * (y ** 2 + y ** 3 + y) ** 4
        return f4
    if _name_ == '_main_':
        main(*args)"
"def func1(x):
    a1 = (37 + x ** 2) ** 7
    a1 = a1 + x ** 4 / 48
    a1 = a1 + ((6 + 79 * x ** 3 + 5 * x) ** (1 / 2)) ** 6
    return a1

def func2(x):
    a1 = x ** 6 / 40 - 48 * x ** (1 / 2) - x ** 5
    return a1

def func3(x):
    return 18 * x ** 6

def main(x):
    if x < 106:
        return func1(x)
    elif x < 175:
        return func2(x)
    else:
        return func3(x)"
"from math import *

def main(z):
    if z < 17:
        f1 = 1 + 65 * z ** 6
        return f1
    elif 17 <= z < 51:
        f2 = z - 37 * (1 + z) ** 6
        return f2
    elif 51 <= z < 97:
        f3 = 51 * sin(z) ** 6
        return f3
    elif 97 <= z < 127:
        f4 = 3 * z ** 3 + z ** 6
        return f4
    elif z >= 127:
        f5 = 90 + (0.01 - 95 * z - z ** 2) ** 6
        return f5
    if _name_ == '_main_':
        main(*args)"
"import math

def main(y):
    if y < 167:
        x = 83 + (1 - 76 * y ** 2 - 89 * y ** 3) ** 7 + 8 * y ** 3
        return x
    if 167 <= y < 254:
        x = 48 * y ** 4
        return x
    if 254 <= y < 271:
        x = y ** 6 / 76
        return x
    if 271 <= y < 368:
        x = 0.01 + 55 * y - 12 * (90 * y ** 2) ** 4 - 97 * y ** 7
        return x
    if y >= 368:
        x = math.tan(82 * y ** 3 + 17 * y ** 2) ** 3 + 89 * (y - 13) ** 6
        return x"
"import math

def main(x):
    if x < 112:
        a = x ** 2 / 33 + 1 + x
        b = math.log(a) ** 2
        f = 85 - 20 * x ** 5 - b
        return f
    elif x >= 112 and x < 164:
        d = (10 * x ** 3 + 0.02 + x ** 2) ** 2
        e = d / 71
        g = 84 * math.fabs(34 * x ** 3 + x ** 2) ** 7
        f = e + 60 * x ** 5 + g
        return f
    else:
        f = x ** 2
        return f
main(35)"
"def main(z):
    if z < 64:
        f = 85 * z ** 7 + (28 * z ** 2 - z) ** 2 + 60
        return f
    elif 64 <= z < 75:
        a = 94 * z ** 4 + 15 * z ** 2
        b = 46 * (59 * z ** 2 + 84 * z ** 3) ** 3
        f = a + b
        return f
    elif 75 <= z < 122:
        f = z ** 7 - 0.02 - (z / 92 - z ** 3) ** 6
        return f
    elif 122 <= z < 206:
        f = 92 * z ** 2 + (0.02 - 84 * z ** 2 - z ** 3 / 45) ** 7
        return f
    elif z >= 206:
        f = (z ** 2 - z) ** 2 + (1 - z) ** 4 + 32
        return f
main(36)"
"def main(y):
    if y < 151:
        a = 1 - 22 * y ** 2 - y ** 3 / 78
        b = 8 * (y ** 3 / 2 + 80 * y + 55 * y ** 2) ** 6
        f = a - b
        return f
    if 151 <= y < 231:
        g = 92 * (y ** 3 + 40 + 60 * y) ** 5
        j = (62 * y ** 2 + 54 * y ** 3 + 94) ** 3
        f = g + j
        return f
    if 231 <= y < 246:
        f = (87 * y ** 2 + 58 * y) ** 7 - 76 * y ** 2
        return f
    if y >= 246:
        f = y ** 18 - (1 + 90 * y + 25 * y ** 2) ** 3
        return f
main(146)"
"from math import log

def main(y):
    if y < 136:
        return 79 * log(y) ** 6 + 90 + (1 + y ** 2 / 13 + 37 * y) ** 4
    elif y < 191:
        return (1 - y) ** 3 - 44 - 89 * y ** 2
    else:
        return (1 + 67 * y ** 2) ** 6 + (90 * y + y ** 3 + y ** 2) ** 7"
"import math

def main(z):
    if z < 109:
        return (z + z ** 3 / 49 + 38) ** 5 + math.atan(z) ** 6
    if 109 <= z < 173:
        return 79 * math.log(z) ** 6 - 83 * z ** 7 - z ** 5
    if 173 <= z < 273:
        return 45 * z ** 3
    if 273 <= z < 319:
        return z ** 5 + z ** 4
    if z >= 319:
        return math.sin(8 * z + 83 * z ** 2) ** 3 / 86 + 5"
"import math

def main(y):
    if y < -50:
        return 24 * pow(y, 5) - y
    elif y < 44:
        return (0.04 - y) ** 5
    elif y < 58:
        return (89 - y ** 3 - 3 * y ** 2) ** 5
    elif y < 135:
        return (y + 0.01) ** 7 - 66 * y ** 5
    else:
        return y + pow(math.log(y), 5) + 1"
"import math

def main(y):
    if y < 169:
        return 99 * math.atan(y) - pow(y, 3)
    if 169 <= y < 213:
        return pow(y, 3) + 17
    if y >= 213:
        return pow(y, 6) / 29 + 96 * pow(pow(y, 3) + y / 11 + 0.02, 7)"
"def main(y):
    import math
    f = 0
    if y < 34:
        f = 40 * y ** 4 - math.exp(1 - 59 * y ** 2 - y) - 65
    elif y >= 34 and y < 56:
        f = y ** 4 + math.tan(y) ** 2
    elif y >= 56 and y < 74:
        f = math.log(y ** 2 / 35 - 1) / 38
    elif y >= 74 and y < 146:
        f = 35 * (y ** 3 - 98 * y ** 2 - 5) ** 4
    else:
        f = 3 * y ** 5 - 59
    return f"
"import math

def main(z):
    if z < 138:
        return 53 * math.atan(29 * z ** 3 - 1) ** 6 + 87 * (72 * z) ** 3
    elif 138 <= z < 176:
        return z ** 2 / 33
    elif 176 <= z < 223:
        return 69 * z ** 7
    elif z >= 223:
        return z ** 4 - z ** 3"
"import math

def main(z):
    if z < -59:
        first = (z ** 2 - z ** 3) ** 2 - (50 * z ** 3 + 16) / 42
        return first
    elif -59 <= z <= -15:
        second = 26 * z ** 2 + 80 * (41 * z ** 3 - z) ** 7 + 42
        return second
    elif -15 <= z < 36:
        third = math.sin(z) ** 2
        return third
    elif z >= 36:
        fourth = 37 * z ** 4 + math.tan(z) ** 3
        return fourth"
"import math

def main(z):
    if z < 74:
        f = 5 - 96 * z ** 87
        return float('%.2e' % f)
    elif 74 <= z < 159:
        f = (35 * z ** 3 + 58 * z) ** 5 - 10 * z ** 2 - (53 * z ** 3) ** 4
        return float('%.2e' % f)
    elif 159 <= z < 252:
        f = (1 - 88 * z ** 3 - z ** 2) ** 2 + math.log10(z) ** 7
        return float('%.2e' % f)
    elif 252 <= z < 313:
        f = 69 * math.log(z) ** 2
        return float('%.2e' % f)
    elif z >= 313:
        f = 7 * z ** 3 + z ** 2 / 56 + 0.03 + 89 * math.log10(40 * z + 2 + 44 * z ** 2) ** 5 + 69 * z ** 4
        return float('%.2e' % f)"
"from math import pow, sin

def f(x):
    result = 0
    if x < 96:
        result = 19 - pow(x ** 3 / 8, 4) - 25 * pow(69 * x ** 2 - 95 * x, 2)
    elif x < 157:
        result = 87 - 22 * sin(0.02 + x) ** 7
    else:
        result = 56 * x ** 6
    return float('{:.2e}'.format(result))
main = f"
"import math

def main(x):
    if x < 58:
        x = 92 * (x ** 3 / 52 - 4 * x ** 2 - x) ** 3 + 38 * x ** 4 + 99 * x
        return x
    elif 58 <= x < 107:
        x = x ** 6 / 49 + 84 * x
        return x
    else:
        x = 8 * (32 * x ** 3 - 86 * x) ** 4 - math.log(x, 2) ** 2 - math.tan(x) ** 5
        return x"
"import math

def main(y):
    if y < -8:
        return float(y ** 3 / 99 - y ** 7)
    elif y >= 50:
        return float(95 * math.cos(y + 14 * y ** 3 + 20 * y ** 2) ** 7)
    else:
        return float(math.ceil(1 - 59 * y ** 2) ** 6 / 57 + 40 + y)"
"import math

def main(x):
    if x < 75:
        return math.exp(x) - 56 - (x ** 2 + x) ** 7
    elif 75 <= x < 166:
        return 21 * x ** 3
    elif 166 <= x < 243:
        return 25 * math.log(x) ** 6 + x ** 5
    elif x >= 243:
        return x"
"import math

def main(y):
    if y < 43:
        a = y ** 7 / 4 + 8 * y ** 4
        return a
    elif 43 <= y < 102:
        b = (y ** 3 + y ** 2 / 44) ** 4 + 0.04 + y ** 2
        return b
    elif 102 <= y < 183:
        c = 7 * math.tan(y - 13 * y ** 2) ** 6
        return c
    elif 183 <= y < 213:
        d = 41 * y + 72 * math.ceil(y) ** 2
        return d
    elif y >= 213:
        e = (y ** 2 + 1) ** 2
        return e"
"import math

def main(z):
    if z < 8:
        return 2 * math.log(39 * z * z + 70) - 1
    if 8 <= z < 44:
        return z - pow(math.log(z), 2)
    if 44 <= z < 58:
        return 96 * pow(z, 3) + pow(z, 4) + z - z * z - 36 * pow(z, 3)
    if 58 <= z < 135:
        return 39 * pow(z, 12)
    if z >= 135:
        return 55 * pow(z * z / 17 - 23 * pow(z, 3), 7)"
"from math import cos

def main(y):
    if y < 4:
        return 84 * y - 31 * pow(cos(y), 6)
    elif y >= 35:
        return 69 * pow(y, 3)
    else:
        return 15 * pow(y, 7) - pow(0.01 - pow(y, 3), 4)"
"import math

def main(y):
    if y < -65:
        a = y * y / 22 - 88 - pow(42 * y - 36 * y * y * y, 3)
        return a
    elif y >= 21:
        b = 5 * y * y - pow(26 + 19 * y * y, 3) / 11
        return b
    else:
        c = 56 * pow(y * y * y / 84 - 1 - y * y, 7)
        return c"
"from math import ceil, cos

def main(y):
    if y < 187:
        return pow(64 * y ** 3, 6)
    if y >= 235:
        return 9 * cos(y) ** 6 - 60 * ceil(33 * y ** 2 - 1 - y)
    else:
        return cos(y) - 8 * pow(y ** 3 / 53 + y ** 2 + 53, 7)"
"import math

def main(z):
    if z < 109:
        return 38 * math.pow(z, 4)
    elif z >= 109 and z < 123:
        return 60 * math.pow(math.exp(10 * z - math.pow(z, 2), 3) - math.pow(math.exp(z), 6))
    elif z >= 123 and z < 219:
        return math.pow(z, 4) - 69 * math.pow(math.pow(z, 2) - 39 * z - 76 * math.pow(z, 3), 7)
    elif z >= 219 and z < 263:
        return math.pow(z, 5) + math.tan(1 + 16 * z) + 89 * math.pow(z, 3)
    elif z >= 263:
        return 69 * math.pow(1 - math.pow(z, 2), 3)"
"import math

def main(y):
    if y < 29:
        return 7 * pow(math.exp(y), 7) - 18 * pow(math.exp(y), 3)
    elif 29 <= y < 87:
        return 69 * pow(y, 7)
    elif 87 <= y < 110:
        return 14 * pow(y, 2) - pow(math.atan(pow(y, 3) / 58 + 1), 5)
    elif 110 <= y < 175:
        return 69 * (0.01 - 91 * y) - 10 * pow(y - 1, 3)
    elif y >= 175:
        return pow(pow(y, 2) + 89, 6) / 23 - pow(16 * y - 14 * pow(y, 2), 3) - pow(y, 5)"
"import math

def main(x):
    if x < 34:
        return 62 * math.log2(x) ** 5
    elif 34 <= x < 124:
        return (x ** 3 + 19 * x + 60 * x * x) ** 5
    else:
        return (49 * x ** 3 + 77) ** 4"
"import math

def main(x):
    if x < 4:
        x1 = abs(57 - 54 * (x * x)) ** 5
        x2 = 62 * (x ** 3 + 1 + 38 * (x * x)) ** 6
        return x1 - x2
    elif 4 <= x and x < 84:
        x1 = 12 * (x * x + 1) ** 4 + 1
        return x1
    elif x >= 84:
        x1 = 25 * math.cos(x) ** 5 + 1
        return x1"
"def main(z):
    if z < 94:
        return 75 + 31 * z ** 2
    if 94 <= z < 191:
        return z ** 3
    if 191 <= z < 254:
        return (z ** 2 - z ** 3 - 1) ** 7 - 1 - 43 * (1 - z ** 2) ** 5
    if z >= 254:
        return z ** 3 - abs(43 * z ** 3 + 0.02 + 3 * z) - (45 * z ** 2 + z) ** 7"
"import math

def main(y):
    a = y ** 2
    if y < 15:
        y = abs(y) ** 2
    elif y >= 15 and y < 28:
        y = math.log(97 * y ** 3 - a) ** 6 - 1
    elif y >= 28 and y < 57:
        y = y ** 3
    elif y >= 57 and y < 119:
        y = (38 + a / 87 + y / 62) ** 4 - (y - 59 * y ** 3) ** 5
    elif y >= 119:
        y = 34 * (65 * y + y ** 3 + 1) ** 6
    return y"
"from math import cos

def main(z):
    if z < 115:
        return 22 * z ** 7 - 4182 * z
    elif 115 <= z < 147:
        return 81 * z ** 2
    elif 147 <= z < 198:
        return 1 - z - 10 * cos(z ** 3 + 40) ** 7
    elif 188 <= z < 297:
        return 97 * z ** 3 - 53 * z ** 6
    else:
        return z ** 5"
"def main(x):
    if x < -49:
        return x ** 3
    elif -49 <= x < 36:
        return (x - 77 * x ** 3 - x ** 2) ** 5 + 67 * (x ** 3 - 97) ** 2
    elif x >= 36:
        return 1 - x / 75"
"import math

def main(z):
    if z < -40:
        return (z ** 2 + 80 * z) ** 5 / 60
    elif -40 <= z and z < 29:
        return 1 - z ** 3 / 58 - math.asin(z / 81) ** 6
    elif -29 <= z and z < 119:
        return 84 * z ** 6
    elif 119 <= z and z < 206:
        return 60 * z ** 5
    else:
        return math.fabs(43 * z) ** 3 - z"
"import math

def main(z):
    if z < 20:
        k = 69 * z - pow(z, 3) - 98 * pow(z, 2)
        f = pow(z, 3) + pow(z, 2) / 55 + z + pow(k, 7)
        return f
    if z < 57:
        f = 53 * pow(pow(z, 2) + 27, 7) + 41 * pow(math.log(z), 6)
        return f
    if z < 124:
        f = pow(z, 5)
        return f
    if z < 161:
        f = 78 + 20 * z
        return f
    if z >= 161:
        f = pow(36 * pow(z, 3) + pow(z, 2), 2) / 29
        return f"
"from math import *

def main(z):
    if z < -7:
        return pow(58 * pow(z, 2), 3) / 96
    elif z >= -7 and z < 12:
        return 36 * pow(log(7 + 19 * pow(z, 2)), 7) + pow(z, 5)
    elif z >= 12:
        return 44 * sin(pow(z, 2) + 98 * pow(z, 3))"
"import math

def main(y):
    if y < -51:
        return 41 * pow(10 * pow(y, 3), 5)
    if -51 <= y < 4:
        return pow(y, 2) + 22 * y
    if 4 <= y < 77:
        return 68 * pow(y, 6)
    if y >= 77:
        return 0.01 - 60 * pow(y, 2)
main(121)"
"from math import tan

def main(y):
    if y < 79:
        f1 = tan(22 * y ** 2 - y - 45 * y ** 3)
        f = f1 - 20 * (67 * y ** 2) ** 6 - 1
    elif 79 <= y < 132:
        f = (50 * y ** 3) ** 6 / 11 + y ** 2 - 1 - y ** 3
    elif 132 <= y < 215:
        f = 6 * (13 * y ** 2 - 66 * y - y ** 3) ** 3
    elif y >= 215:
        f1 = 77 * (98 * y ** 2 - y / 66 - 91 * y ** 3)
        f = f1 + y ** 2 + 86 * (1 - y ** 3 - y / 38) ** 6
    return f"
"import math
import array

def f1(x):
    return (72 * x ** 15 - 6 * (6 * x) ** 7) / (76 * (1 - x - 89 * x ** 2) ** 4 - 1) + 49 * x ** 2

def f2(y):
    if y < 39:
        return (46 + 61 * y ** 3) ** 5
    elif 39 <= y < 126:
        return 76 * math.floor(y - 93 - y ** 3 / 11) ** 3 + 1
    elif 126 <= y < 218:
        return 19 * (39 * y ** 3 - 0.04 - 74 * y ** 2) ** 6 + 72
    elif 218 <= y < 281:
        return 77 * y ** 5 + 35 * y ** 3
    return y ** 7

def sum(f, start, end):
    s = 0
    for i in range(start, end + 1):
        s += f(i)
    return s

def f3(m, z, a, y):
    return sum(f=lambda k: k ** 2 - 97 * z ** 3 - math.ceil(z) ** 7 / 94, start=1, end=m) + sum(f=lambda k: 76 * math.floor(y - 93 - k ** 3 / 11) ** 3 + 1, start=1, end=a)

def f4(n):
    if n == 0:
        return 0.26
    elif n == 1:
        return 0.14
    return 5 * f4(n - 2) ** 2 + f4(n - 1) / 78 + f4(n - 2) ** 2 + 1

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 f2(n)"
"import math

def main(y):
    if y < 110:
        return 52 * (y - y ** 3 / 26 - 1) ** 2 - 92 - y ** 4
    elif y >= 110 and y < 148:
        return 84 * (y / 17 + y ** 2)
    elif y >= 148 and y < 248:
        return 21 * math.log10(y) ** 3 + y ** 7
    else:
        a = 65 * (1 - y ** 2) ** 6
        return a + math.log(16 * y ** 3) ** 3 + 91 * y ** 5"
"import math

def main(x):
    if x < 31:
        return (45 * x ** 3) ** 5 - math.ceil(93 * x) ** 2
    elif 118 > x:
        return x ** 5 + 67 * math.sin(x) ** 2
    else:
        return (38 * x ** 2 - x ** 3 - x / 59) ** 7"
"import math

def main(x):
    if x < -64:
        return pow(x + 21 * pow(x, 3) + 34, 7)
    elif 11 > x >= -64:
        return 9 * pow(56 * x, 4)
    elif 11 <= x < 67:
        return pow(x, 2) - 20 * pow(x * x - 40, 6) - pow(x, 4)
    elif x >= 67:
        return math.atan(x) - pow(x, 4)"
"def main(x):
    if x < 113:
        return 14 + 20 * pow(x, 7) + 88 * pow(28 * x - 98 * pow(x, 3), 3)
    elif 113 <= x < 123:
        return 81 * abs(1 - pow(x, 2) / 82) + 59 + 66 * pow(1 - 59 * x - 8 * pow(x, 2), 2)
    else:
        return pow(x, 6) + 99 * pow(pow(x, 3) - 1, 3) + 83 - pow(x, 3) - pow(x, 2)"
"import math

def main(x):
    if x < 4:
        return x ** 6 + 20 * math.sin(x)
    elif 4 <= x < 66:
        return (1 + 74 * x ** 2) ** 4 + 75 + 88 * math.log(x) ** 6
    elif 66 <= x < 155:
        return x * x / 78 - math.atan(x) ** 6
    elif 155 <= x < 166:
        return x ** 5 + 0.01
    elif x >= 166:
        return math.log(1 + 42 * x ** 3 + 14 * x ** 2, 2) ** 5"
"import math

def f(y):
    if y < -74:
        return 41 * (88 + 45 * y) ** 2 + 50 * y ** 6
    elif -74 <= y < -26:
        return (72 * y - y ** 3 - 1) ** 7 / 4
    elif -26 <= y < -4:
        return 0.01 - 19 * (28 - 43 * y ** 3 - 78 * y) ** 5 - 96 * y ** 2
    else:
        return 85 * y ** 7

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

def main(x):
    if x < 20:
        return 1 + x + 42 + x ** 2 / 96 + x ** 3
    elif 20 <= x < 84:
        return 24 * abs(x ** 3 + 11 * x) ** 7
    elif 84 <= x < 161:
        return (92 * x ** 2) ** 5 + 0.02 + math.atan(x) ** 4
    elif 161 <= x < 240:
        return (36 + x ** 2) ** 6
    elif x >= 240:
        return 3276 * x"
"import math

def main(z):
    if z < -23:
        f = (z ** 3 / 71) ** 7
    elif -23 <= z < 42:
        f = 18 * z ** 5
    elif 42 <= z < 63:
        f = 3 * z ** 2 + 35 * math.tan(z) ** 5
    elif 63 <= z < 100:
        f = (z / 82 - z ** 3 / 40 - 99 * z ** 2) ** 7 + z ** 8
    else:
        f = 9 * math.atan(z) ** 7 + 11 * (3 * z ** 2 + 88 + z) ** 2 + 57
    return f"
"def main(y):
    if y < 153:
        a = 21 * (1 + y ** 3 / 9 + 88 * y) ** 5
    elif 153 <= y < 200:
        a = 71 * (0.01 + 2 * y ** 2 + y ** 3) ** 4 + (39 - y ** 2) ** 3
    elif y >= 200:
        a = (y - 96 * y ** 2) ** 6
    return a"
"import math

def main(y):
    if y < 33:
        return 19 * math.cos(y / 74 - 1 - y ** 2) ** 2 - 79 * math.atan(32 * y) ** 5
    elif 33 <= y < 119:
        return 32 * (y / 32 - 4 * y ** 2) ** 7 - 81 * math.ceil(y)
    elif 119 <= y < 129:
        return math.tan(y) ** 7
    elif 129 <= y < 160:
        return y ** 12 - 1 - y ** 4
    else:
        return 46 * y + y ** 3 - math.ceil(94 * y) ** 2"
"import math

def main(y):
    res = 0
    if y < 173:
        res = math.log2(y ** 3) ** 4 - (y ** 3 - 60 * y ** 2 - 64) ** 3
    elif 173 <= y < 201:
        res = 19 * (1 + 47 * y ** 3) ** 4
    elif 201 <= y < 267:
        res = 31 * (64 * y ** 2) ** 4 - 26 * (y ** 2 / 96) ** 3
    elif y >= 267:
        res = 78 * math.sqrt(y) ** 3 - 70 * (40 * y ** 3 - y - 1) ** 6
    return res"
"import math

def main(x):
    if x < 65:
        return res1(x)
    elif x < 86:
        return res2(x)
    elif x < 114:
        return res3(x)
    elif x < 126:
        return res4(x)
    else:
        return res5(x)

def res1(x):
    return (1 + x ** 2 / 48 + x) ** 6 + 1

def res2(x):
    return math.exp(x) ** 7 - (1 - x ** 3 / 9) ** 3

def res3(x):
    return 30 * x ** 2 - 14 * (0.03 + 85 * x ** 3 + x ** 2) ** 5

def res4(x):
    return math.sin(x) ** 4 - 41

def res5(x):
    return (41 * x ** 3) ** 6 + 31 * (5 * x ** 2 + 31 * x ** 3) ** 4"
"from math import log, tan

def main(z):
    if z < 53:
        output = 1 + z ** 2
    elif z < 91:
        output = 31 * z + log(z) ** 4 + 65 * (z ** 2 - 58 * z ** 3) ** 3
    else:
        output = z ** 6 - tan(z) ** 2
    return output"
"def main(x):
    if x < 100:
        return 6 + x ** 5 + x ** 2
    elif 100 <= x < 131:
        return x ** 2 / 94 + 62 * abs(x ** 3 + x ** 2 / 45) ** 4
    elif 131 <= x < 150:
        return (x ** 3 / 79 + x) ** 3 / 38
    elif x >= 150:
        return 87 * (x ** 2 / 69) ** 7"
"from math import *

def main(x):
    if x < -36:
        return 44 * log2(x - x ** 3) ** 6 + 91 * abs(22 + x * x) ** 5
    elif x >= -36 and x < 14:
        return (x ** 3 / 80) ** 2 + 29
    elif x < 31 and x >= 14:
        return (71 * x ** 3) ** 4 - 90 * x ** 3
    elif x < 98 and x >= 31:
        return (x ** 3 - x - 1) ** 6 / 36
    elif x >= 98:
        return x ** 7 - 24 - ceil(4 * x ** 3 + x * x) ** 6"
"import math

def main(y):
    if y < 4:
        fy = 35 * y ** 15 - math.tan(y) ** 2
    if 4 <= y < 59:
        b1 = 1 + 42 * y + y ** 2
        b2 = y ** 2 - 87 * y ** 3 - y
        fy = b1 ** 3 + 72 * b2 ** 2
    if y > 58:
        c1 = abs(y ** 2 + 63)
        c2 = y - 1 - 85 * y ** 3
        fy = y ** 4 / 97 + 42 * c1 ** 3 + c2 ** 5
    return fy"
"import math

def main(y):
    if y < 91:
        ans = math.log(y) - pow(y, 3) - 1
        return ans
    elif 91 <= y < 139:
        ans = pow(math.cos(y), 3) - y
        return ans
    elif 139 <= y < 236:
        ans = 0.01 - y
        return ans
    elif y >= 236:
        ans = math.log(y + y ** 2 + 55 * y ** 3)
        return ans"
"from math import log10

def main(z):
    if z < 82:
        res = (z ** 2 - 33 * z ** 3 - 1) ** 5 + 11 * z ** 4 + 82 * (22 * z ** 2 + 90 * z ** 3 + 23)
        return res
    elif 82 <= z < 177:
        res = z ** 2
        return res
    elif 177 <= z < 235:
        a = log10(5) * (z ** 3 - 46 * z ** 2 - 1)
        b = (z ** 3 + 27 + z) ** 2 - (41 * z ** 3 - 99 * z - z ** 2) ** 6
        res = a + b
        return res
    elif 235 <= z < 264:
        res = z ** 2 - z ** 6 - z ** 3 / 73
        return res
    elif z >= 264:
        res = z ** 10
        return res"
"import math

def main(x):
    if x < 33:
        return 28 * x ** 7 + 99 * abs(x) ** 3
    if 33 <= x < 79:
        return x / 42 - 7 * x ** 3 - x ** 2
    if 79 <= x < 95:
        return math.floor(25 * x ** 2 - 16 * x ** 3) ** 6 + 81 * (33 * x ** 3 - 6 * x ** 2) ** 2 + 94 * abs(x ** 3 - 64 * x) ** 3
    if x >= 95:
        return (31 * x ** 2 - x) ** 6"
"import math

def main(z):
    if z < 106:
        return z - math.log(11 * z ** 2 + z ** 3 + 1) ** 5 - 33 * z ** 6
    if 106 <= z < 170:
        return math.atan(z) ** 6 - 34 * (1 + z ** 3 + z) ** 2
    if 170 <= z < 252:
        return z ** 5 - 69 * math.tan(45 * z + 69 * z ** 2 + 1) ** 6 - 88 * abs(z) ** 7
    if z >= 252:
        return 85 - 15 * math.sin(z) ** 5"
"from math import log

def main(z):
    if z < 78:
        return (49 * z ** 3) ** 7 - (z * z + z ** 3 / 74) ** 3 / 72
    elif z >= 122:
        return z ** 5
    else:
        return 35 * log(z * z) ** 2 + 37 * z ** 3 + 90 * z * z - 79"
"import math

def main(y):
    if y < 176:
        return 48 * math.log10(y) ** 5 + 38 * (78 * y ** 3 + 8) ** 2
    elif y < 261:
        return 10 * y ** 3 - y ** 6 - (y / 69 - 4 * y ** 2) ** 5
    elif y < 358:
        return 55 * (30 + y / 73 + 20 * y ** 3) - 90 * math.sin(46 * y ** 3 - 1 - 83 * y ** 2) ** 6
    elif y < 424:
        return 73 * math.fabs(y) ** 2 - 1 - 81 * y ** 5
    else:
        return 90 * y - 62 * y ** 2 - y ** 3"
"from math import tan as tg
from math import cos as cos

def main(x):
    if x < 134:
        a = cos(91 * x ** 3 + 0.02 + 7 * x) ** 4
        b = 43 * cos(x ** 3 - 1 - x ** 2) ** 2
        return a + b
    elif x < 175:
        return x ** 3 + x ** 2 + 48 * x
    elif x < 275:
        return 54 + 16 * (32 + x + x ** 2) ** 6
    elif x < 362:
        a = 14 * x ** 4 + 8 * tg(x ** 2) ** 3
        b = (33 + x ** 3 + 39 * x ** 2) ** 2
        return a + b
    else:
        return 4 * (x ** 3 + x * x + 56) ** 2 - 46"
"import math

def main(x):
    res = 0
    if x < 3:
        res += 26 * math.tan(x) ** 5
    if 3 <= x < 58:
        res += (1 + x ** 2) ** 4 - x ** 3 / 27
    if 58 <= x < 138:
        res += (47 * x ** 3 + x ** 2 + 22 * x) ** 3 / 48 + math.cos(x) / 24 + 1
    if x >= 138:
        res += 65 * math.tan(x) ** 5 - x ** 6 - math.floor(x ** 2 + 39 * x ** 3 + x)
    return res"
"import math

def main(y):
    if y < 27:
        result = y ** 7 - y
    elif 27 <= y < 90:
        result = 39 - (y + 1) ** 5 / 66
    elif 90 <= y < 160:
        result = math.log(y ** 2 + y ** 3) ** 7 - math.cos(y ** 2 + y ** 3 + 51 * y) ** 2
    else:
        result = (19 * y + 1) ** 3 + 26 * y ** 2
    return result"
"def main(x):
    if x < 78:
        return 1 + x ** 7
    elif x >= 78 and x < 154:
        return 49 * x ** 2 - 0.02 - 14 * (63 * x ** 2 - 36 * x)
    else:
        return x ** 7 + 8 + (x ** 2 / 49 - 83 * x) ** 4"
"import math

def main(y):
    if y < 81:
        f = math.log10(y) ** 3
    elif 81 <= y < 117:
        f = 68 * math.floor(63 - 55 * y) ** 2 - 8 * y ** 3 - 53 * (53 * y + 1) ** 7
    elif 117 <= y < 194:
        f = y ** 6
    elif 194 <= y < 218:
        f = 99 * math.cos(y ** 3 - 43 * y ** 2) ** 2 - 57 * y ** 3 / 8 - 30 * y ** 4
    else:
        f = math.log2(y) ** 4 - math.log2(y) ** 7 / 15
    return f"
"import math as m

def main(y):
    if y < -32:
        return y ** 5 + 44 * (17 * y ** 2 - y / 68 - 90) ** 3
    if y >= -32 and y < 60:
        return 25 * (84 * y - 1) ** 7
    if y >= 60 and y < 100:
        return 65 * y ** 5
    if y >= 100:
        return 42 * m.log10(21 * y) ** 7 + 54 * y ** 3"
"import math as m

def main(z):
    if z < 159:
        return 26 * z ** 6
    if z >= 159 and z < 198:
        return m.atan(9 - 25 * z - z ** 3) ** 3 + 37 * (16 * z ** 3 - z - 43 * z ** 2) ** 5 + 60 * (1 + z ** 3) ** 7
    if z >= 198 and z < 287:
        return (1 + z) ** 7 + 76 * m.sin(z)
    if z >= 287:
        return (39 * z ** 3 + 27 * z ** 2 + 80) ** 2"
"def main(x):
    if x < 75:
        return 1 + 74 * x ** 7 + 53 * x ** 4
    elif 75 <= x < 155:
        return x ** 7 + 87 * (13 * x ** 3) ** 6
    elif x >= 155:
        return 25 * (1 + x ** 2 + x) ** 7"
"from math import ceil

def main(z):
    if z < 84:
        return 74 * abs(96 + z / 68 + z ** 3) ** 2 - z
    elif 84 <= z < 111:
        return (51 - 5 * z - z ** 2) ** 3
    elif 111 <= z < 163:
        return z ** 7 + 12 * z ** 5
    else:
        return 46 * ceil(1 + z ** 3) ** 2 + 83 * z ** 3"
"import math

def main(y):
    return {y < 88: pow(y + 1 + y * y * y / 22, 6) + 91, 88 <= y < 138: 73 * pow(math.atan(y), 5) - 1, 138 <= y < 234: 81 - 2 * y * y * y, y >= 234: 1 + 83 * pow(round(41 * y * y * y - 0.02), 6)}[True]"
"import math

def main(x):
    if x < 113:
        return float(x ** 2 / 91)
    elif 113 <= x < 187:
        return float((64 * x ** 2) ** 3 + 96 * (1 + 59 * x) ** 5)
    elif 187 <= x < 283:
        return float(x ** 2 - 30 * (55 * x ** 2) ** 4)
    elif 283 <= x < 312:
        return float(19 * (1 - 37 * x ** 3 - x) ** 4 - 58 * math.cos(1 - 80 * x - 57 * x ** 3) ** 7)
    else:
        return float(98 * (x ** 2 / 52 - 8 - 83 * x ** 3) ** 5 - x ** 6)"
"import math

def main(y):
    if y < 111:
        return 85 + (y ** 3 / 43 - 50 * y * y) ** 3 + y ** 7 / 93
    elif 111 <= y < 127:
        return (27 * y ** 3) ** 4 + y ** 3 / 98
    elif 127 <= y < 189:
        return 77 * (33 + y ** 3) - 26 * y ** 4 - math.log10(y) ** 2
    elif y >= 189:
        return 18 * (y * y / 46 + 0.01) ** 6 + 1"
"import math

def main(z):
    if z < 124:
        return 67 * (45 * z - 15 * z ** 2 - 0.02) ** 7 - 15 * math.cos(z - 29) ** 5
    elif 124 <= z < 211:
        return math.tan(z) ** 5 / 19 + abs(57 * z ** 2 - 36 * z ** 3 - 15 * z)
    elif 211 <= z < 272:
        return 29 * z ** 7
    elif 272 <= z < 362:
        return math.atan(z ** 2 / 9) ** 3 - 62 * z ** 7 - (60 * z ** 3 - 9 - 48 * z) ** 5
    elif z >= 362:
        return 6 * z ** 7"
"import math

def main(z):
    if z < 78:
        return 26 * math.log(65 * z) - 19 * math.cos(1 + 41 * z ** 3 + 64 * z ** 2) ** 5
    if z >= 78 and z < 142:
        return z ** 7 / 20
    if 142 <= z and z < 181:
        return math.log10(z ** 2 + 41 + z ** 3) / 42
    if z >= 181:
        return z"
"import math

def main(x):
    if x < 134:
        f = pow(7 + pow(x, 2), 6) + pow(math.tan(x), 2)
    if x >= 134 and x < 232:
        f = (91 * x ** 3 - 1) ** 2 / 70
    if x >= 232 and x < 252:
        f = x ** 4 + math.atan(x) ** 3 + pow(math.log(x, math.exp(1)), 6)
    if x >= 252 and x < 316:
        f = x ** 5 + 87 * x ** 7 + 1
    if x >= 316:
        f = (x - 62 * x ** 2 - 85 * x ** 3) ** 2 - 67 * x ** 4
    return f"
"import math

def main(y):
    if y < 55:
        y = 7 * (92 + y ** 2 / 98) ** 6
    elif 55 <= y < 100:
        y = 16 * y ** 2 + y
    elif 100 <= y < 176:
        y = 47 * y - 9 * y ** 5 - y ** 3
    else:
        y = 75 * math.log(1 + 93 * y ** 3 + y, 10) ** 3 + 98 * y ** 2
    return y"
"def main(z):
    if z < -24:
        return 69 - 73 * z ** 6
    elif z >= -24 and z < 62:
        return 10 * (87 - z - z ** 2) ** 4
    elif z >= 62 and z < 141:
        return 5 * z ** 6
    elif z >= 141:
        return z ** 4 + z ** 5 + 84 * z"
"import math

def main(x):
    a = 0
    if x < 110:
        a = 54 * pow(x + 8, 6)
    elif x < 142:
        a = pow(math.tan(pow(x, 3)), 3) / 57
    elif x < 220:
        a = pow(math.log(x, 10), 2)
    elif x < 249:
        a = 36 * pow(2 * pow(x, 2) + 48 + pow(x, 3), 4) - 11 * pow(x, 7)
    else:
        a = pow(x, 4)
    return a"
"from math import *

def main(x):
    if x < 117:
        x = pow(cos(74.0 + pow(x, 3) + x), 5) - 2.0
    elif x >= 117 and x < 149:
        x = pow(x, 2) + x / 67 - (1 - pow(x, 3) / 81 - pow(x, 3))
    elif x >= 149 and x < 199:
        x = pow(x + 71 * pow(x, 3) + 92 * pow(x, 2), 5) - pow(x, 3)
    elif x >= 199 and x < 263:
        x = 27 * x
    elif x >= 263:
        x = pow(tan(x), 4)
    return x
main(44.0)"
"def main(y):
    if y < 110:
        return 32 * y - 88 * (y ** 2 - 1 - 12 * y) ** 4
    elif y >= 110 and y < 209:
        return 3816 * y
    elif y >= 209 and y < 292:
        return 92 * (y - 1 - y ** 3) ** 2 + 0.14 + y ** 6
    elif y >= 292:
        return 4 * (90 * y) ** 4
'\n'"
"import math

def main(y):
    if y < 93:
        return 49 - math.atan(y) ** 2
    elif 93 <= y < 131:
        return 9 * (y ** 2 - 1 - 15 * y ** 3) + 97 * (73 * y ** 2 - 96 * y - y ** 3 / 89) ** 3 + y ** 5
    elif 131 <= y < 162:
        return 97 * math.tan(75 * y) ** 7 - 79 * (9 * y ** 3 + 0.02) ** 6 - math.exp(y) ** 4
    elif 162 <= y < 226:
        return 89 * (63 * y ** 2) ** 6 - (53 * y) ** 4
    else:
        return 69 * (y + 1 + 67 * y ** 2) ** 4 + (47 * y ** 3 + 37 * y ** 2) ** 5"
"import math

def main(x):
    if x < 69:
        return f1(x)
    elif 69 <= x < 161:
        return f2(x)
    elif 161 <= x < 177:
        return f3(x)
    else:
        return f4(x)

def f1(x):
    a = math.log(79 * x ** 3 - x ** 2) ** 3
    b = 25 * math.log10(x + x ** 3) ** 4
    c = (x ** 3 - 23 * x - 20) ** 5 / 95
    return a - b - c

def f2(x):
    return math.log(x ** 2) ** 3 / 60

def f3(x):
    return x ** 2 - x ** 6

def f4(x):
    a = x ** 6 / 18
    b = 54 * (x / 66 + x ** 3) ** 4
    c = x ** 2
    return a + b + c"
"from math import cos

def main(x):
    if x < 142:
        return (1 - x - x ** 3 / 40) / 52 + 1
    elif 142 <= x < 230:
        return 97 * cos(5 + 85 * x ** 3 + x) ** 6 - 93 * (x + x ** 3) ** 3 - 68 * (49 * x + 32 * x ** 2) ** 5
    elif 230 <= x < 304:
        return x ** 5 / 97 + (x ** 2 - 69 * x) ** 3
    elif x >= 304:
        return 94 * x ** 7 + x ** 4 + (x - x ** 3) / 99"
"import math

def main(z):
    if z < 96:
        one = 95 * pow(z, 2) - 76 * pow(math.sin(1 + 17 * z), 4) - 1
        return one
    elif 96 <= z < 134:
        two = pow(z + 46, 3) - 59 * pow(94 * pow(z, 2), 2)
        return two
    elif 134 <= z < 196:
        three = 23 * pow(z, 8) - 38 * z - pow(z, 7) / 90
        return three
    elif z >= 196:
        four = 69 * pow(z, 7) + pow(z, 6) + pow(5 - pow(z, 2), 3)
        return four"
"from math import *

def main(y):
    if y < 47:
        y1 = 79 + 18 * y ** 6 + (1 + y + y ** 3) ** 3
    elif 47 <= y < 123:
        y1 = y ** 6 / 2
    elif 123 <= y < 134:
        y1 = 38 * y ** 6
    elif y >= 134:
        y1 = floor(y) ** 7 - floor(y + y ** 2 + 26 * y ** 3) ** 4 / 30
    return y1
    if _name_ == '_main_':
        main(*args)"
"def main(y):
    if y < 123:
        return 1 - (y + 23 * y * y + 1) ** 5 - 3 * (52 * y ** 3 - y)
    if y >= 177:
        return (39 * y + 59 * y ** 3) ** 6 + 61 * y ** 5 + 0.01
    else:
        return 64 * y ** 5"
"import math

def main(z):
    if z < 109:
        return 81 * z ** 5 - 93 * math.log2(z) ** 3
    if 109 <= z < 161:
        return 96 * z ** 7
    if z >= 161:
        return 6 * z ** 3 + z ** 2 + 264 * z ** 3"
"import math

def main(z):
    if z < 152:
        return 71 - 47 * math.log(z) - 15 * (32 + z + 96 * z ** 2) ** 7
    elif 152 <= z < 240:
        return 41 * (1 + 8 * z ** 2) ** 6 - abs(1 + z) ** 4
    elif z >= 240:
        return (6 * z ** 3 - z ** 2) ** 6"
"import math

def main(y):
    if y < 85:
        return 14 * y ** 4 - math.log(y) ** 7 - 0.02
    elif 85 <= y < 164:
        return 42 * (y - 26 * y ** 2 - 0.02) ** 3
    elif 164 <= y < 244:
        return 43 * y ** 4
    elif 244 <= y < 311:
        return 49 * math.cos(32 * y ** 3) - y ** 7
    else:
        return y ** 5 - 38"
"from math import sin, log

def main(y):
    if y < -37:
        return pow(sin(pow(y, 2)), 6) - 36 * pow(y, 12) - 32 * pow(y, 3)
    elif -37 <= y < 6:
        return 46 * pow(y, 7)
    elif y >= 6:
        return 30 * pow(log(y, 10), 4) + 54 * pow(abs(y), 5) + 26"
"import math

def main(y):
    res = float
    if y < 72:
        res = 87 * math.exp(y) - 22 - y ** 7
    elif y < 145:
        res = y ** 2
    elif y < 161:
        res = 17 * y ** 3 + 70 + (78 + 38 * y + 13 * y ** 3) / 82
    elif y < 200:
        res = math.sin(y) ** 7
    else:
        res = y ** 2 - 14 * y ** 6
    return res"
"def main(x):
    if x < 99:
        return x ** 7
    elif 99 <= x <= 199:
        return x ** 5 - (x ** 2 - x ** 3 - 82) ** 2 - 35 * (x ** 2 + x ** 3) ** 7
    else:
        return 33 * (1 + x + x ** 2 / 99) ** 3 - 46 - x ** 6 / 81"
"from math import sqrt

def main(x):
    if x < -41:
        return 68 * x ** 4
    elif -41 <= x < 14:
        return 77 * (48 * x ** 2 - 64 * x - 24 * x ** 3) ** 2
    elif 14 <= x < 33:
        return (7 * x ** 3 + x) ** 4 - (x + 71) ** 5 - 74 * x ** 3
    elif 33 <= x < 94:
        return 36 * (28 + x ** 3) ** 4 + sqrt(x ** 3) + 46 * (73 + x ** 3) ** 3
    elif x >= 94:
        return (1 + x ** 2) ** 6"
"import math

def main(y):
    if y < -46:
        return (80 * y ** 3 - 93 * y ** 2 - 47 * y) ** 2
    elif -46 <= y < 32:
        return 13 * y ** 3 + (94 - y - y ** 2) ** 2 + y ** 6 / 72
    elif 32 <= y < 131:
        return y ** 2 / 82 - 54 * y ** 10 - y ** 6
    elif 131 <= y < 144:
        return y / 55
    elif y >= 144:
        return math.tan(y) ** 5 - y ** 3 - 76"
"import math

def main(y):
    s = 0
    x = 99 * y ** 3 - 76 * y - y ** 2
    if y < -13:
        s = 84 * (78 * y ** 3 - 33) ** 6 - y ** 7
    if -13 <= y < 10:
        s = 17 * y ** 6 - (53 * y ** 2 - 1) ** 7
    if 10 <= y < 73:
        s = 80 * x ** 3 + (34 * y ** 3 + 1) ** 5 + y
    if 73 <= y < 142:
        s = 73 * y ** 3
    if y >= 142:
        s = y - math.log2(y) ** 2 / 66 - math.log10(1 + 77 * y ** 3) ** 5
    return s"
"from math import *

def main(y):
    if y < -51:
        f = y ** 7
    elif y >= -51 and y < -25:
        f = sin(y ** 2 - y / 93 - y ** 3) ** 4 + sin(y + 34 * y ** 3 + 0.01) ** 3 + y ** 7 / 56
    elif y >= -25:
        f = (85 * y) ** 6
    return f"
"from math import log2

def main(y):
    if y < -43:
        return 87 * y ** 14 - y ** 3 - 3 * y ** 4
    elif -43 <= y < 40:
        return 72 * y
    elif 40 <= y < 84:
        return abs(y) / 55 - 14 * (1 - y ** 3 - y ** 2) ** 5
    elif 84 <= y < 105:
        return 93 * y ** 7
    else:
        return 21 * y ** 18 + 75 * log2(11 * y ** 2 - 12) ** 4"
"import math

def main(z):
    if z < -1:
        return math.ceil(pow(z, 3))
    elif -1 <= z < 86:
        return pow(math.sqrt(z), 3)
    else:
        return 98 * pow(pow(z, 3) / 83 + 28 * z + 23, 4)"
"import math

def main(z):
    if z < -2:
        sum = math.pow(z, 6) + math.pow(math.sin(z), 5)
    elif -2 <= z and z < 26:
        sum = 28 * math.pow(math.pow(z, 0.5), 3) - math.floor(z + math.pow(z, 2) / 58) / 54
    elif 26 <= z and z < 82:
        sum = 58 * math.pow(z, 14) + 62 * math.log(z)
    elif 82 <= z and z < 131:
        sum = 67 * math.pow(z, 3) + 1
    elif z >= 131:
        sum = math.pow(54 * math.pow(z, 3) + 76, 7)
    return sum"
"def main(x):
    if x < -29:
        return pow(pow(x, 2) + pow(x, 3), 6) + 81 * pow(x, 3)
    if x >= -29 and x < 24:
        return pow(17 * x, 2) / 95
    if x >= 24:
        return pow(x, 2)"
"from math import *

def main(y):
    if y < 145:
        return 79 * y ** 2 + 1 + 28 * y ** 5
    elif y >= 145 and y < 183:
        return (38 * y ** 3) ** 7
    elif y >= 183 and y < 239:
        return (y ** 2 - y ** 3) ** 2
    elif y >= 239:
        return y + 95 * sin(63 * y ** 2 + 54 * y + 11) ** 7"
"def main(z):
    return f(z)

def f(z):
    if z < 36:
        gt = z ** 4 + (z / 52 - z ** 2 - 0.03) ** 5
    elif 36 <= z < 68:
        g = 20 * (39 * z) ** 4 - (z ** 2 / 26 - z - 1)
        t = -12 * (12 - z ** 2 / 53 - z / 97) ** 7
        gt = g + t
    elif 68 <= z < 162:
        gt = 58 * z ** 6
    else:
        gt = 77 * (z ** 3 - 29) ** 5 + 53 * z ** 4 + 80
    return gt"
"import math

def main(x):
    if x < 126:
        return pow(x, 3) + pow(x, 2) + 15 * pow(pow(x, 2) - pow(x, 3) - 34 * x, 4)
    elif 126 <= x < 219:
        return 46 * pow(math.log10(11 * x), 3) - 36 * pow(x, 14) - 40 * (92 - pow(x, 2))
    else:
        return pow(math.atan(x), 7) - 38 * pow(x, 4)"
"import math

def main(y):
    if y < 62:
        return 4 * math.ceil(y) ** 6 + math.log(11 * y ** 2 + y) ** 7 / 63
    if 62 <= y < 158:
        return math.sin(y) + 93 * y + (18 * y + 0.04) ** 6
    if y >= 158:
        return (y + 1) ** 7 - 56 * math.ceil(y) ** 4"
"from math import sin, log10

def main(z):
    if z < 107:
        return (z - z ** 2) ** 3 + log10(z)
    if 107 <= z and z < 171:
        return sin(z ** 3 - 90 * z ** 2) ** 5
    if z >= 171:
        return 21 * z ** 4 - 46 * (z ** 3 + 21 * z ** 2) ** 3"
"import math

def main(x):
    if x < 110:
        return math.log(0.01 + 12 * x) ** 6
    if 110 <= x < 202:
        return 29 * x ** 7 + x ** 3 / 43 + 87 * math.sin(28 * x) ** 6
    if 202 <= x < 288:
        return 1 + (69 * x ** 2 - 53 - x) ** 3
    if x >= 288:
        return 54 * (31 + x / 42) + x ** 6 + (84 * x ** 2 + 32) ** 4"
"import math

def main(x):
    if x < 17:
        f = (0.02 - 74 * x) ** 7 + 48 * x + 93 * math.tan(7 * x ** 2) ** 2
    elif 17 <= x < 50:
        f = x ** 3 / 19 - math.cos(60 * x ** 2 + x) ** 5
    elif 50 <= x < 89:
        f = 1 + x + 99 * (11 * x ** 2 + x + 38 * x ** 3) ** 5
    elif 89 <= x < 132:
        f = 92 * abs(x) ** 6
    elif x >= 132:
        f = math.atan(1 + x ** 2 + x) ** 3 + 43 * x ** 4
    return f"
"def main(x):
    if x < -12:
        return x ** 3
    elif x < 16:
        return 29 * x - 10 * (58 * x ** 2 - 1 - x ** 3) ** 4 - 0.02
    return (26 * x ** 2 - x ** 3 / 45 - 28) ** 3 - 44 * (40 * x ** 2 - x ** 3)"
"import math

def func(x):
    if x < -24:
        return x ** 4
    elif -24 <= x < 21:
        return x ** 6
    elif x >= 21:
        return math.sin(x) ** 4 - 72 * x ** 3 - 7 * x ** 7

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

def main(z):
    if z < 158:
        return 47 * (z ** 0.5) ** 4
    if 158 <= z < 206:
        return 69 * (z ** 3 / 31) ** 5 + 27 * z - 81 - 33 * z ** 2
    if 206 <= z < 293:
        return 94 * (z + z ** 3) ** 7
    if 293 <= z < 304:
        return (0.02 + 41 * z + z ** 2) ** 7 - 96 * (z ** 2 - 71) ** 2
    if z >= 304:
        return 17 * abs(z) ** 7 - 38"
"from math import floor

def main(x):
    if x < -5:
        return floor(x ** 2) ** 6 - 85 * (54 - 10 * x ** 2) ** 5 - 52 * x ** 3
    elif x < 58:
        return x ** 7 / 7 - 46 * (x - 1) ** 6 - 1
    elif x < 131:
        return 28 * (84 * x ** 3) ** 6 - x ** 7
    else:
        return x ** 6 / 4"
"import math

def main(z):
    if z < 183:
        return z ** 3 - z ** 4 - 70 * (44 * z ** 3) ** 6
    if 183 <= z < 253:
        return abs(z) ** 2 - 57 * math.atan(z) ** 3
    if 253 <= z < 277:
        return 63 * (58 * z ** 3) ** 3 - math.cos(z) ** 7 / 56
    if 277 <= z < 305:
        return (z - z ** 2) ** 7 + math.exp(z) ** 6 + 91 * z
    if z >= 305:
        return math.log(z ** 2 / 35 - z) ** 2 / 45 + 90 * math.log2(z ** 3 - 2) ** 4 + 62 * z ** 5"
"import math

def main(x):
    if x < 152:
        return 53 * x ** 5 + x ** 6 + (32 * x + 15 * x ** 2) ** 3 / 69
    if x < 189:
        return 94 * (25 * x + x ** 2) ** 2
    return (41 - 42 * x) ** 3 - math.ceil(x) ** 4 - 61 * (1 - x ** 3 - x ** 2 / 21)"
"import math

def main(z):
    if z < 12:
        a = (1 + 7 * z ** 3 + z) ** 3 + 1 + 61 * z ** 6
        return a
    elif 12 <= z < 39:
        a = z ** 7 + abs(21 * z ** 2 - 31) ** 6 + 0.02
        return a
    elif 39 <= z < 97:
        a = z ** 5 + z ** 6 + (91 * z ** 3) ** 4
        return a
    elif z >= 97:
        a = z ** 3 / 4
        return a"
"import math

def main(z):
    if z < 173:
        return z ** 4
    elif z < 264:
        return 94 * pow(58 * z, 6) - pow(math.tan(z), 7)
    elif z < 304:
        return pow(z, 3)
    elif z < 362:
        return 1 - 81 * pow(z, 3 / 2) - 7 * pow(z, 4)
    else:
        result = pow(math.atan(95 - z * z - z ** 3), 3) / 41
        result -= pow(z / 33 - 68 - 90 * z * z, 7)
        return result"
"import math

def main(z):
    scob1 = z ** 3 + 3 * z ** 2 + 1
    one = 63 * math.log(scob1) + 33 * (79 * z ** 3) ** 3
    two = 77 * z ** 5
    three = 34 * z ** 6 + z ** 5
    if z < 125:
        return one
    elif 125 <= z and z < 167:
        return two
    else:
        return three"
"import math

def main(y):
    if y < -24:
        return y ** 6 / 23 - math.cos(y - y ** 2 - 33) ** 5 / 42 - y ** 4
    if -24 <= y < 29:
        return (1 + 43 * y + 59 * y ** 2) ** 6 / 13
    if 29 <= y < 68:
        return math.sin(y) ** 6 - y ** 2
    if 68 <= y:
        return (60 * y ** 3 + 13 * y) ** 5 + math.floor(y ** 3) ** 3 + 53 * (5 + y + y ** 2)"
"import math

def main(x):
    if x < 43:
        ans = 47 * math.tan(x) ** 5 + math.log(x, 2) ** 6
    elif 43 <= x < 108:
        ans = (63 * x ** 3) ** 3 - 58 * int(x) ** 6
    elif 108 <= x < 163:
        ans = 70 * (x - 39 - 15 * x ** 3) ** 6
    else:
        ans = 76 * x ** 2
    return ans"
"import math

def main(x):
    if x < 148:
        num = 60 * (71 + x / 81) ** 7
    elif 148 <= x < 176:
        num = x ** 7
    elif 176 <= x < 212:
        num = x ** 4
    elif 212 <= x < 285:
        num = 97 * (21 * x ** 3 + 36) ** 2 - 1 - x ** 4
    elif x >= 285:
        num = x / 11 - 1
    return num"
"import math

def main(z):
    if z < -7:
        return math.tan(z * z) ** 4 + z ** 5 + 85 * math.exp(z) ** 6
    elif z < 33:
        return z + z ** 6
    elif z < 90:
        return (11 - 94 * z - 96 * z ** 3) ** 3 / 89
    elif z < 185:
        return 15 + math.log2(z) ** 4 + z
    elif z >= 185:
        return 8 * math.sin(z) ** 7 + 75 * z ** 5"
"import math as m

def main(x):
    if x < 21:
        return x
    elif 21 <= x < 73:
        return 1 - 25 * x ** 4
    else:
        return m.log(1 - x / 96, m.e) ** 7"
"from math import log2

def main(y):
    if y < 157:
        return 22 * (y ** 2 / 60 + 14 * y ** 3) ** 5
    elif y < 233:
        return 22 * abs(y) - 66 * log2(57 * y ** 3) ** 2
    else:
        return 8 * y ** 4 - (y ** 2 / 52 - 16) ** 3"
"import math

def main(y):
    if y < 65:
        return 85 * (y + y ** 3) ** 4 + 55 + math.tan(y) ** 5
    elif y >= 65 and y < 89:
        return y / 3 + y ** 5 + 13 * (20 - y ** 3) ** 7
    elif y >= 89 and y < 129:
        return y ** 3
    else:
        return math.sqrt(y) ** 5"
"import math

def main(y):
    if y < 23:
        return (y + 47) / 23
    if 23 <= y < 112:
        return 22 * (36 * y ** 3 - 81)
    if 112 <= y < 148:
        return 85 * (y ** 3 / 45) ** 3 + 69 * math.log2(y) ** 6
    if y >= 148:
        return (40 * y ** 3 - y) ** 3 - 51 * (y ** 3 - 1)"
"import math

def main(x):
    if x < 105:
        return math.tan(x) ** 6
    if 105 <= x < 147:
        return x ** 5 / 60 + 81 * x ** 2 + (x ** 3 - x) ** 6
    if 147 <= x < 176:
        return 67 + (56 * x ** 3 - 65 * x) ** 2 / 4
    if 176 <= x < 248:
        return math.atan(x ** 2 / 98 - x ** 3 - 1) ** 5
    if x >= 248:
        return 38 * math.tan(x) ** 4 + 91 * x ** 5"
"import math

def main(x):
    if x < 27:
        one = 40 * (1 - x) ** 6 - math.tan(x) ** 7
        return one
    elif 27 <= x < 123:
        two = x / 99 - 39 * x ** 6
        return two
    elif x >= 123:
        three = 23 * (48 + x) ** 6
        return three"
"import math

def main(z):
    if z < -59:
        z = pow(z, 3)
    elif -59 <= z < -17:
        z = 58 - pow(math.cos(9 * pow(z, 3) + 0.11 + pow(z, 2) / 28), 5)
    elif -17 <= z < 22:
        z = 35 * pow(z, 2) + 80 + 37 * z
    elif z >= 22:
        z = pow(21 * pow(z, 2), 4)
    return z"
"import math

def main(y):
    if y < 70:
        return 9 * (33 - 98 * y - 29 * y ** 2)
    if y < 162:
        return 72 * math.sin(y) ** 3
    return y + math.log(y) ** 4"
"from math import log, tan, ceil

def main(x):
    if x < 101:
        return 1 + pow(x / 48, 4) + 4 * pow(x, 3)
    elif 101 <= x < 151:
        left_term = 90 * pow(pow(x, 2) + 1 + x, 7)
        right_term = 19 * pow(log(pow(x, 2) + x + 1), 3)
        return left_term + right_term
    elif 151 <= x < 172:
        left_term = pow(tan(88 * x + pow(x, 3) + pow(x, 2)), 4)
        return left_term - pow(x, 10)
    elif 172 <= x < 254:
        left_term = 44 * pow(1 + pow(x, 2), 3)
        right_term = 31 * pow(abs(pow(x, 3)), 2)
        return left_term - right_term
    elif x >= 254:
        return 42 * pow(x, 2) - 41 * pow(ceil(x), 5)"
"import math as m

def main(y):
    if y < 181:
        f = y ** 4 + abs(y) ** 2
    if 181 <= y < 246:
        f = m.log10(y) ** 5 + (30 * y - y ** 3 - y ** 2 / 83) ** 3
    if 246 <= y < 305:
        f = m.sqrt(y)
    if y >= 305:
        f = 40 * m.sqrt(92 * y ** 3) + y ** 3
    return f"
"import math

def main(y):
    if y < 42:
        return 32 * (1 + 53 * y ** 3 + 57 * y ** 2) ** 5 + y ** 7
    elif 42 <= y < 97:
        return 94 + 26 * y ** 5
    elif 97 <= y < 186:
        return math.ceil(y) ** 3
    else:
        return 52 * y ** (3 / 2) + y ** 7"
"import math

def main(z):
    if z < 161:
        return (z + z ** 3) ** 3 + 1 + z ** 2 + z ** 3 / 54
    if 161 <= z < 198:
        return z ** 5 - z ** 3 - 29 * z ** 12
    if 198 <= z < 275:
        return 50 * z ** 14
    if z >= 275:
        return 57 * (0.01 - 26 * z ** 2 - 40 * z ** 3) ** 3 - z
    else:
        return 0"
"def main(y: int):
    if y < 156:
        return y ** 4
    elif y >= 168:
        return (91 * y ** 3) ** 6
    else:
        return 48 * (y ** 3 - 45 * y - y ** 2) ** 2"
"from math import exp

def main(y):
    result = 0
    if y < 111:
        result = 11 * y ** 12 + 7 * exp(y) ** 5
    if 111 <= y < 136:
        result = (49 * y + 64 * y ** 2) ** 6
    if 136 <= y < 219:
        result = (1 + 76 * y) ** 3 - 1
    if 219 <= y < 278:
        result = 86 * abs(y) ** 5
    if 278 <= y:
        result = 1 + 33 * y ** 5
    return result"
"import math

def main(x):
    if x < 61:
        return math.pow(1 - 50 * x * x * x - 46 * x * x, 7) - 43 * math.pow(math.log(x, 2), 3) - math.cos(x)
    elif x < 81:
        return 1 + math.pow(math.atan(x), 6)
    else:
        return 6 * math.pow(1 - x * x / 2 - x / 56, 3) + math.pow(x, 7)"
"from math import atan

def main(z):
    if z < -11:
        return 15 * atan(29 * z + 63) ** 7 - 90 * (46 * z - z ** 3) ** 2 - 4 * (z ** 2 - z ** 3 - 42 * z) ** 6
    if -11 <= z < 53:
        return 30 * z ** 5 - 1 - 3 * (z ** 3 + z + 1)
    if z >= 53:
        return z ** 3 / 37
main(-43)
main(48)"
"import math

def main(y):
    if y < 111:
        return 81 * y + 5 * (80 * y ** 3 - y ** 2 - 1) ** 3 + y ** 15
    elif 111 <= y < 194:
        return y ** 5 + 70 * y ** 3
    elif 194 <= y < 213:
        return 44 * (38 * y ** 3 + 1) ** 5
    elif 213 <= y < 278:
        return 4 * y ** 5 - 1 - 15 * y ** 7
    else:
        return math.log10(33 * y) ** 4"
"import math

def main(z):
    if z < 106:
        return 25 * abs(z) ** 3
    elif z < 143:
        return z ** 5 / 92
    elif z < 228:
        return abs(35 * z + z ** 2 + z ** 3) ** 5 + 92 * z ** 2 + 56 * (z + z ** 3 / 44 + z ** 2 / 59) ** 7
    return 53 * math.log2(z) ** 4"
"import math

def main(y):
    if y < 80:
        return pow(pow(y, 3) / 44 - y * y - y / 29, 4) + 1 + pow(math.tan(y), 5) / 84
    if 80 <= y < 166:
        return pow(y, 7)
    if 166 <= y < 194:
        return pow(math.atan(y), 7) - 65 * (75 - 24 * y * y - y) - 94 * pow(math.atan(27 * y * y - 1), 2)
    if 194 <= y < 263:
        return pow(math.log(y * y, 2), 3)
    if y >= 263:
        return 57 * (26 - 94 * y) - pow(75 * y * y * y, 7)"
"import math

def main(y):
    if y < 99:
        q = y
    if y >= 99 and y < 166:
        s = (59 * y ** 3 - y - 25 * y ** 2) ** 3
        q = 99 * s - y ** 2
    if y >= 166 and y < 251:
        n = y ** 2 / 85
        q = n + (y ** 2 - y) ** 4
    if y >= 251 and y < 304:
        q = 2 * y ** 6 - 49 * y ** 3
    if y >= 304:
        g = math.tan(y) ** 3
        q = 35 * math.ceil(y) + g
    return q"
"import math

def main(x):
    if x < 93:
        q = x ** 8 + 6 + 70 * math.ceil(87 * x ** 2) ** 6
    if x >= 93 and x < 159:
        s = math.tan(x + 31 + 92 * x ** 3) ** 7
        q = 1 - s - (x / 23 + 64 * x ** 2 + x ** 3) ** 4
    if x >= 159 and x < 185:
        q = x ** 3 / 3 - 1 - (79 * x ** 2) ** 7 - 46
    if x >= 185:
        q = 28 * x ** 7 + (90 + 7 * x ** 2) / 79
    return q"
"import math

def main(y):
    if y < 38:
        return math.pow(y, 7) + math.pow(y, 4)
    elif y < 93 and y >= 38:
        return 80 * math.pow(y, 3) + 55 * math.pow(math.log10(2 * y), 7)
    elif y >= 93:
        a = 89 * math.pow(94 * math.pow(y, 3) + 26 * math.pow(y, 2), 6)
        return math.pow(y, 3) / 27 - 97 - a"
"import math

def main(x):
    if x < 14:
        return math.exp(x) ** 7 - 99 * math.cos(x) ** 3
    elif x < 107:
        return 74 * x
    elif x < 203:
        return 1 - (x * x - 42 * x - 1) ** 6 / 52
    else:
        return 34 * math.fabs(x ** 3 + 15 + 16 * x ** 2) ** 3"
"import math

def main(y):
    ans = 0
    if y < 56:
        ans = 36 * y * y - 1
    if y >= 56 and y < 117:
        ans = pow(math.log(y), 3)
    if y >= 117:
        temp1 = 35 * y * y + y * y * y + 40
        temp1b = 57 * pow(math.log(temp1), 4)
        temp2 = y + y * y * y + 76
        temp2b = pow(temp2, 5)
        ans = temp1b + 77 * y * y * y + temp2b
    return ans"
"import math

def main(x):
    if x < 120:
        return 1 - x ** 2
    elif 120 <= x < 195:
        return x + x ** 5
    elif 195 <= x < 255:
        return 88 + math.atan(x ** 3 + 1 + 84 * x ** 2) ** 6 + x ** 5
    else:
        return x ** 6 + 82 * (77 * x ** 2) ** 3"
"from decimal import *

def main(x):
    with localcontext() as ctx:
        if x < 153:
            return 25 * ctx.power(x, 4) - 83 * (66 * ctx.power(x, 2) + 81) - 12 * ctx.power(56 * ctx.power(x, 2) + 1 + 27 * x, 5)
        elif 153 <= x < 214:
            return 47 * pow(x, 10) - 54 * pow(x ** (-37), 3) - 20
        elif 214 <= x < 288:
            return x + pow(x, 5)
        elif 288 <= x < 332:
            return pow(0.01 - pow(x, 3), 2)
        elif x >= 332:
            return 1 - 76 * pow(x, 6)"
"import math

def main(z):
    if z < 64:
        f = 32 * pow(z, 4) + 1 + 79 * pow(pow(z, 3) / 89, 7)
    if 64 <= z < 113:
        f = pow(z, 2) - 60 * pow(z, 5) - 3 * pow(39 * pow(z, 3) + z, 7)
    if 113 <= z < 196:
        f = pow(z, 3) + pow(z, 6) + pow(math.log(z), 2)
    if z >= 196:
        f = 20 * pow(z, 8) - 6 * pow(z, 5)
    return f"
"from math import *

def main(x):
    if x < 57:
        return 1 + x ** 3
    elif 57 <= x < 125:
        return x ** 4 + 1 + 63 * sin(x) ** 57
    elif 125 <= x < 167:
        return 6 * (x ** 2 + x ** 3) ** 4 - 77 * round(86 * x) ** 3
    elif 167 <= x < 259:
        return log2(7) * x ** 3 - 78 * (16 * x ** 2 + x) ** 5
    else:
        return 44 * x ** 7 + 1 + 36 * (1 - 26 * x ** 3 - 29 * x ** 2)"
"from math import *

def main(x):
    if x < 34:
        return 55 * (x ** 2 + 1 + x) ** 7 - 25 * x
    elif 34 <= x < 100:
        return 35 * sin(x ** 2) + 66 * cos(x ** 3) + 47 * (69 - x ** 3 - x / 79) ** 4
    else:
        return x ** 12 - 1863 * x ** 2"
"def main(y):
    if y < 56:
        rab = 1 - pow(y, 3)
        rab1 = 69 * pow(y, 4) + pow(rab, 2)
        rab = 31 * pow(y, 3) + y + 57
        rab1 = rab1 + 14 * pow(rab, 5)
    elif y > 56 and y < 139:
        rab1 = pow(y, 3) + pow(y, 2)
    elif y > 139 and y < 196:
        rab = 1 + 25 * y + pow(y, 2)
        rab1 = pow(y, 4) + 75 * pow(rab, 2)
        rab1 = rab1 + 31 * (99 + pow(y, 3))
    elif y >= 196 and y < 212:
        rab = pow(y, 2) - 68
        rab1 = 77 * pow(rab, 7)
    elif y > 212:
        rab1 = 3 * y
    return rab1"
"import math

def main(z):
    if z < 48:
        return z ** 6
    if 48 <= z < 64:
        return z ** 4 / 53
    if 64 <= z < 137:
        return z ** 5 - 96 * math.fabs(z ** 3 - z) ** 6 - math.log10(z) ** 3 / 14
    if z >= 137:
        return z ** 2 - 29 * (1 + z ** 2 + z) ** 5"
"import math

def main(z):
    if z < 3:
        return 63 * z ** 6 - (1 + z) ** 7 / 5 - math.sin(z)
    elif 3 <= z < 100:
        return 22 + z ** 6
    elif 100 <= z < 195:
        return math.log(30 * z + z ** 3 + 1, 10) ** 6 - 29 * z ** 4
    elif 195 <= z < 227:
        return z ** 7
    else:
        return 64 * (z - 39) ** 5"
"import math

def main(*args):
    z = args[0]
    if z < 77:
        z = 60 * (37 * z ** 2) ** 3
    elif 77 <= z and z < 118:
        z = z + z ** 3 - 32 * z ** 5 - z ** 7
    elif z >= 118:
        z = 46 * (1 - z - 64 * z ** 2) ** 7 + 80 * (35 * z ** 2 + 65) ** 6
    return z"
"import math

def main(*args):
    y = args[0]
    if y < 80:
        y = 49 * math.sin(y) ** 6 - abs(y) ** 3
    elif 80 <= y and y < 109:
        z = 11 * y ** 5
        v = math.log10(61 * y ** 3 + y / 2 + 79 * y ** 2) ** 2
        y = z + v
    elif 109 <= y and y < 123:
        y = math.log(y) ** 6 - 89 * (y ** 2 / 8) ** 5
    elif y >= 123:
        y = (y ** 3 - 97) ** 6
    return y"
"import math

def main(y):
    if y < 67:
        return (1 - 39 * y - 60 * y ** 2) ** 6
    if 67 <= y < 127:
        return 12 * y ** 2 + 14 * math.log(y) ** 6 + math.exp(y)
    if 127 <= y < 168:
        return (14 * y) ** 5
    if 168 <= y < 230:
        return (y ** 2 - 1) ** 2 / 51
    if y >= 230:
        return 28 - 71 * math.cos(y) - 10 * (y ** 2 + 22 + 90 * y) ** 3"
"from math import *

def main(z):
    if z < -35:
        return z ** 7 - 47 * z ** 5
    elif z < -18:
        return 83 * (1 + 34 * z + 32 * z ** 3) ** 6 - (1 - z ** 3 / 86 - 68 * z ** 2) - atan(91 * z - 43 * z ** 2) ** 7
    elif z < 72:
        return 60 * z ** 6
    elif z < 152:
        return 98 * (1 + 40 * z ** 3) ** 4 - log10(z) ** 2 / 42 - 8 * log(z) ** 7
    else:
        return (1 - 22 * z - z ** 2) ** 5 / 68 - 17 * atan(6 * z - z ** 3) ** 7 - 59 * floor(1 - 69 * z ** 3) ** 4"
"import math

def main(x):
    if x < 59:
        result = 14 * (27 * x) ** 6 - 65 * (46 + 90 * x + 72 * x ** 2) ** 7 - 92 * x ** 4
    elif 59 <= x < 144:
        result = (x ** 2 + 97) ** 6
    elif x >= 144:
        result = math.log(1 - 82 * x ** 3) ** 3 + math.sin(x) ** 7 + math.atan(x) ** 2
    return result"
"from math import *

def main(z):
    if z < 104:
        f = 99 * z ** 6 + (1 + z ** 3 / 89) ** 4 / 27
    elif 104 <= z < 165:
        f = 34 * sin(z ** 2 - 1 - 68 * z ** 3) ** 2 + sin(z / 45) ** 5 / 35 + log(z)
    elif 165 <= z < 196:
        f = 27 * z ** 4 + z ** 3
    else:
        f = z ** 3 + 17 * (76 * z - 1 - 37 * z ** 2) ** 2
    return f"
"from math import ceil

def main(x):
    if x < 21:
        return 16 * x ** 2
    elif 21 <= x < 99:
        return ceil(x) ** 3
    elif 99 <= x < 144:
        return (20 * x + 64 * x ** 3) ** 4
    elif 144 <= x < 187:
        return (45 * x ** 2 - x ** 3) ** 3 - ceil(80 * x) ** 7
    elif x >= 187:
        return 51 * (x + 3) ** 3 + 34 * x"
"from math import ceil

def main(z):
    if z < 84:
        return (13 * z ** 3 + 56 * z + 56) ** 2 + z ** 5 + 85 * z ** 3
    elif z < 119:
        return ceil(z - z ** 2 / 18) ** 5 - (z ** 2 + z) ** 3
    elif z < 180:
        a = 2 * (71 + z / 25 + z ** 3) ** 6
        b = -z ** 4 - (18 * z ** 2 - z ** 3 - z) ** 4
        return a + b
    elif z < 233:
        return 1 - z ** 3
    else:
        return 86 + 76 * z ** 3"
"import math

def main(y):
    if y < 96:
        return 94 - math.cos(25 + y ** 3) ** 6 - 49 * (64 * y ** 3 + 0.03)
    elif y < 157:
        return math.cos(25 * y * y) ** 2 + 56 * (29 * y * y + 47 * y + 77 * y ** 3) ** 3
    elif y < 243:
        return 13 - 29 * (58 * y * y * y - 19 * y * y) ** 6 - (y * y - 0.03) ** 4
    elif y < 341:
        return math.log(y * y, 10) ** 5 + math.sin(y) ** 7 / 82
    else:
        return 67 * abs(58 * y ** 3 + y * y)"
"from math import *

def main(z):
    if z < 34:
        return pow(1 + 33 * z ** 2, 4) - pow(1 - z - z ** 3, 7)
    if 34 <= z < 73:
        return 59 * pow(z, 3) - 0.03 - 20 * z + 77 * pow(tan(z), 7)
    else:
        return 97 * pow(36 * z, 4) + pow(z ** 2 + 50 + z ** 3, 2) / 94"
"import math

def main(z):
    if z < 70:
        result = z + 86 * z ** 2 + 26 * z ** 3 + 1 + z
    elif z >= 149:
        result = 62 * (53 * z ** 3) ** 7 + (z + 2 + 97 * z ** 2) ** 6 + z
    else:
        result = (z ** (1 / 2)) ** 6 + 20 * z + 68 * (z ** 2 + z ** 3) ** 3
    return result"
"from math import log1p, cos

def main(z):
    if z < -4:
        return z ** 5 / 47
    elif -4 <= z <= 47:
        return 1 + abs(z) ** 4 + 92 * (93 + z ** 2 + 9 * z ** 3) ** 3
    elif 47 <= z < 59:
        return 48 - z + cos(z) ** 3 + 54 * (14 * z ** 2 - 1) ** 2
    elif 59 <= z < 140:
        return (9 * z ** 3 * z / 74) ** 3 - abs(z - z ** 3 / 73) ** 6 - z ** 4
    elif z >= 140:
        return 79 * (z ** 3 - 1 - 85 * z ** 2) + 76 + 8 * log1p(23 * z ** 3 - z ** 2) ** 3"
"import math
from math import *

def main(x):
    if x < 52:
        otvet = 82 * (78 * x ** 3) ** 2
        return otvet
    elif x >= 52 and x < 129:
        otvet = 50 * math.exp(x) ** 4 + 38 * x
        return otvet
    elif x >= 129 and x < 155:
        otvet = x - 34 * math.sin(x ** 3 - x) ** 4
        otvet1 = 57 * round(x - 12 * x ** 3) ** 5
        return otvet - otvet1
    elif x >= 155 and x < 225:
        otvet = x ** 5 - x ** 7 - 74 * math.exp(x) ** 4
        return otvet
    else:
        otvet = 93 * math.log(x ** 3) ** 3 - x - 17 * x ** 6
        return otvet"
"from math import log10

def main(x):
    if x < 45:
        return (x ** 3 - x ** 2) ** 3
    elif 45 <= x < 141:
        return 95 * (x ** 3 - x ** 2 - x) ** 3 + 61 * (x ** 2 - 0.02 - 53 * x) ** 6
    elif 141 <= x < 231:
        return (x ** 3 + x) ** 3 - x ** 18 - 95 * x ** 5
    elif 231 <= x < 320:
        return log10(78 * x + 41 + x ** 2) ** 7 + abs(x + x ** 3) ** 3 / 94
    elif x >= 320:
        return 19 * x ** 3 - 71 * x ** 2 - 78 * (x ** 2 - x - 28 * x ** 3) ** 7"
"import math

def main(y):
    if y < -16:
        return 80 * math.pow(16 * y * y * y - y - 13 * y * y, 5)
    elif -16 <= y < 49:
        return y * y - 13 * math.pow(abs(y + 53 * y * y * y + 0.03), 7) - math.pow(abs(10 * y * y * y + y * y + 48 * y), 4)
    elif 49 <= y < 63:
        return 90 * math.pow(4 * y * y, 3) + math.ceil(math.pow(y, 7)) + math.pow(71 * y * y * y - 45 * y * y - 39, 6)
    elif 64 <= y < 118:
        return 49 * math.tan(y)
    else:
        return 24 * math.pow(math.tan(10 * y * y + 2 * y * y * y + 0.03), 6) - 56 * (25 * y * y + 75 + 78 * y * y * y)"
"import math

def main(y):
    if y < 112:
        return 54 * y ** 3 + 8 * math.log(y, 2) ** 2 + 49 * (0.02 + 65 * y + y ** 3) ** 5
    if 112 <= y <= 124:
        return math.sin(y) ** 2
    if 124 <= y < 213:
        return 9 * math.cos(y ** 2) ** 7 - math.tan(y) ** 4 - 93 * y ** 3
    if 213 <= y < 283:
        return 60 * y - y ** 6
    if y >= 283:
        return math.log(34 * y + 14 * y ** 3, 2) ** 4 - y ** 3"
"import math

def main(y):
    if y < 16:
        return 79 + 45 * (39 * y ** 3) ** 6
    elif 16 <= y < 65:
        return y ** 2 + y
    elif 65 <= y < 99:
        return 75 * (6 - 74 * y ** 3) ** 6 - 22 * math.sin(y) ** 5 - math.cos(y) ** 3
    else:
        return y ** 6 + y ** 2 + 59 * y ** 3"
"import math as m

def main(y):
    if y < 46:
        sin = 18 * m.pow(m.sin(m.pow(y, 2) / 47 + 39 * m.pow(y, 3)), 5)
        arc = 64 * m.pow(m.atan(y + m.pow(y, 2) + m.pow(y, 3)), 7)
        return m.pow(y, 3) + sin + arc
    elif 46 <= y < 86:
        first = m.pow(m.pow(y, 2) / 48 - 56 * y - 66, 4)
        log = 33 * m.pow(m.log(y, 10), 5)
        return first - log
    else:
        return m.pow(9 * m.pow(y, 2), 5)"
"import math

def main(z):
    if z < 102:
        return z ** 4 - 70 * z ** 5 - (66 - z ** 3) ** 6 / 30
    elif 102 <= z < 137:
        return 49 * math.log(z ** 3 - z ** 2) - 24 * (z ** 2 + z) ** 3
    else:
        return 52 - z ** 4 / 62"
"from math import *

def main(y):
    if y < 89:
        func_one = pow(50 * pow(y, 3), 3)
        return func_one
    elif 89 <= y < 153:
        func_one = 24 + 69 * pow(abs(pow(y, 3) - pow(y, 2) - 1), 4) + pow(floor(y), 7)
        return func_one
    elif y >= 153:
        func_one = 9 * (32 + 38 * pow(y, 3)) - 89 * pow(log2(y + pow(y, 3) / 89), 4)
        return func_one"
"import math

def main(x):
    answer = 0
    if x < 75:
        return x ** 6 / 83 - 0.02
    if 75 <= x < 99:
        return math.fabs(x) ** 2
    if 99 <= x < 181:
        return (98 * x ** 2 - 58 * x) ** 5
    if 181 <= x < 239:
        return 76 * x ** 2 - 5220 * x ** 3 - 24 * x ** 7
    if x >= 239:
        return 1 + math.sin(x) / 10"
"def main(y):
    if y < -15:
        return 78 * y ** 6 - 8 * y ** 4
    elif -15 <= y < 78:
        return (y + y ** 2 / 5) ** 6
    elif 78 <= y < 141:
        return (80 * y ** 3) ** 6 / 5
    elif y >= 141:
        return y ** 4"
"import math

def main(x):
    if x < 149:
        a = math.atan(78 * x ** 2 - 62 - 21 * x ** 3) + 79 * x ** 7
        b = (96 - 32 * x ** 3 - x) ** 3
        return a + b
    elif 149 <= x < 216:
        a = 1 + math.fabs(x) ** 4
        b = 69 * (77 * x ** 3 - x ** 2 - 21 * x) ** 2
        return a + b
    else:
        a = (x / 97 - 24 - 64 * x ** 2) ** 6 / 7 + 1
        b = 51 * (1 - x)
        return a + b"
"import math

def main(y):
    if y < 73:
        s1 = math.pow(y - 1, 4)
        s2 = math.pow(y, 7) / 93
        s3 = math.pow(y, 5) / 93
        return s1 + s2 + s3
    if y >= 73 and y < 97:
        s1 = 72 * math.pow(y, 3)
        s2 = 57 * math.pow(y, 5)
        return s1 + s2
    if y >= 97 and y < 121:
        return math.pow(math.log(y, 10), 5)
    if y >= 121 and y < 204:
        s1 = 44 * math.pow(abs(y), 5)
        s2 = 72 * (y + 81 * math.pow(y, 2) + 26 * math.pow(y, 3))
        s3 = 34 * math.pow(92 * math.pow(y, 2) - 77 * y - math.pow(y, 3), 2)
        return s1 - s2 - s3
    if y >= 204:
        s1 = 58 * y - 18 * math.pow(y, 3) - math.pow(y, 2)
        s2 = math.pow(abs(s1), 6)
        return 85 * s2 + 70 + 95 * math.pow(y, 7)"
"import math

def main(y):
    if y < 163:
        return y ** 5
    if 163 <= y < 196:
        return (y ** 3 + 13 + 49 * y * y) ** 3
    if 196 <= y < 256:
        return 65 * (y * y + y) ** 2 + 74 * (43 * y * y - y - 29 * y ** 3) ** 4 + 69 * math.log(y, 10) ** 7
    return y"
"def main(z):
    from math import sqrt
    from math import tan
    from math import cos
    from math import exp
    from math import log
    if z < -37:
        sum = z + z ** 18
    elif z >= -37 and z < 43:
        sum = 93 * exp(1 - 59 * z ** 2 - z) - cos(z ** 2 - z) ** 4 / 23 - z ** 3
    elif z >= 43 and z < 100:
        sum = 73 * (5 * z ** 3) ** 7
    elif z >= 100 and z < 142:
        x = 40 * z
        sum = log(x, 2) ** 5
    elif z >= 142:
        sum = abs(z) ** 6
    return sum"
"import math

def f(z):
    if z < 125:
        return 82 * (98 * z ** 2 - z ** 3) ** 4 - 61 - (66 * z ** 3 + 42)
    elif 125 <= z and z < 155:
        return math.log(z ** 2, 10) ** 6
    elif 155 <= z and z < 230:
        return 94 - z ** 5
    elif 230 <= z and z < 312:
        return (1 - 93 * z ** 3) ** 6
    else:
        return 85 * z ** 4 - z ** 6 - math.floor(18 * z - 0.08) ** 3

def main(z=338):
    return f(z)"
"from math import floor

def main(x):
    if x < 174:
        return floor(x ** 2) + 66 * (95 - x ** 3 - 17 * x ** 2) ** 3 + x ** 5
    elif 174 <= x < 270:
        return 0.11 - 42 * (x ** 3 / 42) ** 5 - 42 * (x ** 2 - x / 87 - 1) ** 4
    elif x >= 270:
        return 1 - 62 * (x - 32 * x ** 2) ** 3"
"import math

def main(z):
    if z < 107:
        x1 = (25 * z + 0.02 + z ** 3) ** 3
        x2 = z ** 3 - 45 - z ** 2
        x3 = (1 - 18 * z) ** 7
        return x1 - x2 - x3
    if 107 <= z and z < 191:
        y1 = z ** 7 / 67
        y2 = z + 5 * z ** 3
        return y1 + y2
    if 191 <= z and z < 247:
        return math.atan(z ** 3 / 33) ** 2
    if z >= 247:
        return z ** 2 - 89 * (74 * z) ** 4 - 1"
"import math

def main(x):
    if x < 1:
        return 70 * math.asin(x) ** 5 - 4 * abs(x)
    elif 1 <= x < 94:
        return 39 * x ** 3 + x ** 2 / 4
    elif x >= 94:
        return 78 * math.atan(x ** 2 + 1) ** 3 - 1"
"import math

def main(x):
    if x < -39:
        str1 = 70 * math.log1p(5 * x ** 2) ** 2 + (73 * x ** 2) ** 5 + 77
    if x >= -39 and x < 18:
        str1 = x ** 7
    if x >= 18 and x < 50:
        str1 = 92 * (61 * x) ** 2
    if x >= 50:
        str1 = 92 * math.log1p(x - 1) ** 6 - x
    return str1"
"from math import exp

def main(y):
    if y < 50:
        return 78 - y ** 3 + 7 * y ** 7 + exp(y) ** 2
    elif 50 <= y < 140:
        return 75 * (y ** 2 / 63) ** 2 - y ** 7
    elif 140 <= y < 202:
        return y ** 6 + y ** 7 + 95 * (1 + y ** 2 + 72 * y) ** 4
    elif y >= 202:
        return y ** 5 + y ** 2 + 4"
"import math

def main(z):
    f = 0
    if z < 100:
        f = 23 * math.pow(z, 2) - 83 * math.pow(abs(z), 3)
    elif 100 <= z < 163:
        f = math.pow(z, 5) + math.pow(abs(math.pow(z, 2)), 2) + 51
    elif 163 <= z < 201:
        f = 80 * math.pow(62 * math.pow(z, 2) + 30 * z + 1, 5)
    elif z >= 201:
        f = math.pow(z, 3)
    return f"
"import math

def main(y):
    if y < 104:
        return float(y ** 6 + y ** 4)
    if 104 <= y < 176:
        return float(math.ceil(y) ** 6 / 81 + math.cos(y ** 3 - 1) ** 3)
    if 176 <= y < 249:
        return float(math.atan(68 * y) ** 5 - y ** 4 / 49 - 19 * y ** 3)
    if 249 <= y < 321:
        return float(y ** 5 - 32 * math.log(0.02 + y / 95) ** 4 - y)
    if y >= 321:
        return float((y ** 2 + y ** 3) ** 2 - 2 * (74 * y ** 2 - 96 - y) ** 4)"
"import math

def main(y):
    if y < 124:
        a_11 = math.ceil(y / 33 - 1 - y ** 2)
        a = a_11 ** 7 + 42 * y ** 3 + 72 * y ** 4
        return a
    elif y >= 124 and y < 181:
        return y
    elif y >= 181:
        b_11 = y + 65 * y ** 3 + 61
        b = 96 - math.log10(b_11) ** 7
        return b"
"import math
from math import sqrt

def main(x):
    if x < 177:
        return 82 * (6 * x ** 3 + 97 * x) ** 5 - 31 - sqrt(x ** 3) ** 6
    elif x >= 177 and x < 227:
        return 75 * x ** 2
    else:
        return 35 * x ** 6 - 31 - x / 65"
"from math import sin, log

def main(y):
    if y < 99:
        return 29 * y * y - y - 20
    elif 99 <= y < 139:
        return y - y ** 5 * 63
    elif y > 139:
        return (y ** 3 - 45 * y - 60) ** 7 + sin(y) ** 3 + log(y, 2) ** 4"
"import math

def main(z):
    if z < 0:
        return z ** 2 / 22
    elif 0 <= z < 11:
        return 16 * z ** 2
    elif 11 <= z < 87:
        return (60 * z + 18 * z ** 3) ** 3 + 1
    elif 87 <= z < 145:
        return z
    elif z >= 145:
        return math.sin(z) ** 6 / 52 + 79 + 32 * math.exp(p) ** 4 * z ** 2"
"import math
from math import log

def main(y):
    if y < 128:
        return 57 * y ** 2 - (9 + y ** 3 / 62) ** 7
    if 128 <= y < 184:
        return 7 * y ** 2 - (13 * y ** 3 - 53 * y - 89) ** 7 / 33 - (57 * y - 3 * y ** 3) ** 3
    if 184 <= y < 273:
        return 93 * log(y) ** 3 - math.ceil(y ** 2) ** 6
    if y >= 273:
        return y ** 3 - (y - 7 - y ** 3) ** 7"
"import math

def main(z):
    if z < 156:
        det1 = z ** 4 - 1 - z ** 5
        return det1
    elif z >= 156 and z < 211:
        det2 = 11 * (z ** 3 - z ** 2 - z) ** 6 + 1 + abs(z) ** 4 / 31
        return det2
    elif z >= 211 and z < 242:
        det3 = (z ** 3 + z ** 2 / 68) ** 5 - 15 * (72 * z ** 3 + 63) ** 4
        return det3
    elif z >= 242:
        det4 = 34 * z ** 4 - z ** 2 - 17 * math.log(z, 2)
        return det4"
"import math

def main(z):
    if z < 175:
        return math.atan(z) ** 6 / 33 + 0.02 + 60 * (14 - z ** 3 - z ** 2 / 40) ** 3
    elif z >= 175 and z < 260:
        return 46 * z ** 5 - 15 - (z + z ** 3 / 59 + z ** 2 / 45) ** 2
    elif z >= 260:
        a = 89 * (6 * z + z ** 3 + 0.02) ** 5 + 89 * math.tan(69 * z + 62 * z ** 2 + 64) ** 3
        a1 = math.log10(12 * z - 3 * z ** 3) ** 7
        return a + a1"
"import math

def main(y):
    if y < 58:
        return (y ** 3 / 37) ** 2 - 87 * math.sin(y) ** 3
    elif 58 <= y and y < 86:
        return 1 + y ** 5
    elif 86 <= y and y < 109:
        return y ** 5
    elif y >= 109:
        return 24 * math.tan(y) ** 3"
"from math import log, fabs

def main(x):
    if x < 98:
        return 92 * x ** 6 + 4
    elif x < 122:
        return x ** 2 / 27
    elif x < 169:
        return 83 * fabs(x ** 3 / 34) ** 3 + 15 * log(x) ** 6 + log(65 + 11 * x ** 3 + x) ** 2
    elif x < 266:
        return 22 * x ** 4 + x + (x - x ** 3 - 23 * x ** 2) ** 3
    else:
        return 78 * x ** 7 - x ** 5"
"from math import *

def main(y):
    if y < 64:
        f = 72 * pow(27 * pow(y, 2) + pow(y, 3), 7)
        return f
    elif 64 <= y < 130:
        f = 45 * pow(y, 5) - 95 * y
        return f
    elif y >= 130:
        f = 88 * pow(y, 4) - 47 * pow(12 * y - pow(y, 2), 3) - 62
        return f"
"import math

def main(z):
    if z < -14:
        return z * z + math.tan(z) + 0.02
    elif -14 <= z < 4:
        return 95 * z
    elif 4 <= z < 100:
        return abs(z ** 2) + 56 + 89 * z ** 10
    elif z >= 100:
        return 16 * (z ** 2 - 20 * z - 1) ** 3
    else:
        return 1"
"from math import log10, atan, ceil

def main(y):
    if y < 75:
        return 60 * y ** 4
    elif 75 <= y < 93:
        return y ** 3
    elif 93 <= y < 153:
        return y ** 3 - 17 * y ** 5 - log10(1 + y ** 2 + y) ** 4 / 33
    elif 153 <= y < 249:
        return 41 * atan(67 * y) ** 6
    elif y >= 249:
        return 88 * ceil(y) ** 2 + 1 + (87 * y + y ** 2 + 1) ** 6 / 10"
"import math

def main(x):
    num = 0
    if x < 176:
        num = (x ** 3 + 0.02 + x ** 2) ** 7
    if 176 < x < 202:
        num = (48 * x ** 2 + 87) ** 2
    if 202 < x < 234:
        num = 48 * math.floor(x - 8 * x ** 3) ** 3 - (72 * x ** 2) ** 4 / 30
    if 234 <= x < 260:
        num = math.sin(x ** 3 / 86 - 9 - 63 * x ** 2) ** 4
    if x >= 260:
        num = math.log(55 + x + 14 * x ** 3) ** 2 + 94 * x ** 5
    return num"
"import math

def main(y):
    if y < 98:
        x = 35 * y ** 7 - 1
    elif y >= 98 and y < 143:
        x = math.exp(57 - y - 60 * y ** 2) ** 7 - y ** 2 / 92
    elif y >= 143 and y < 159:
        x = 89 * (43 * y - 88 * y ** 3) ** 3 + y ** 4
    elif y >= 159:
        x = 34 * y ** 4 + y ** 2 / 82
    return x"
"import math

def main(z):
    if z < -33:
        return 60 * z ** 6
    elif z >= -33 and z < -17:
        return math.cos(z ** 2 - 94) + 10 * z ** 6 + 30 * z ** 3
    elif z >= -17 and z < 81:
        return z ** 4
    return (z - z ** 2 - 27 * z ** 3) ** 7 - (20 * z ** 2 + 30) ** 6 - 1"
"def main(x):
    if x < 58:
        a = 95 * x ** 4
        return a
    elif 58 <= x < 113:
        a = 26 * (x ** 2 / 81) ** 3 + (x + 27) ** 6
        return a
    elif x >= 113:
        a = 78 * x ** 2 + x ** 7
        return a"
"import math

def main(x):
    if x < 4:
        return 67 * (1 + 36 * x ** 3) ** 3 + 43 * math.log(2, 2) * (x / 52 + 1 + x ** 2) + 42 * x ** 6
    elif 4 <= x < 89:
        return 9 * (1 - 91 * x ** 2 - x) ** 4
    elif 89 <= x < 103:
        return 55 * x ** 2 + (math.exp ** 4)(x)
    elif x >= 103:
        return (15 - 87 * x ** 3) ** 2 / 65 - 40 * x"
"import math

def main(z):
    if z < 108:
        f = z ** 6 / 94 + 24 * math.sin(z) + z ** 5
    elif 108 <= z < 132:
        f = 94 * z ** 7
    elif 132 <= z < 180:
        a = math.tan(0.01 - 80 * z ** 3 - 31 * z ** 2) ** 7 / 38
        f = 56 * math.sin(54 + z ** 2 + z) ** 3 - a - 1
    elif 180 <= z < 223:
        f = 74 * math.sin(5 * z ** 3 - 59) ** 7
    elif z >= 223:
        f = math.log10(z) ** 7 - z ** 6 - 3 * z
    return f
main(99)"
"import math

def main(z):
    a = float(z - 50 - 82 * z ** 3)
    b = float(69 * math.ceil(z) ** 3 + z + 1 + 77 * z ** 3)
    c = float(76 + 42 * (42 * z ** 3 - z - z ** 2) ** 6 + z)
    d = float(math.cos(z) / 59)
    if z < 177:
        return a
    elif z >= 177 and z < 246:
        return b
    elif z >= 246 and z < 344:
        return c
    elif z >= 344:
        return d"
"import math

def main(z):
    if z < 62:
        return z * z * z
    elif 62 <= z < 100:
        return z ** 3 / 36
    elif z >= 100:
        return z * z"
"import math

def main(y):
    if y < -57:
        z = 48 * math.atan(y) - 48 * y ** 4 - math.exp(y ** 3) ** 7
    elif -57 <= y < 19:
        z = (1 - 85 * y ** 2) ** 7 - 25 - y ** 4 / 76
    elif 19 <= y < 100:
        z = 8 * (84 * y ** 3) ** 6 - math.log10(y ** 3 + 0.02) / 92
    elif y >= 100:
        z = (y ** 2 + y ** 3 + 1) ** 2 - (y ** 2 + 1) ** 3 - 12 * y ** 6
    return z"
"def main(y):
    f1 = 82 * y ** 2 + 92 * (89 * y ** 3 + 1 + y) ** 5
    f2 = (54 + y) ** 3
    f3 = abs(y) ** 3 - 87 * (38 * y ** 3) ** 2
    if y < 158:
        f = f1
    elif y >= 158 and y < 245:
        f = f2
    else:
        f = f3
    return f"
"import math

def f(y):
    if y < 55:
        return 1 - math.floor(80 * y - y ** 3 / 66 - y ** 2 / 94) ** 4 - 58 * (y ** 2 - 1 - y / 20) ** 6
    if 55 <= y < 110:
        return 40 * y ** 7 - y ** 5 / 47 - (26 * y ** 3) ** 2
    if 110 <= y < 162:
        return 94 * (y ** 3 + y + 1) ** 6 - y ** 9
    if y >= 162:
        return 88 * (1 + 23 * y ** 3 + 88 * y ** 2) ** 7 + (y ** 3 + y ** 4 / 44) ** 4 + y ** 3

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

def main(x):
    if x < 74:
        return 37 * math.tan(x ** 2 + x + 92) ** 4 - 48 * (65 * x) ** 7 - 91
    elif 74 <= x < 153:
        return 81 * x ** 4 + 36
    else:
        return 73 * x ** 3"
"def main(y):
    if y < -28:
        return 2 * y ** 6 - 21 * y ** 4
    elif -28 <= y < -8:
        return 98 * (6 * y + y ** 3) ** 5 + 45 * y ** 3
    else:
        return y ** 2"
"import math

def main(z):
    if z < 56:
        z1 = 21 - 56 * z ** 3 - 93 * z ** 2
        anw = z1 ** 4 - 96 * z ** 2
        return anw
    elif z >= 56 and z < 72:
        z1 = (67 * z) ** 7
        z2 = (54 * z ** 2 + 85 * z) ** 4 / 92
        return z1 + z2
    elif z >= 72 and z < 116:
        z1 = abs(z) ** 2
        z2 = math.exp(z) ** 7
        z3 = (z * z - 1 - z) ** 6
        return z1 - z2 - z3
    elif z >= 116 and z < 178:
        z1 = 74 * z ** 4
        return z1
    elif z >= 178:
        return math.sqrt(z)"
"import math

def main(z):
    if z < 155:
        return math.atan(z) ** 2
    elif 155 <= z < 206:
        return z ** 3 - z ** 12 - 69 * (77 * z ** 2) ** 4
    elif z >= 206:
        return z ** 4"
"import math

def main(x):
    if x < -8:
        x = math.atan(76 * pow(x, 2))
        x = pow(x, 6)
    elif x < 35:
        x = pow(x, 6) * 70 + 1
    elif x < 55:
        a = math.log(x, 2)
        b = math.atan(x)
        x = 68 * a + pow(b, 7)
    elif x < 113:
        a = 91 * pow(x, 2) - pow(x, 3) - 89
        b = math.sin(a)
        a = pow(b, 2)
        x = x / 68 / 66 + a
    else:
        x = pow(x, 4) * 95
    return x"
"import math

def main(z):
    if z < 162:
        return (z ** 2 + 4 + 95 * z) ** 7 - abs(z - 87 - z ** 3) ** 3
    elif 162 <= z < 199:
        return 28 * z ** 6
    elif 199 <= z < 242:
        return 1 - math.log(z) ** 5 / 15 - math.sin(z) ** 7
    elif 251 <= z < 309:
        return z / 97
    elif z >= 309:
        return z ** 4 / 65 + math.tan(z) ** 2 + 84"
"from math import sin
from math import cos

def main(z):
    if z < -38:
        return z ** 4
    elif z < 42:
        return z ** 5
    elif z < 140:
        return abs(z) ** 6
    elif z < 211:
        return 76 * sin(48 - z ** 3) ** 2 - 81 * z ** 4
    else:
        return 84 * cos(z) ** 6"
"import math

def main(z):
    if z < -7:
        z = 14 * (z + z ** 3) ** 7 - z ** 3
    elif -7 <= z < 23:
        z = 91 * (30 * z ** 2) ** 6 - z
    elif 23 <= z < 92:
        z = 67 * (98 - z ** 2 - z ** 3 / 63) ** 5 - 1 - math.tan(z) ** 3
        z = z * -1
    elif 92 <= z < 162:
        z = 21 * z ** 2
    elif z >= 162:
        z = 9 * z ** 7 + z ** 6 / 81
    return z"
"from math import atan

def main(z):
    if z < 167:
        return 71 * z + 48
    if z < 184:
        return z ** 7
    if z < 208:
        return (49 * z * z - 82) ** 3
    if z < 246:
        return 34 * atan(z) ** 5
    else:
        return z ** 6 + 1"
"from math import log, floor, sin

def main(x):
    if x < 149:
        a = 80 * floor(49 * x - 72 * x * x - 2 * x ** 3) ** 5
        return 1 - 36 * x * x - a
    if x < 242:
        return log(x * x + x, 2) ** 5 / 11
    if x < 310:
        return 53 * (62 * x - 57 * x * x - 68 * x ** 3) ** 5 + log(x, 2) ** 4
    if x < 409:
        return 75 * sin(x) ** 2 - 67 * (93 * x) ** 7
    else:
        return 32 + x ** 5 + x ** 4"
"import math

def main(z):
    if z < 116:
        return 69 * z ** 4
    elif 116 <= z < 197:
        return 74 * z
    elif 197 <= z < 241:
        return 33 * math.sqrt(z) ** 3 + 81 + 70 * z ** 21
    elif 241 <= z < 290:
        return (62 * z + 82 + z ** 3 / 15) ** 4 + 15 * math.ceil(z) + 84 * math.floor(z ** 3 - z ** 2 - z) ** 6
    elif z >= 290:
        return 34 * (z / 58 + 63) - z ** 5 - (84 * z - 72 * z ** 2) ** 4 / 31"
"import math

def main(x):
    if x < 60:
        a = 49 * (x ** 3 + 1) ** 3 - 38 * x ** 6 - (90 * x - x ** 3 - 1) ** 4
        return a
    elif 60 <= x < 114:
        b = 83 * (0.07 - 7 * x ** 2 - x / 73) ** 7 + abs(x) ** 2
        return b
    elif 114 <= x < 173:
        c = (24 + x ** 3) ** 3 + 22
        return c
    elif 173 <= x < 244:
        d = math.atan(x) ** 3 / 4
        return d
    elif x >= 244:
        e = math.atan(x) ** 6 - 1
        return e"
"def main(z):
    if z < -2:
        z1 = 59 + 55 * (z ** 3 / 44 - 94 * z - 74 * z ** 2) ** 7
        return z1
    elif -2 <= z < 86:
        z2 = 51 * abs(z) ** 6 - 96 * (z ** 2 - 69)
        return z2
    elif 86 <= z < 147:
        z3 = (26 * z ** 2 - 13 * z ** 3 - 93 * z) / 36
        return z3
    elif 147 <= z < 193:
        z4 = 1 + (32 * z ** 3 + 1) ** 2
        return z4
    elif z >= 193:
        z5 = z ** 6
        return z5"
"import math

def main(x):
    if x < 93:
        return x ** 5
    if 93 <= x < 143:
        return math.fabs(x) ** 3 + 11 * math.fabs(x) ** 7 + 26
    if 143 <= x < 181:
        return x ** 6 - 92 - 77 * math.tan(x ** 2 - 42 ** 3) ** 3
    if 181 <= x < 208:
        return 71 * x - 64 * (x ** 3 - 63 * x - 51 * x ** 2) ** 2 - x ** 3
    if x >= 208:
        return x ** 6 + (x ** 2 / 49) ** 4 / 32"
"import math

def main(y):
    if y < 37:
        f = math.ceil(y) - y ** 6 - 97
    elif y >= 37 and y < 94:
        f = math.log2(85 * y ** 2) / 72 - 1
        f -= math.log(y ** 2) ** 2
    elif y >= 94:
        f = y ** 2 - y - 1 - 59 * math.cos(y) ** 3
        f -= 6 * (78 * y ** 2 - 1) ** 6
    return f"
"import math

def main(y):
    if y < 1:
        return 33 * (y + 59 * y ** 3 + 53) ** 6 - y ** 5
    elif y >= 1 and y < 66:
        return 70 * y ** 7 - y ** 2
    elif 66 <= y < 143:
        return 69 * math.cos(y) ** 5 - 28 * y ** 2
    else:
        return 84 * y ** 3"
"import math

def main(z):
    if z < 29:
        return 6 * z ** 9 + (56 * z) ** 5
    elif z >= 29 and z < 79:
        return 4 * math.ceil(z ** 2) ** 6
    elif z >= 79 and z < 135:
        return (32 * z + 7) ** 4 - 82 - 50 * z ** 6
    else:
        return 27 * z ** 4"
"def main(x):
    if x < 104:
        return x ** 9
    elif x < 121:
        return (75 * x + 91 * x ** 3) ** 7 + 60 * x
    elif x < 142:
        return (78 * x ** 3 - x ** 2 / 54) ** 7 / 46 - 4 * x ** 2
    else:
        return (1 - x - x ** 3) ** 2 - 1"
"import math

def main(z):
    if z < 10:
        return 1 - math.log(39 * z + 0.01, 10) ** 4
    elif z < 71:
        return math.sin(z) ** 4
    elif z < 124:
        return z ** 5 + 47 * (1 - z ** 3 - z / 93) + 6 * (88 * z ** 3 + z ** 2 + 31) ** 3
    else:
        return z ** 6 + math.tan(1 - z - z ** 3) ** 2 + 1"
"import math

def main(x):
    if x < 2:
        return 1 - math.fabs(x) ** 4 / 45 - math.floor(x) ** 7
    elif 2 <= x < 37:
        return 87 * x ** 7 - 3480 * x ** 3
    elif 37 <= x < 115:
        return 32 * (x + x ** 2 + 42) ** 2 - 43 * x ** 6
    elif x >= 115:
        return 98 + 68 * x ** 6
    else:
        return 1
main(14)"
"import math

def main(z):
    if z < 63:
        return 66 * math.tan(32 * z) ** 6
    if 63 <= z < 88:
        return 81 * (2 * z ** 3 + 99 * z) ** 5 + 1 + (z / 58 + 33) ** 4
    if 88 <= z < 153:
        return math.sin(z) ** 5 + 2 * z ** 7
    if 153 <= z < 228:
        return math.sin(54 * z ** 3) + 9 * (z - 51 - 71 * z ** 3) ** 5
    if z >= 228:
        return 44 * (80 * z ** 2 - z ** 3 / 19) ** 2 - 1
main(167)"
"from math import cos, tan, log10

def main(z):
    if z < 62:
        return 31 * log10(1 + 33 * z ** 3 + z) ** 5 + z / 87
    elif 62 <= z < 133:
        return tan(z) / 58 - 1 - 83 * (1 + 87 * z ** 2) ** 4
    else:
        return 10 * cos(z) ** 7"
"def main(z):
    if z < 76:
        z = z * z
    elif z >= 76 and z < 92:
        z = z ** 4 / 47 + 11 * (z ** 3 - 88 * z ** 2 - 38 * z)
    elif z >= 92:
        z = 15 * (1 + z ** 2 + z ** 3) ** 6 - z ** 3 / 82
    return z"
"import math

def main(x):
    if x < 65:
        return math.atan(1 + x) ** 5 + 1 + 11 * x ** 2
    elif 65 <= x < 133:
        return math.cos(81 * x ** 2 + 1 + 13 * x) ** 7 / 64 - math.sqrt(x) ** 6
    elif 133 <= x < 221:
        return (55 * x ** 2) ** 6 + (x ** 3 - 58 - x ** 2 / 54) ** 5
    elif x >= 221:
        return 38 * x + (x ** 2 - 1) ** 6 / 8 + (49 * x ** 2 - 31 * x ** 3) ** 7 / 34"
"import math

def main(x):
    result = 0
    if x < 140:
        result = 85 * x
    elif x < 222:
        result = x ** 2 - x ** 4 / 34 - 42 * (x ** 2 + 1 + x / 25) ** 3
    elif x < 310:
        result = 46 * x - x ** 4 - 17 * math.log10(x) ** 5
    else:
        result = 93 * x ** 12
    return result
main(244)
main(307)"
"import math

def main(z):
    if z < 93:
        a = z ** 5
        b = (z ** 3 - z / 56 - 34) ** 3
        c = 72 * math.exp(z)
        f = a - b - c
    elif 93 <= z < 179:
        f = z ** 6 + 0.04
    elif 179 <= z < 206:
        a = math.asin(z) ** 6 / 74
        b = math.exp(10 * z ** 3) / 63
        c = z ** 3
        f = a - b - c
    elif z >= 206:
        f = 1 + 18 * z ** 7
    return f"
"import math
from math import fabs

def main(x):
    if x < 14:
        a = 65 * x ** 6
        return a
    elif x >= 14 and x < 85:
        b_1 = fabs(19 + x)
        b_2 = x ** 7
        b = 87 * b_1 ** 4 + b_2 + 13
        return b
    elif x >= 85:
        c_11 = 29 * x ** 2
        c_1 = c_11 ** 7
        c_21 = x / 47
        c_22 = x ** 2 / 88
        c_23 = 58 * x ** 3
        c_2 = (c_21 + c_22 + c_23) ** 3
        c = c_1 + c_2
        return c"
"import math

def main(x):
    if x < 112:
        a = pow(x, 3) + 15
        b = math.cos(a)
        B = pow(b, 4)
        c = 1 - x / 52
        C = pow(c, 7)
        f = B - C
    elif x < 152:
        f = pow(x, 7) + pow(x, 4) / 27 + pow(x, 3)
    elif x < 191:
        pows1 = 20 * pow(x, 3) + 1 + 26 * x
        pows2 = 1 + pow(x, 3) + x
        f = 0.05 - pow(pows1, 6) - pow(pows2, 3)
    elif x < 237:
        f = 17 * pow(x, 7) - 1 - 73 * pow(x, 3)
    else:
        f = pow(x, 3) / 49
    return f"
"import math

def main(y):
    if y < 123:
        return y ** 6
    elif 123 <= y < 216:
        return math.log1p(y) - 6 * y ** 2 - 1
    else:
        return 1 + math.sin(y ** 3) ** 2"
"import math

def main(y):
    if y < 36:
        res = 70 * pow(y + 1, 7) + 1 + abs(y)
    elif y < 84 and y >= 36:
        res = pow(y, 5) - 87 * pow(41 * pow(y, 3) + 55 * y, 3)
    elif y < 99 and y >= 84:
        res = pow(y, 6) / 16 + 65 * y
    elif y < 122 and y >= 99:
        res = pow(pow(y, 3) + 33 * y, 5) - pow(77 - pow(y, 2), 3) / 35
    elif y >= 122:
        res = 70 * pow(math.atan(pow(y, 2) - 42 * y - 1), 2)
    return res
main(-22)"
"import math
from math import log

def main(x):
    if x < 66:
        return x ** 6
    elif x >= 66 and x < 119:
        return 38 * x ** 4
    else:
        tmp = 4 * (x - 11 * x ** 2)
        return tmp - 60 * math.log(x ** 2 - 8 - 88 * x) ** 3"
"from math import *

def main(z):
    if z < 135:
        return 15 * pow(z, 6) + 54 * pow(z, 4) + pow(ceil(z), 5) / 41
    if 135 <= z <= 227:
        return 56 * pow(z, 6)
    if 227 <= z <= 242:
        return pow(z * z - pow(z, 3) / 86, 6) + 57 * z
    if 242 <= z <= 268:
        return 20 * pow(z, 4)
    if 268 <= z:
        return 48 * pow(z, 7)"
"from math import log2

def main(y):
    if y < 15:
        return 16 * y ** 5
    elif 15 <= y < 54:
        return 72 * log2(y + 72 * y ** 2) ** 5 - (y / 6) ** 4
    elif y >= 54:
        return y ** 18"
"import math

def main(y):
    if y < 103:
        f = 38 * y ** 5
    elif 103 <= y < 143:
        f = 78 * (47 * y - 33) ** 7 - 40 * math.log1p(y) ** 4
    elif 143 <= y < 224:
        f = (38 + y) ** 4
    elif 224 <= y < 243:
        f = 41 + y ** 5 + 26 * math.atan(y)
    elif y >= 243:
        f = 1 - y ** 2 - 69 * y ** 3
    return f"
"from math import *

def main(y):
    if y < 140:
        f = 79 * tan(y) ** 4 + 57 * cos(y ** 2)
        return f
    elif 140 <= y < 179:
        f = 1 - 89 * floor(y) ** 5 - 91 * log10(12 * y) ** 2
        return f
    elif y >= 179:
        f = 66 * abs(y ** 3) ** 6 + (1 + 69 * y ** 3) ** 4
        return f"
"import math
from math import fabs

def main(y):
    if y < -54:
        a = 2 * y ** 2 - 51 * (74 * y ** 2) ** 6
        return a
    elif y >= -54 and y < -9:
        b = y - y ** 7
        return b
    elif y >= -9 and y < 39:
        c_1 = (y ** 3 + 88 * y ** 2) ** 6
        c_2 = fabs(1 - y) ** 3
        c = c_1 + y ** 7 + c_2
        return c
    elif y >= 39:
        d_1 = y / 71
        d = y ** 2 - 56 * d_1 ** 3 - 1
        return d"
"from math import pow, cos, tan, fabs

def main(x):
    if x < 171:
        first = 5 * pow(x, 7)
        second = pow(x, 2) / 97 + 57 * x + pow(x, 3) / 9
        result = first - pow(second, 5)
    elif x >= 171 and x < 210:
        result = 2 * pow(tan(x), 5)
    elif x >= 210 and x < 290:
        first = 19 * x - pow(x, 3) - 32 * pow(x, 2)
        second = 82 * x - pow(x, 2)
        third = pow(cos(19 * pow(x, 2)), 6)
        result = pow(first, 5) - pow(second, 7) - third
    elif x >= 290 and x < 349:
        first = 2 * pow(x, 3) - 26 * x - pow(x, 2) / 94
        second = pow(x, 3) / 49 - 69 * x - 69 * pow(x, 2)
        result = 1 + 65 * pow(fabs(first), 6) + second
    elif x >= 349:
        result = pow(x, 5)
    return result"
"import math

def main(y):
    if y < 13:
        f = 89 * (88 + y * y + 84 * y * y * y) ** 2 + 1
    elif y < 106:
        f = 1 + 7 * math.cos(y - 66 - y * y) ** 6
    else:
        f = y ** 3 - y ** 4 - y ** 5
    return f"
"def main(z):
    if z < 38:
        return 95 * z ** 2 + z ** 6
    elif 38 <= z < 124:
        return 32 * (z ** 3 + 73 * z) ** 4 - 8
    else:
        a = (46 * z - z ** 2) ** 6
        b = 67 * (z ** 2 + 1 + z) ** 5 - z ** 7
        c = a - b
        return c"
"import math as m

def main(x):
    if x < 90:
        return (x ** 2 - x ** 3) ** 4 / 8 - 31 * x ** 6 - x ** 7
    if 99 <= x and x < 182:
        return m.ceil(x + x ** 2) ** 2 / 4
    if x >= 182:
        return 21 * (28 * x ** 2) ** 3 + x ** 5"
"from math import *

def main(num):
    if num < -38:
        return float('%.3g' % (18 * pow(0.01 + num + 90 * pow(num, 3), 6)))
    elif num < 28:
        return float('%.3g' % (pow(37 * pow(num, 3), 5) + pow(num, 2) / 48 + 82 * ceil(pow(72 * pow(num, 2), 4))))
    elif num < 49:
        return float('%.3g' % (pow(num, 6) - pow(pow(num, 3) / 99, 3) - num))
    elif num < 145:
        return float('%.3g' % (pow(num, 2) + pow(num, 2) + pow(pow(num, 3) + num / 86 + 1, 3) + 18 * pow(num, 5)))
    else:
        return float('%.3g' % (atan(pow(num, 3) - 53 * pow(num, 2) - num) + pow(num, 5)))"
"import math

def main(y):
    if y < 162:
        first = math.pow(math.exp(y), 3)
        return first
    elif 162 <= y < 234:
        sec = math.pow(y, 2) + 1 + math.cos(49 * y * y - 28 * y)
        return sec
    elif 234 <= y < 285:
        third = 0
        third += 74 * math.pow(y * y / 87 + 7 * y, 4)
        third += -(14 * math.pow(0.02 + 73 * y * y + y, 7))
        third += -(31 * math.pow(y, 5))
        return third
    elif y >= 285:
        fourth = 4 * y * y + 59 * math.pow(y, 6)
        return fourth"
"from math import sin

def main(x):
    if x < -56:
        return x ** 3
    elif -56 <= x < 10:
        return x ** 15
    elif 10 <= x < 20:
        return 71 * sin(x) ** 4 + x ** 7 / 30
    elif 20 <= x < 101:
        return 73 - (34 * x ** 2) ** 7
    elif x >= 101:
        return 81 * (91 * x ** 2 - 1 - x ** 3 / 42) ** 6"
"def main(y):
    if y < 136:
        return 73 * pow(y + y * y / 42 + 1, 5) - 1
    if y < 225:
        return 12 + pow(34 * pow(y, 3), 3)
    if y < 269:
        return 68 + y
    return 32 * pow(y, 3) - 0.02"
"import math

def main(y):
    F = 0
    if y < 28:
        F = math.pow(y, 3) / 63 + 93 * math.pow(y, 2)
    elif y >= 73:
        F = 12 * math.pow(y, 7) - math.pow(math.tan(y), 4)
    else:
        F = 24 * y - 59 * math.pow(65 * math.pow(y, 2), 4)
    return F"
"import math

def main(n):
    if n < 18:
        return 52 * math.floor(n)
    elif n >= 18 and n < 31:
        return 9 * n ** 3 - 81 * math.sin(59 * n ** 3 + 50 * n ** 20) ** 5
    elif n >= 31 and n <= 84:
        return math.sin(n) ** 4 + 73 * (74 * n + n ** 3 + 94 * n ** 2)
    elif n >= 84:
        return abs(78 * n ** 2) ** 5"
"import math

def main(x):
    a = 77 * (x + pow(x, 3) + x ** 2) ** 2
    z = x / 12
    if x < 97:
        return math.pow(x, 5)
    elif 97 <= x <= 148:
        return math.pow(math.pow(x, 3) - x ** 2 - 0.01, 6) + a
    elif 148 <= x <= 207:
        return 8 - math.pow(x, 5)
    elif 207 <= x <= 222:
        return math.pow(x, 5) + math.pow(35 * x, 3) / 23
    elif x >= 222:
        return 15 + 51 * math.pow(z, 6) + x ** 2
    return 0"
"import math

def main(x):
    if x < 48:
        f = 66 - 36 * pow(x, 5) - pow(math.floor(x * x), 4)
    elif 47 < x < 102:
        f = 41 * pow(x / 56 + 17, 2) + 97 * pow(12 * x * x - x * x * x, 5)
    elif 101 < x < 179:
        f = math.floor(x) / 62
    elif 178 < x < 230:
        f = 43 - 14 * pow(x, 7)
    else:
        f = 31 * x * x - pow(x, 3) + 49
    return f"
"from math import floor, log2

def main(y):
    if y < 2:
        return 57 * (y - 1 - 58 * y ** 2) ** 3
    elif y < 46:
        return floor(y) ** 4 - 1 - y ** 3 / 18
    else:
        return (92 * y ** 2 + 49 * y ** 3) ** 4 + log2(y) / 70"
"import math

def main(z):
    if z < 31:
        return math.cos(0.02 - z ** 2) ** 5
    if 31 <= z < 123:
        return 37 * math.ceil(z) ** 6
    if z >= 123:
        return z ** 2 - 1"
"from math import *

def main(y):
    if y < 46:
        return y ** 3
    if 46 <= y < 82:
        return 1 - y ** 2 - 32 * (1 - y) ** 4
    if 82 <= y < 181:
        return 83 * tan(y) ** 4
    if y >= 181:
        return 62 * (7 * y ** 3 + y) - y ** 5 - fabs(y + y ** 2) ** 6"
"from math import *

def main(x):
    if x < 5:
        return x ** 3
    if 5 <= x < 83:
        return 35 * sqrt(x) ** 3
    if x >= 83:
        return cos(x ** 2 - x ** 3 - x) ** 5 - 56 - x"
"import math

def main(y):
    if y < -55:
        return pow(math.asin, 2) * (34 * pow(y, 3) + 26 * y)
    elif -55 <= y < 37:
        return 14 * pow(y, 3) + 84 * pow(26 * pow(y, 3) + 1, 7) + 59 * pow(y, 15)
    elif 37 <= y < 53:
        return pow(abs(pow(y, 3 + 1 + 41 * y)), 5)
    elif 53 <= y < 119:
        return y
    elif y >= 119:
        return 88 * pow(7 * y + pow(y, 3), 2)"
"import math

def main(n):
    if n < 127:
        return 1 + math.sin(n) ** 5 + (17 * n ** 3 + 1) ** 4
    elif n >= 127 and n < 204:
        return n
    elif n >= 204:
        return math.sin(n) ** 7 - 52 * math.ceil(21 * n) ** 5"
"from math import cos, log10

def main(x):
    if x < 44:
        return 30 + (1 - x ** 2 - x ** 3 / 89) ** 2 + cos(6 * x) ** 4 / 67
    elif 44 <= x < 110:
        return 22 * x ** 6 + log10(x) ** 4
    elif x >= 110:
        return x + x ** 4"
"from math import *

def main(x):
    if x < -33:
        return exp(x) - 80 * pow(atan(65 * x ** 3 + x / 74), 2)
    elif -33 <= x < -7:
        return pow(x ** 3 + 20 * x ** 2 + x / 48, 4) / 36
    elif x >= -7:
        return pow(x ** 2 - 28 * x ** 3 - 1, 4)"
"from math import floor, ceil, exp

def main(y):
    if y < 34:
        return floor(y) ** 6
    elif y < 120:
        return (93 + y ** 3) ** 7 + exp(y) ** 3 + (34 - 91 * y ** 3 - y ** 2) ** 4
    elif y < 154:
        return 75 * y ** 3
    else:
        return 93 * ceil(y) ** 3"
"from math import cos, atan, asin

def main(x):
    if x < 147:
        return 25 * cos(76 - 43 * x ** 2 - x ** 3) ** 3 + 42 * x ** 6 + (x ** 3 - 1) ** 2
    elif x < 176:
        return atan(x ** 3 - x ** 2 - 1) ** 3
    elif x < 226:
        return 70 * asin(0.02 + x) ** 5
    elif x < 245:
        return 64 * x ** 3 + 57 + x ** 2 - 12 * (32 * x) ** 6
    else:
        return 49 * x ** 7"
"def main(y):
    if y < 120:
        return 36 * y ** 2 + (40 * y ** 2 + y / 54 + 1) ** 3 + 92 * y ** 5
    elif y < 183:
        return abs(98 * y ** 3 + 37 * y) ** 6 / 94
    else:
        return (y ** 2 / 29 - 68) ** 4 / 66"
"import math

def main(y):
    if y < 79:
        y = y ** 5 - 13 * y - y ** 4
    elif 79 <= y < 128:
        y = 9 * y ** 2
    elif 128 <= y < 185:
        y = 81 * y ** 3 + 1 + 80 * (84 * y) ** 3
    else:
        y = 58 * math.tan(y ** 2 + 0.04) ** 7 - y / 76
    return y"
"import math

def main(y):
    y = float(y)
    if y < -79:
        f = 33 * y ** 2 - 89 * (y ** 3 + y ** 2) ** 6
    elif y >= -79 and y < -40:
        f = y ** 3 - 66 * math.exp(y) ** 4 - 46 * (87 * y - y ** 3) ** 2
    elif y >= -40 and y < 56:
        f = y ** 6 + math.exp(y) ** 3 + 1
    elif y >= 56 and y < 108:
        f = math.log10(y) ** 5 - 8 * (0.07 - y) ** 7
    elif y >= 108:
        f = y ** 3 / 84 - (18 + 45 * y ** 3 + 40 * y) ** 4 - 54
    scientific_notation = '{:.2e}'.format(f)
    return float(scientific_notation)"
"from math import tan

def main(z):
    if z < 138:
        return 39 * (41 * z ** 2 - 1) + 3 * z ** 3
    elif z < 166:
        return tan(z) ** 5
    else:
        return (z / 41 - 1 - 27 * z ** 2) ** 5"
"import math

def main(y):
    if y < -1:
        y = (y ** 3 - 0.03 - y) ** 6 / 26 + 27
    elif -1 <= y < 15:
        y = y ** 7 / 42
    else:
        y = y ** 2 - y ** 4 - 9 * y ** 7
    return y"
"import math

def main(x):
    if x < 10:
        return 91 * pow(math.tan(x), 6)
    elif 10 <= x < 26:
        return pow(x, 4) / 73
    elif 26 <= x < 122:
        return pow(x, 4) / 39
    elif 122 <= x < 209:
        return 51 * pow(x, 2) - 32 * pow(x, 7)
    elif x >= 209:
        return pow(abs(10 * pow(x, 3)), 3)"
"from math import log10, tan

def main(x):
    if x < 96:
        return 59 * log10(x ** 2 + 2) ** 3
    elif x < 152:
        return 69 - (x ** 3 + x ** 2 + 1) ** 2
    elif x < 249:
        return 94 * (x / 28) ** 5 - 95 * x ** 4
    else:
        return (41 * x ** 2 - 11 * x ** 3 - 0.06) ** 5 - tan(34 - x ** 2 - 5 * x) ** 7"
"from math import tan

def main(y):
    if y < -9:
        return (23 * y ** 3 - 49 * y ** 2 - 66 * y) ** 2 - 73 * 73 * tan(y) ** 3
    elif y < 35:
        return 27 * y ** 2
    elif y < 67:
        return y ** 4 - 72 - 92 * y ** 3
    elif y < 157:
        return (56 * y ** 2 + 35 * y ** 3) ** 4 - 16 * abs(y ** 3 / 77) ** 2
    else:
        return 40 * y ** 3"
"def main(x):
    if x < 165:
        return x ** 4
    elif x < 218:
        return 59 * (0.06 + 71 * x ** 3 + x) ** 6 - (x ** 3 / 56 + x ** 2) ** 3
    elif x < 301:
        return 20 * x ** 2 + 53
    else:
        return 27 * x ** 2 - 1 - 52 * abs(x) ** 7"
"import math

def main(z):
    if z < 44:
        a = 57 - z * z - z ** 3 / 94
        return a ** 4 - 90 * z * z - 99 * z * z
    elif z >= 44 and z < 99:
        return math.fabs(z) ** 4 + 54 * z ** 3
    elif z >= 99 and z < 127:
        a = 2730 * z ** 3
        return a - 10 * (3 + 6 * z ** 3) ** 6 - 72 * z ** 7
    elif z >= 127 and z < 202:
        a = 1 - z ** 3 - 18 * z * z
        return a ** 4 + z ** 2 ** 0 / 5 ** 7 / 20
    else:
        a = 62 * z ** 6
        return a"
"import math

def main(y):
    if y < 135:
        result = math.log2(69 * y ** 2) ** 5 - 12 * y ** 6
        return result
    elif y >= 160:
        result = 69 - y ** 4
        return result
    else:
        result = math.log10(77 * y ** 2 + 63 + 98 * y) ** 7
        result += 58 * math.cos(y) ** 5
        result += 78 * y ** 6
        return result"
"import math

def main(z):
    if z < 35:
        second = pow(74 * z + 66 + 20 * pow(z, 3), 3)
        return second
    elif 35 <= z <= 106:
        second = pow(pow(z, 2) + pow(z, 3), 5)
        second -= pow(24 * z, 7) - 37 * pow(z, 3)
        return second
    else:
        second = 91 * pow(93 * pow(z, 2), 6)
        second += 4 * pow(abs(44 * z), 2)
        return second"
"import math

def main(z):
    if z < 49:
        k = math.pow(math.ceil(z), 3)
    elif (z >= 49) & (z < 107):
        k = math.pow(math.fabs(z), 7)
    elif (z >= 107) & (z < 140):
        k = z - 25 * math.pow(math.ceil(z), 5) - math.pow(z, 2) / 55
    else:
        k = math.pow(math.ceil(z), 5) + 14 * math.sqrt(math.pow(z, 2) / 85 + z)
    return k"
"import math

def main(y):
    if y < 77:
        a = 34 * y + y ** 6
    elif y < 116:
        a = 83 * (79 * y) ** 5
    else:
        a = y ** 4 / 35 + math.atan(0.04 - y ** 3) ** 5
    return a"
"import math

def main(x):
    if x < 37:
        b = 1 - x ** 6 / 20 - math.sin(1 - 72 * x ** 3 - x) ** 3
        return b
    elif x < 114:
        b = x ** 2 - math.log10(x) * 6 - x ** 7
        return b
    elif x < 203:
        b = math.cos(x) ** 7 + x ** 5 / 40 + x
        return b
    elif x >= 203:
        b = 88 * math.log10(x ** 3 - 1)
        return b"
"import math

def main(y):
    if y < 74:
        return 5 * (10 * y ** 3 + y + y * y / 38) ** 2
    if y < 151 and y >= 74:
        return 21 * y ** 2 + 1 + 86 * y ** 2
    if y < 228 and y >= 151:
        return 17 * y ** 6
    else:
        return y ** 2 + math.ceil(y ** 3 - y / 81) ** 7 + 45"
"import math

def main(z):
    if z < 34:
        return z ** 7
    elif z < 52:
        return 60 * (z ** 3 / 91 - z) ** 6
    elif z < 99:
        return z ** 4
    else:
        return math.log2(13 * z ** 2 - 1) ** 2 / 39 + z ** 4 + 13 * z ** 3"
"import math

def main(z):
    if z >= 212:
        return math.tan(z) ** 5
    elif z >= 115:
        return z ** 2
    elif z >= 66:
        return 39 * z ** 7 - z ** 3
    elif z >= -6:
        return 2 * abs(z) ** 5
    else:
        return math.tan(z ** 2 - 71 * z ** 3 - z) ** 6 / 57 + 52 * math.sqrt(8 * z ** 2) ** 3"
"from math import *

def main(z):
    if z < 43:
        return z - 55
    elif 43 <= z and z < 132:
        return 33 * (z ** 3 - 63 * z) ** 3
    elif 132 <= z and z < 143:
        return 26 * abs(z) ** 4 + 1 + 29 * log10(z ** 2 + 67 + 73 * z)
    elif z >= 143:
        return (1 + z + 52 * z ** 2) ** 5"
"def main(x):
    if x < 97:
        f = x ** 3 - 15 * x ** 7
    elif x >= 97 and x < 156:
        f = x ** 6
    elif x >= 156 and x < 230:
        f = 33 * x ** 3
    elif x >= 230 and x < 308:
        f = 85 * x ** 6 - 93 * (x ** 2 / 59 + x ** 3) ** 2 - 1
    elif x >= 3086:
        f = 14 * math.log(2, x) ** 6 + (38 * x ** 2) ** 7 + 1
    return f"
"from math import *

def main(z):
    if z < 83:
        return sin(z) ** 5
    elif z >= 83 and z < 104:
        return atan(68 + z + 48 * z ** 2) ** 3
    else:
        return (57 - z) ** 6 - 35"
"import math

def main(x):
    if x < 152:
        return abs(69 * x ** 3 + 93 + 67 * x ** 2) ** 5 - abs(x ** 3 - 4) ** 7
    if 152 <= x < 194:
        return 1 - 96 * (x - x ** 2 / 47 - 0.01) ** 5
    if 194 <= x < 258:
        return x ** 4 + (38 * x ** 3) ** 6 + 69 * x ** 3
    if x >= 258:
        return (1 - x ** 3 - 34 * x ** 2) ** 6"
"import math as m

def main(y):
    if y < 85:
        return 22 * y ** 5 - y ** 2
    elif 85 <= y < 183:
        return (y ** 3 / 64) ** 2 + m.floor(y) ** 6
    elif y >= 183:
        return 38 * y ** 7 - (33 * y ** 3 + 82) ** 3 - y"
"import math

def main(x):
    if x < 157:
        return x ** 2 - 0.04 - 39 * x ** 7
    elif 157 <= x < 241:
        return 23 * x ** 4 + math.tan(x) ** 5 + (x ** 2) ** 6
    elif 241 <= x < 305:
        return x ** 6 + 1
    elif 305 <= x < 394:
        return 74 * (37 * x ** 3) ** 2
    else:
        return 34 * x ** 3 + 1 - (x ** 3 / 25 - 97) ** 4 - x ** 7"
"import math

def main(z):
    f = pow(z, 4) - 57 * (73 + pow(z, 3))
    h = pow(z, 5) + math.ceil(pow(z, 2))
    k = pow(math.ceil(8 * pow(z, 2) - pow(z, 3) - 1), 2)
    d = h + k
    c = 6 * pow(z, 3) + 1 + 99 * pow(z, 14)
    s = pow(z, 3) + pow(math.ceil(43 + pow(z, 2)), 4)
    if z < 127:
        result = f
        return result
    elif 127 <= z <= 168:
        result = d
        return result
    elif 168 <= z <= 197:
        result = c
        return result
    else:
        result = s
        return result"
"def main(y):
    if y < 82:
        return (34 + y) ** 6 - 8 * y ** 3
    elif y < 167:
        return (39 * y ** 2 - 69) ** 4
    elif y < 241:
        return 83 * (1 + y ** 2 / 24 + 25 * y) ** 5
    else:
        return 57 - y ** 6"
"import math

def main(y):
    if y < 3:
        one = pow(y, 5)
        return one
    elif 3 <= y < 94:
        two = 9 * pow(4 + 32 * y, 2) + pow(y, 4) / 52 + pow(y, 3)
        return two
    elif y >= 94:
        three = pow(1 - y, 7)
        return three"
"def main(y):
    if y < 107:
        return 36 * (y ** 3 + y + y ** 2 / 99) ** 2
    elif 107 <= y < 125:
        return (32 * y ** 3 + 70 * y ** 3 + 1) ** 3 - (y ** 2 - 1 - y ** 3) ** 6 - 81 * y ** 4
    else:
        return 44 * abs(y ** 2 - 1 - y ** 3) ** 6 - (y ** 2 - 63 * y ** 3 - 1) ** 7"
"import math

def main(x):
    if x < 8:
        return x ** 2 / 30
    elif 8 <= x < 77:
        return (x / 13) ** 7 + 18 * (1 + 51 * x + 56 * x ** 2) + 61 * x ** 4
    elif 77 <= x < 97:
        return math.cos(93 * x + x ** 3 + 69 * x ** 2) ** 2
    elif 97 <= x < 196:
        return x / 62 + math.fabs(x) ** 4
    elif x >= 196:
        return (x ** 2 - 93 - x ** 3) ** 3 + (x ** 3 / 93) ** 5 + math.fabs(x) ** 4"
"from math import ceil, tan, sin

def main(y):
    if y < 60:
        return 84 * pow(y ** 2 / 9 - 1 - y ** 3, 5) + y ** 3 + 59 * y ** 2
    elif 60 <= y < 131:
        return (59 * y) ** 7 + y ** 6 / 60 + pow(sin(y), 3)
    elif 131 <= y < 172:
        return 1 - y ** 2 - pow(tan(y), 5)
    elif 172 <= y < 222:
        return y ** 4
    else:
        return 5 * ceil(31 * y ** 3 + y ** 2 + 11 * y) ** 5"
"def main(x):
    if x < 20:
        return 85 - (x ** 3 - 1 - x) ** 3 - (1 + x ** 2 + x ** 3) ** 5
    elif x < 74:
        return 91 * (71 * x ** 3 + 61 * x + 62) + x ** 5
    else:
        return 35 * x ** 2 - 1"
"import math

def main(z):
    if z < -51:
        res = z ** 6
    elif -51 <= z < 37:
        res = z ** 6 + 0.02
    elif 37 <= z < 124:
        res = math.tan(z ** 2 + z ** 3 * 29) ** 3 - 39
    else:
        res = z
    return res"
"def main(n):
    if n < 73:
        return 27 * (n ** 3 + 84 * n + n ** 2 / 2) ** 6
    elif n >= 73 and n < 124:
        return (74 * n - n ** 2) ** 3 - 0.02 - 75 * (60 * n ** 3 + 5) ** 6
    elif n >= 124:
        return n ** 15 - 49 * n ** 3"
"import math

def main(x):
    if x < 170:
        return 94 * x ** 3
    elif 170 <= x < 243:
        return x + x ** 2 + 66
    elif 243 <= x < 279:
        return 8 * x ** 4 + 1
    elif 279 <= x < 305:
        return x ** 2 + 44
    else:
        a = 45 * x ** 2 - x ** 3 - x / 54
        return a ** 6 + math.atan(x) ** 2 + 48 * (87 * x ** 2) ** 4"
"import math

def main(y):
    if y < 162:
        return 73 * y ** 2 - 90 * y - 98
    elif 162 <= y < 218:
        return 23 * math.floor(y) ** 5
    elif 218 <= y < 307:
        return y ** 6
    else:
        return 90 * y ** 3"
"import math

def main(z):
    if z < 112:
        return z ** 5 / 88 - 48
    elif 112 <= z < 132:
        return z ** 3 / 31 + math.tan(z) ** 4
    elif 132 <= z < 176:
        return 35 * z ** 5 + z ** 7
    else:
        return math.atan(z) ** 2 - 20 * (37 * z ** 2 + 28) ** 5"
"import math

def main(z):
    if z < 175:
        return (z ** 3 + 24 * z ** 2 + 22 * z) ** 5 - z ** 2 - 54 * z ** 2
    if 175 <= z < 272:
        return 50 * z ** 7
    if 272 <= z < 290:
        return (17 * z ** 2 - z) ** 6 - math.exp(z) - z ** 2
    return math.ceil(z) ** 5 / 7 - 25"
"from math import tan, atan

def main(z):
    if z < 105:
        return z ** 4 - 67 - (76 * z - z ** 2) ** 7
    elif z < 203:
        return tan(z ** 3 + 97)
    else:
        return 3 * tan(65 * z ** 2) ** 6 - atan(17 * z ** 2 - 5 * z ** 3) ** 2"
"import math

def main(z):
    if z < 107:
        n1 = 10 * z ** 5 - z ** 4
        return n1
    elif 107 <= z < 127:
        n2 = math.pow(abs(z + 1 + z ** 3 / 2), 3)
        return n2
    elif 127 <= z < 184:
        n3 = 97 * z - z ** 4 - 7
        return n3
    elif 184 <= z < 280:
        n4 = 25 * math.pow(33 * z - 1 - 20 * z ** 2, 7)
        return n4
    elif z >= 280:
        n5 = math.pow(z - 0.02 - z ** 2, 6) + z ** 5
        return n5"
"import math

def main(y):
    if y < 85:
        f = 24 * math.fabs(y + y ** 3 / 13 + 14 * y ** 2) ** 2 + y ** 6
    elif y < 169:
        f = math.floor(1 + y) ** 5 - 19 * (38 * y ** 2) ** 6
    elif y < 264:
        f = 43 * math.cos(y) ** 7 + 2 * math.log2(45 * y ** 3 + 38 + y ** 2 / 66) ** 5 + 72
    else:
        f = 1 + 56 * y ** 4 + 73 * y ** 5
    return f"
"import math

def main(y):
    a = (y ** 3 + 61 + y) ** 6 + 55 * (1 + 93 * y ** 3 + y ** 2) + 72 * y ** 8
    b = 47 + y + y ** 5 / 92
    c = math.atan(54 * y - 98 * y ** 2 - 98) ** 4
    if y < 130:
        return a
    if 130 <= y < 186:
        return b
    if y >= 186:
        return c"
"import math

def main(z):
    if z < 21:
        return abs(z) ** 7 + z
    if 21 <= z < 111:
        return 49 * z ** 6 + z ** 5 / 86
    if 111 <= z < 188:
        return (z + 53) ** 4
    if z >= 188:
        s = math.sin(55 * z + 26 * z ** 3 + z ** 2) ** 3
        return 64 * z ** 2 - 55 - s"
"from math import *

def main(x):
    if x < 103:
        return pow(x, 10)
    if x >= 103 and x < 185:
        return 81 * pow(pow(x, 2) + 98 * x, 3) - pow(0.02 + pow(x, 2), 4) - 57
    if x >= 185 and x < 217:
        return x / 96 + pow(pow(x, 2) + x, 7) + 1
    else:
        return 69 * cos(x) ** 4"
"import math

def main(y):
    y = float(y)
    if y < 10:
        f = 55 * (31 * y + y ** 3) ** 5
    elif y >= 10 and y < 57:
        f = (11 * y ** 2 + 49 * y ** 3) ** 2 - 528 * y - math.tan(y) ** 7
    elif y >= 57 and y < 122:
        f = y ** 5 - 69
    elif y >= 122:
        f = y + math.log1p(y) ** 3 + y ** 12 / 81
    scientific_notation = '{:.2e}'.format(f)
    return float(scientific_notation)"
"def main(z):
    if z < 3:
        return pow(2 * pow(z, 3) + 13 * pow(z, 2), 2) + 1
    if 3 <= z < 89:
        return 17 * pow(pow(z, 2) - z, 2) + 88 * pow(z + 0.02, 6)
    if 89 <= z < 151:
        return 98 * pow(43 * pow(z, 3) - pow(z, 2), 3)
    if 151 <= z < 204:
        return 5 * pow(pow(z, 3) - 60 * pow(z, 2) - z / 92, 4)
    if z >= 204:
        return 94 * pow(z, 3)
    return 0"
"from math import pow

def main(x):
    if x < 60:
        return pow(x, 4) - 65 * pow(x, 7) - pow(36 * pow(x, 3) + pow(x, 2), 5) / 12
    elif 60 <= x < 144:
        return 87 * pow(x, 6)
    elif 144 <= x < 200:
        return pow(pow(x, 2) - 64 * x, 3) - x
    elif 200 <= x < 213:
        return pow(x, 7) / 88 + pow(x, 6)
    else:
        return x + pow(20 * pow(x, 3) + 0.03, 4) + 29 * pow(40 * pow(x, 3), 7)"
"def main(x):
    if x < -52:
        return 1 + 39 * x ** 5
    elif x >= -52 and x < -18:
        return 1 + 24 * x ** 3
    elif x >= -18 and x < 35:
        return 76 * x ** 3 - 26 * x ** 7
    else:
        return x ** 3 / 75"
"from math import *

def main(z):
    if z < 91:
        return 61 * ceil(z) ** 3 - 93 * (0.2 + 23 * z + z ** 2)
    elif 91 <= z and z < 134:
        return 11 * ceil(z) ** 4
    elif 134 <= z and z < 158:
        return 1 - z ** 3
    elif 158 <= z and z < 224:
        return (78 * z ** 2) ** 6
    elif z >= 224:
        return z ** 4 / 72 - (0.01 + z ** 2) ** 3 - 48 * z ** 6"
"import math

def main(x):
    if x < 77:
        return 90 * (1 + x + x ** 3) ** 7 - math.log(x, 2) ** 4 - x ** 6
    if x >= 77 and x < 119:
        return (1 + 90 * x) ** 5 + math.cos(x) ** 7 + x ** 4 / 69
    if x >= 119 and x < 157:
        return 41 * math.floor(x) ** 2
    if x >= 157:
        return math.floor(49 - x ** 2 - x) ** 6 + 80"
"from math import log

def main(y):
    if y < 66:
        return (y ** 2 + 0.14 + 7 * y) ** 4
    elif y < 161:
        return y ** 6 - 40 * log(y, 10) ** 2 - 23 * y ** 4
    else:
        return (y / 92 - 0.14) ** 4"
"import math

def main(x):
    if x < 101:
        return x ** 6
    elif 101 <= x < 157:
        return x ** 4 - 51 * math.atan(1 - x ** 3 / 39) ** 3
    elif x >= 157:
        return math.exp(x) ** 3 / 26 - 0.01 - math.exp(x) ** 7"
"from math import floor, atan, tan, sin

def main(z):
    if z < 83:
        return z ** 3 + z ** 6 + 63 * (z - 42 * z ** 2)
    elif z < 145:
        return floor(61 * z - 92 * z ** 2 - 1) ** 3 + 53 * (20 + 24 * z ** 2) ** 7 + 74 * atan(23 * z ** 3 + z / 61 + 12)
    elif z < 166:
        return 75 * (81 * z ** 3 + 96 + 93 * z ** 2) ** 6
    elif z < 179:
        return 98 * tan(z) ** 6 + 59 * sin(z / 34 - 1) ** 2 + z ** 5
    else:
        return 0.04 - z / 88 - 24 * (0.01 - z) ** 7"
"import math

def main(z):
    if z < -80:
        final = 87 * z ** 6
    elif z >= -80 and z < 19:
        final = 99 * z + 85 * (62 * z + 46 + 43 * z ** 2) ** 5
    else:
        final = 44 * math.log(z, 10) ** 6 - 90
    return final"
"import math

def main(y):
    if y < 83:
        return y ** 10 - y ** 2 / 97
    if 83 <= y < 110:
        return math.ceil(y) + y ** 6 + math.log10(y) ** 4
    if 110 <= y < 185:
        return 23 * y ** 3 - 65 * (y ** 2 - 44 * y - 68 * y ** 3) ** 5
    if 185 <= y < 235:
        return (y - 1 - y ** 2) ** 6 / 52 - 62 * y ** 7 - 54 * y ** 4
    return 13 * math.log(y) + (y / 99 + 39 + 26 * y ** 3) ** 3 + 0.02"
"import math

def main(z):
    if z < 175:
        return (z ** 3 + 24 * z ** 2 + 22 * z) ** 5 - z ** 2 - 54 * z ** 2
    if 175 <= z < 272:
        return 50 * z ** 7
    if 272 <= z < 290:
        return (17 * z ** 2 - z) ** 6 - math.exp(z) - z ** 2
    return math.ceil(z) ** 5 / 7 - 25"
"import math

def main(y):
    if y < 70:
        return y ** 5 + math.exp(y) ** 3
    if 70 <= y < 148:
        return 12 * y - 77 * math.floor(y) ** 2 - 50 * (97 * y ** 2 + 1 + y) ** 4
    if 148 <= y < 187:
        return 6 + 81 * math.sin(96 * y ** 3) ** 4
    if 187 <= y < 287:
        return y ** 5
    if y >= 287:
        return (1 + 72 * y ** 2) ** 3 + 34 * (78 + 60 * y ** 2) ** 5"
"import math

def main(z):
    if z < 16:
        a = 40 * (31 * z - 21 * z ** 2) ** 3
        return a
    if 16 <= z < 99:
        return 92 * math.exp(z) ** 3 - 1
    if 99 <= z < 136:
        return z ** 6
    if 136 <= z < 169:
        b = 23 * z ** 21 - 24 * z ** 3
        c = (z ** 3 + 55 * z) ** 5
        return b - c
    if z >= 169:
        return 1 - 83 * (93 * z ** 2 - z - 1) ** 3"
"import math

def main(x):
    if x < 14:
        a = 59 * math.sin(x) ** 2
        return a
    elif 14 <= x < 59:
        b = (6 * x ** 2) ** 4 / 93
        return b
    elif x >= 59:
        c = math.exp(6) * (44 * x ** 2 - x / 89 - x ** 3) - 1 - 53 * x ** 7
        return c"
"import math

def main(z):
    if z < 31:
        return 78 * math.sin(1 - z - z ** 2) ** 4 - 80 * (z ** 3 + 1) ** 5
    if 31 <= z < 127:
        return z ** 7
    if z >= 127:
        return 97 * (1 - z ** 2)"
"import math

def main(x):
    if x < 62:
        return (x ** 3 - 1 - x ** 2) ** 5 / 10 - 32 * (57 * x ** 3 - 1 - 76 * x ** 2) ** 2 - (1 + 41 * x ** 2) ** 6
    elif 62 <= x < 101:
        return (x - 73 * x ** 2) ** 6 - 89 * (27 * x - 5 * x ** 3 - 57 * x ** 2) ** 5 - 13 * x ** 4
    elif 101 <= x < 132:
        return x ** 7 + 91 * x ** 4 + 43
    elif 132 <= x < 170:
        return 2025 * x
    else:
        return math.log(12 * x + x ** 3 / 45) - 75 - x ** 2"
"import math

def main(x):
    if x < 143:
        return math.pow(1 + x, 6)
    elif (143 <= x) & (x < 235):
        return math.pow(x, 6)
    elif (x >= 235) & (x < 326):
        return 20 * math.pow(x, 4)
    elif x >= 326:
        return math.pow(math.log(x, 2), 7) / 4 - math.pow(x + x ** 3 + x ** 2, 3) - math.cos(54 * x + 10 * x ** 3)"
"import math

def main(x):
    if x < -31:
        return 51 * math.atan(x) ** 4 - x ** 7
    elif -31 <= x < 66:
        return 63 * (97 * x + 72 + 97 * x ** 2) ** 3 + x ** 6
    elif 66 <= x < 149:
        return (x - x ** 2 - 10) ** 3
    else:
        return math.cos(20 + 38 * x ** 3) ** 7"
"import math

def main(y):
    if y < 107:
        return math.sin(65 * y ** 3) ** 5 + 1
    if 107 <= y < 179:
        return y ** 4 + 29 * y ** 6
    if 179 <= y < 209:
        return 13 * y ** 6
    if y >= 209:
        return y ** 4"
"import math

def main(y):
    if y < 86:
        return 55 * y ** 5 - math.fabs(y) - math.atan(y) ** 2 / 19
    elif y >= 86 and y < 99:
        return 30 * y ** 7
    elif y >= 99 and y < 175:
        return (72 * y ** 3 - 97) ** 4
    elif y >= 175 and y < 203:
        return 63 * (1 + y ** 2) ** 3
    elif y >= 203:
        return y - (46 * y ** 2 - y - 60) ** 4 - 36 * y ** 7"
"from math import atan

def main(x):
    if x < 78:
        return 97 * x ** 5 - 85 * x ** 2 - x ** 7
    elif x < 177:
        return 46 * (72 * x + 0.03) ** 2 - atan(x - x ** 3 - 52 * x ** 2) ** 4
    elif x < 188:
        return x ** 4
    else:
        return 22 * atan(x) ** 3 + 68 * x ** 7"
"import math

def main(y):
    if y < 120:
        a = (78 + y ** 3 + 87 * y ** 2) ** 2
        return math.floor(76 * y ** 2) ** 6 + y ** 7 + 93 * a
    if 120 <= y < 141:
        return math.sin(y - 47 * y ** 2) ** 2 + (77 * y) ** 3 + 83 * y ** 21
    if 141 <= y < 228:
        return 1 + 45 * math.log10(y)
    if 228 <= y < 279:
        return 62 * y ** 3 + (y + 50 * y ** 2 + (y ** 3 / 79) ** 4) / 17 + 42
    if y >= 279:
        return (34 + 50 * y) ** 7 / 98 + y ** 6 + math.sin(41 * y ** 3 - 92 * y ** 2 - 44 * y) / 9"
"from math import *

def main(z):
    if z < 132:
        return z ** 6 + (z ** 2 + 13 * z ** 3 + z) ** 5
    elif 132 <= z < 212:
        return z ** 4
    elif 212 <= z < 288:
        return z ** 4 / 73
    elif z >= 288:
        return 54 * z ** 2 + (1 - 11 * z ** 3) ** 3 + 30"
"def main(x):
    if x < 52:
        return x ** 5
    elif 52 <= x < 132:
        return 27 * x ** 4 - 69 * x ** 6
    elif 132 <= x < 208:
        return (x ** 2 + 91 * x ** 3) ** 7 / 78 + x
    else:
        return 81 * x ** 5 + (x ** 3 + 96 * x + 0.02) ** 2"
"def main(y):
    if y < 91:
        result = (72 + 69 * y ** 2 + y ** 3) ** 3 - y ** 2
    elif 91 <= y < 117:
        result = 75 * (y ** 3 / 95 - 65 * y) ** 3
    elif 117 <= y < 198:
        result = (y // 1) ** 7 / 88 + 92
    elif y >= 198:
        result = ((98 * y ** 3 + 1 + y) // 1) ** 4
    return result"
"import math

def main(z):
    if z < 117:
        return 27 * (z ** 2 + z ** 3 + 14) ** 4 - 33 * z ** 5
    elif 117 <= z < 174:
        return (88 * z ** 3 + 12 * z ** 2) ** 7
    elif 174 <= z < 205:
        return 53 * (z - 24 * z ** 3) ** 4 - math.tan(z) ** 5 / 27
    else:
        return (z + 65 + z ** 2 / 38) / 47 + (30 * z ** 2) ** 2 / 62"
"import math

def main(x):
    if x < 170:
        return x ** 3
    if 170 <= x < 201:
        return 74 * math.atan(27 * x ** 3 + x ** 2 + 14 * x) ** 2 + 58 * x ** 5
    if 201 <= x < 287:
        a = x + x ** 2
        return 64 * (67 * x ** 3 + 26 + 55 * x ** 2) ** 6 - 89 * a - 14 * math.cos(4 * x + 64 * x ** 2) ** 3
    if x >= 287:
        return x ** 2 + 68 * abs(x) ** 4"
"import math

def main(z):
    if z < 5:
        first = math.floor(z ** 3 / 80 - 0.01) ** 4 + (68 * z ** 2) ** 6 + 40 * math.tan(z)
        return first
    elif 5 <= z < 35:
        second = (1 + z + z ** 2) ** 7
        return second
    elif 35 <= z < 79:
        third = math.log2(z) ** 4 - (z ** 3 - 75 * z - 99) ** 5
        return third
    elif 79 <= z < 119:
        fourth = z + (0.01 + 91 * z + z ** 2 / 90) ** 5 + z ** 3
        return fourth
    elif z >= 119:
        f = z + z ** 6 / 33
        return f"
"import math

def main(x):
    if x < 123:
        return 3 + (40 * x ** 2) ** 4 / 7 + 82 * x
    elif x < 155:
        return 18 * math.cos(x) - 21 * (28 * x ** 2 - x) ** 5 - math.exp(42 * x - 96 - x ** 2) ** 2
    elif x < 175:
        return x ** 2 + 78 * (60 * x + x ** 2 / 24) ** 5
    elif x < 263:
        return math.log2(x) ** 4 - 0.02 - 50 * x
    else:
        return x ** 3 / 66 + 92"
"import math

def main(x):
    if x < 94:
        a = (74 * x ** 2 + 58 * x ** 3 + 36) ** 6 / 58
        b = 87 * x ** 4
        return a + b
    elif 94 <= x < 178:
        a = 13 * (52 * x ** 3 + x ** 2 + 12) ** 6
        b = 79 * math.tan(x) ** 5
        return a - b
    elif 178 <= x < 218:
        return math.tan(x ** 3) ** 2
    else:
        a = 72 * x ** 6
        b = math.fabs(x) ** 4
        return a + b"
"import math

def main(z):
    if z < 127:
        return (36 * z ** 3) ** 4 / 4 + 69 * z ** 3 + z ** 2 / 7 + z
    elif 127 <= z < 153:
        return math.log1p(z) ** 2 - (z ** 3 - z * z / 54) ** 4 / 76
    elif 153 <= z < 211:
        return z
    elif 211 <= z < 276:
        return 73 + (z * z + 69 + z) ** 6
    elif z >= 276:
        return 22 * math.tan(54 - z) ** 3 + 19 * z ** 6"
"from math import floor, atan

def main(y):
    if y < -61:
        return 60 * floor(y ** 2) ** 4 + 65 * abs(51 * y ** 2) ** 3 + atan(y ** 3 + 29 * y) ** 6 / 33
    elif y < 18:
        return y ** 5 - 44 * y - y ** 7
    elif y < 31:
        return (y ** 2 / 16) ** 7 - 66 * y ** 4
    elif y < 91:
        return (1 + 5 * y + y ** 2) ** 2
    else:
        return (y - y ** 2) ** 5"
"import math

def main(y):
    if y < -70:
        return math.floor(y) ** 7
    if -70 <= y < -36:
        return 49 * math.sqrt(48 + y ** 2) ** 4 + y ** 6
    if -36 <= y < 46:
        return 70 * y ** 6
    if 46 <= y < 99:
        return (y ** 3 / 30 - 1) ** 4
    if y >= 99:
        return y ** 6"
"import math

def main(z):
    if z < -53:
        return (20 * z ** 3 - 19 * z ** 2) ** 5 + 20 * z ** 6
    if -53 <= z < 11:
        return (z ** 2 - 23 * z - 0.01) ** 5 - 71 * z ** 2
    if 11 <= z < 54:
        return z ** 7 + abs(z) ** 4 + 16 * (95 * z ** 3 + 23 * z * z + 22 * z) ** 2
    if 54 <= z < 108:
        return 10 * math.atan(z) ** 4 - 1 - 96 * z ** 3
    if z >= 108:
        return 49 * z ** 5 - 1 - 16 * z ** 18"
"def main(x):
    if x < 26:
        return 0.01 + x ** 2 + x
    elif 26 <= x < 83:
        return x ** 4
    else:
        return abs(x)"
"from math import atan, sin

def main(y):
    if y < -26:
        return 35 * (1 - 88 * y ** 3 - 37 * y) ** 2 - 74 * atan(y) - (1 + 78 * y ** 3) ** 7
    elif y < 15:
        return 87 * sin(93 * y ** 3 + y ** 2) ** 5 - 76 * (59 * y + 31 * y ** 2) ** 4
    else:
        return 32 * (49 * y ** 3) ** 2 - y"
"import math

def main(y):
    if y < 152:
        return float('{:.2e}'.format(58 * pow(pow(y, 3) + 0.05 + y, 4) - pow(67 - pow(y, 2) / 83 - pow(y, 3), 3) - math.atan(32 * pow(y, 2) - y - 26)))
    elif y >= 152 and y < 180:
        return float('{:.2e}'.format(pow(y, 4)))
    elif y >= 180 and y < 209:
        return float('{:.2e}'.format(abs(y) / 56 + pow(y, 3) + 1))
    else:
        return float('{:.2e}'.format(y + 60 * (87 * pow(y, 2) - 1) + 58))"
"def main(y):
    if y < 116:
        f = 82 * y ** 6
    elif y < 167:
        f = (64 * y ** 2 + 34 * y) ** 2 - 17 * (1 - y ** 2 / 3) ** 7 - y ** 5
    else:
        f = y ** 7
    return f"
"import math

def main(z):
    if z < 116:
        return 43 * pow(z, 6) - pow(z, 4) - 96 * pow(math.tan(15 * z), 7)
    elif z >= 116 and z < 184:
        return 40 * pow(z, 7)
    elif z >= 184 and z < 250:
        return 2 * abs(z) + pow(z, 6)
    elif z >= 250 and z < 340:
        return 35 * pow(pow(z, 2) - pow(z, 3) - 92 * z, 6) + pow(z, 5)
    else:
        return 39 * pow(math.atan(z), 5)"
"from math import *

def main(z):
    f = 0
    if z < 160:
        f = z / 90
        return f
    elif 160 <= z < 249:
        f = pow(ceil(z), 3) / 12
        return f
    elif 249 <= z < 293:
        f = 76 - pow(exp(z), 2)
        return f
    elif 293 <= z < 362:
        f = 81 * pow(log10(97 * z), 3)
        return f
    else:
        f = (z - 3 * z ** 3) ** 2
        return f"
"import math

def main(x):
    if x < -32:
        return 3 * math.exp(x) - x ** 7 / 76
    if -32 <= x < -5:
        return math.ceil(x ** 3 - x ** 2 - 23 * x) - x ** 6
    if x >= -5:
        return 54 * math.log2(x) ** 6 + x ** 2 / 57 + 55 * x ** 4"
"import math

def main(y):
    if y < 9:
        return (y ** 3 + 47 * y) ** 4
    if 9 <= y < 83:
        return 15 * y ** 3 + 64 * y ** 5 + 1
    if y >= 83:
        return abs(y) ** 4 + 68 * y ** 5 + (y ** 3 - 6 * y - 1) ** 2"
"from math import ceil, cos

def main(z):
    if z < 99:
        return z ** 2 / 63 - z
    elif 99 <= z < 197:
        return (17 * z) ** 7 + 1 + 54 * z ** 6
    elif 197 <= z < 252:
        return z ** 7 - (79 * z - 1 - 96 * z ** 2) ** 3
    elif 252 <= z < 341:
        return 22 * (1 + 57 * z ** 3 + 27 * z ** 2) ** 6
    elif z >= 341:
        return ceil(z) - z ** 5 / 92 - 18 * cos(z) ** 7"
"from math import sin, atan

def main(z):
    if z < 150:
        return 7 - 74 * z - 28 * z ** 2
    elif 150 <= z < 231:
        return 25 * z ** 7
    elif 231 <= z < 270:
        return 47 * sin(z) ** 5
    elif 270 <= z < 280:
        return atan(z) ** 2 + z ** 5 / 51 + 30 * z ** 7
    elif z >= 280:
        return z ** 7 - 77"
"from math import *

def main(z):
    if z < -58:
        return z ** 7 / 64 + 16 * z ** 5 + (2 * z) ** 2
    if z < -26 and z >= -58:
        return z ** 6 - z ** 5
    if z < 75 and z >= -13:
        return z ** 2 - 48 * (1 + 24 * z * z * z) ** 5
    if z < -13 and z >= -26:
        return 49 * (46 * z) ** 5 + 99 * z * z
    if z >= 75:
        return floor(z * z) ** 5"
"import math

def main(x):
    if x < 148:
        return 35 * math.cos(x)
    elif 232 > x >= 148:
        return math.ceil(x ** 2) + math.log(x, 10) ** 5
    elif 232 <= x < 322:
        return x ** 2 - x
    else:
        return 42 * x ** 3 - x ** 6 - x ** 7"
"def main(z):
    if z < 33:
        a = z ** 2 - 17 * z ** 9 - z / 48
        return a
    elif 33 <= z < 110:
        b = (z / 95 + 1) ** 2
        return b
    elif 110 <= z < 188:
        c = 0.03 - 9 * (z ** 3 - z ** 2 - z) ** 6 - (z ** 2 - 25 * z) ** 5
        return c
    elif 188 <= z < 235:
        d = 42 * (z + 30 + z ** 2) ** 5 - (63 * z + 91 * z ** 3 + z ** 2) ** 3 - z ** 2
        return d
    else:
        e = 36 * (39 + 59 * z + 61 * z ** 3) ** 7 - z
        return e"
"from math import *

def main(y):
    if y < 75:
        f = 56 * y ** 6 + 21 * y ** 21 + y ** 3
        return f
    elif 75 <= y < 168:
        f = 10 * pow(y, 5)
        return f
    elif 168 <= y < 225:
        f = 90 * (pow(y, 2) - y - 24 * pow(y, 3))
        return f
    else:
        f = 1 + y ** 2
        return f"
"from __future__ import annotations
import math

def func_1(z) -> int | float:
    return 24 * z ** 3

def func_2(z) -> int | float:
    return 56 * z ** 6 - (89 * z + 27 * z ** 2) ** 2

def func_3(z) -> int | float:
    return 28 * (72 + z + z ** 2) ** 6 + z ** 21

def func_4(z) -> int | float:
    return (z ** 2 + 7 * z ** 3 + 1) ** 2 / 45 - 15 * (58 * z - z ** 2 - 1) ** 7

def func_5(z) -> int | float:
    return z ** 5

def main(z) -> int | float:
    if z < 8:
        return func_1(z)
    elif 8 <= z < 74:
        return func_2(z)
    elif 74 <= z < 110:
        return func_3(z)
    elif 110 <= z < 182:
        return func_4(z)
    return func_5(z)"
"from __future__ import annotations
import math

def func_1(y) -> int | float:
    return y ** 7 + y ** 2

def func_2(y) -> int | float:
    return (87 * y ** 2 + y ** 3) ** 4

def func_3(y) -> int | float:
    return y ** 6 / 15 + (y ** 3 / 91 + y + 1) ** 4

def main(y) -> int | float:
    if y < 175:
        return func_1(y)
    elif 175 <= y < 234:
        return func_2(y)
    return func_3(y)"
"from math import floor

def main(x):
    if x < 95:
        return (69 * x + 1) ** 6
    elif x < 168:
        return 76 * x ** 7 + x ** 5 + 76 * x ** 3
    elif x < 223:
        return 16 * x ** 6
    else:
        return 86 * floor(x ** 2) ** 6 - 1 - x ** 4"
"from math import floor, ceil

def main(x):
    if x < 45:
        return x + 63 * ceil(x) ** 2
    elif (x >= 45) & (x < 131):
        return floor(x) ** 7 + 78 * (62 - x / 47)
    elif x >= 131:
        return (x + 0.02) ** 5"
"import math

def main(y):
    if y < 32:
        return 11 * (26 * y ** 2 + y ** 3) ** 5
    elif 32 <= y < 43:
        return 71 * y ** 6
    elif 43 <= y < 122:
        return 68 * math.floor(y) ** 2 + 1 + 62 * (63 * y ** 2) ** 4
    elif 122 <= y < 179:
        return 75 * y ** 5 + 33
    else:
        return 26 * math.cos(y) ** 6 - y ** 3"
"def main(x):
    if x < 43:
        return 87 * (36 * x ** 2 - x ** 3 / 91) ** 6
    if 43 <= x < 98:
        return (1 - x ** 2) ** 6 + 0.02 + 37 * (x - 70) ** 5
    if 98 <= x < 194:
        return 1 - 83 * (24 * x - 84 * x ** 3 - x ** 2) - x ** 2
    if x >= 194:
        return (x ** 2 - 35 * x - x ** 3) ** 6"
"import math

def main(y):
    if y < 65:
        return 87 * y ** 7
    elif 65 <= y < 80:
        return 97 * y
    elif 80 <= y < 175:
        return 80 * y ** 7
    elif 175 <= y < 256:
        return 49 * (62 * y ** 2 - 1 - y) + 64 * math.ceil(y - 86 * y ** 2) ** 6 + y ** 10 / 38
    elif y >= 256:
        return y / 63 + y ** 3 + 52 * math.sin(y) ** 4"
"from math import pow

def main(y: float):
    if y < 61:
        p0 = (46 - y ** 3) ** 3 / 97
        p1 = 25 * (1 + 91 * y) ** 4
        return p0 - p1
    elif y >= 144:
        return 83 * y
    else:
        return pow(1 + pow(y, 3), 2)"
"import math

def main(z):
    if z < 81:
        return z ** 3 + 92 + 97 * z + z ** 2 / 4
    elif z >= 81 and z < 164:
        return 1 - z ** 6 - math.floor(43 - z ** 3) ** 5
    elif z >= 164 and z < 203:
        return math.ceil(z) ** 5 + 1
    elif z >= 203:
        return z ** 5"
"import math

def main(x):
    if x < 6:
        anw = (48 * x ** 2) ** 2
        return anw
    elif x >= 6 and x < 25:
        anw = 5952 * x
        return anw
    elif x >= 25 and x < 114:
        anw = 97 * (x ** 3 - 27 * x ** 2 - x / 9) ** 6
        return anw
    elif x >= 114:
        anw = x ** 7
        return anw"
"from math import asin, acos, atan

def main(y):
    if y < 86:
        return asin(52 * y ** 3) ** 5 + acos(y ** 2 + 14) ** 7 / 78 + 18 * y
    elif 86 <= y < 164:
        return (18 * y ** 2) ** 2 + atan(y) ** 6
    elif y >= 164:
        return y ** 6 / 64 + 44 * y ** 2"
"import math

def main(y):
    a = 20 * (99 * y ** 3 + 70 * y + 65 * y ** 2) ** 6
    b = math.ceil(y) ** 2 - 43 * y ** 4
    if y < 20:
        return 51 * y ** 5 + 47
    if 20 <= y < 96:
        return a - b
    if y >= 96:
        return (y ** 2 / 89 - y ** 3) ** 2 - 5 * math.sin(y)"
"import math

def main(z):
    if z < 10:
        return 51 * z ** 6
    if 10 <= z < 55:
        return (59 * z ** 2 + 72 + z) ** 2 - (z ** 3 - 1) ** 3
    if 55 <= z < 88:
        return 44 * math.log2(z) ** 7 - 84 * (z / 19 + 84 * z ** 3) ** 6 - 98 * z
    if 88 <= z < 146:
        return 15 * (1 - z ** 2) ** 4 - z ** 5 - 1
    if z >= 146:
        return 14 * z - 39 * (51 * z ** 3) ** 2 - 43 * math.ceil(z) ** 5"
"from math import atan, cos, log1p

def main(x):
    if x < 38:
        return 96 * atan(x) ** 2 - log1p(10 * x ** 2 - x) ** 7
    elif 38 <= x < 72:
        return cos(x) ** 7
    else:
        return 57 + x ** 3"
"import math

def main(x):
    if x < 26:
        return x ** 6 + 46 * (x + x ** 2 + x ** 3) + 1
    elif 26 <= x < 51:
        return 27 * (1 - 52 * x) ** 4 + 34 * math.sin(x)
    elif 51 <= x < 146:
        return 1 + x + 31 * (89 * x ** 3) ** 7
    elif x >= 146:
        return math.sin(84 * x ** 3) ** 7 + 98 * (x ** 3 + 21 + x ** 2) ** 4"
"import math

def main(x1):
    if x1 < 135:
        a1 = 37 + pow(math.atan(x1), 5) - 21 * pow(x1, 3) - 57 * pow(5 - x1, 6)
    if 135 <= x1 < 231:
        a1 = 18 * pow(math.log(x1, 2), 7)
    if 231 <= x1 < 280:
        a1 = pow(63 * x1 * x1 + 15 * pow(x1, 3) + 24 * x1, 3)
    if 280 <= x1 < 380:
        a1 = pow(pow(x1, 1 / 2), 3) + abs(pow(x1, 3) + pow(x1, 2))
    if x1 >= 380:
        a1 = 81 * pow(abs(51 * x1 * x1 + 63 + 89 * pow(x1, 3)), 5)
    return a1"
"def main(x):
    if x < 69:
        return 1 - 86 * x ** 2 - x ** 4
    elif 69 <= x < 116:
        return 51 * (x ** 2 + 12 * x + 51 * x ** 3)
    elif 116 <= x < 162:
        return 34 * (72 * x ** 3 + x ** 2) ** 6
    elif x >= 162:
        return x ** 3"
"from math import cos, floor

def main(z):
    if z < 14:
        return z ** 4 + z ** 6 / 5 + 15 * (z ** 3 / 10 - 2 - z ** 2) ** 7
    elif z < 91:
        return 65 * (67 * z ** 2) ** 4
    elif z < 164:
        return 12 * z + z ** 4 + 84 * (1 - 63 * z ** 2 - 50 * z ** 3) ** 7
    elif z < 209:
        return cos(z) ** 6 / 67 + (z - 0.02) ** 7 + floor(z / 34 - z ** 2) ** 3
    else:
        return floor(z) ** 5"
"from math import sqrt
from math import ceil

def main(y):
    if y < 53:
        result = (y / 6 - 1 - 70 * y ** 2) ** 5 - 56
    elif y >= 53 and y < 148:
        result = (54 * y ** 3) ** 7
    elif y >= 148 and y < 229:
        result = sqrt(y)
    else:
        result = 87 * y ** 2 + ceil(y) ** 6
    return result"
"from math import cos

def main(x):
    if x >= 163:
        return cos(x) ** 6 + x ** 7
    elif x >= 127:
        return 26 * (1 + 25 * x ** 2 + x) + (x ** 3 + 8 * x + 1) ** 6
    else:
        return 56 * (x ** 2 - 1) ** 5 - 47 * x ** 2"
"from math import *

def main(z):
    if z < 94:
        return 88 * pow(z, 4) - pow(z, 5)
    elif z >= 94 and z < 191:
        return pow(54 * pow(z, 2), 2) / 67
    elif z >= 191 and z < 261:
        return 41 * (60 + 68 * pow(z, 2)) + 0.01
    elif z >= 261 and z < 342:
        return 66 + 87 * pow(55 * z + 1 + pow(z, 2), 4) + 95 * z
    else:
        return pow(19 * pow(z, 2) + 0.01 + 61 * pow(z, 3), 6) - 82 * pow(z, 5) - pow(96 * pow(z, 2) + z, 3)"
"from math import *

def main(x):
    if x < 175:
        return 95 * floor(x) ** 7 - 1
    if 175 <= x < 226:
        return (x ** 2 + 52 * x + 1) ** 7 / 7 + 6 * log(x, 10) + 97 * x ** 10
    if 226 <= x < 237:
        return 67 * x ** 6 - exp(x) ** 3 - 76 * x ** 5
    if x >= 237:
        return (46 * x + x ** 2 + x ** 3) ** 7 / 30"
"import math

def main(x):
    if x < 19:
        return 33 * (1 + 8 * x ** 2 + x ** 3) ** 3
    elif 19 <= x < 107:
        return 26 * x ** 4
    elif 107 <= x < 148:
        return 29 * math.ceil(0.01 - 92 * x - x ** 2)
    elif x >= 148:
        return math.exp(1 - 84 * x ** 3 - x ** 2) ** 7 + 21 * (68 + x ** 2 + x) ** 2 + math.atan(x) ** 6"
"def main(y):
    if y < 12:
        first = 66 * y ** 7 - (99 * y ** 3 + y ** 2 / 46) ** 4 / 66 - 5 * y ** 3
        return first
    elif 12 <= y < 40:
        second = 23 * (60 - 60 * y ** 2) ** 4
        return second
    elif 40 <= y < 132:
        third = 1 - y ** 2 - y ** 3 / 54 + 34
        return third
    elif 132 <= y < 216:
        fourth = y ** 7 + y ** 5
        return fourth
    elif y >= 216:
        fifth = y ** 6
        return fifth"
"from math import pow, floor

def main(y):
    if y < 91:
        return 1 + y
    if 91 <= y < 113:
        return pow(y, 5)
    if 113 <= y < 196:
        return pow(y, 3) / 39 / 8 - pow(floor(34 * pow(y, 2)), 7)
    if y >= 196:
        return 87 * pow(y, 6) - pow(y, 6)"
"import math

def main(y):
    if y < 12:
        return 38 * math.atan(y) ** 4 + 96 * (y ** 2 - 60 * y)
    elif y >= 12 and y < 82:
        res = math.sqrt(y / 5 + 66 * y ** 2) ** 5 - (y / 64 - 69 - 24 * y ** 2) ** 4 - (y ** 2 - 7) ** 6
        return res
    elif y >= 82:
        return 44 + y ** 5"
"from math import tan, atan

def main(x):
    if x < 38:
        res = tan(x)
    elif 38 <= x < 116:
        res = 39 * x ** 2
    elif 116 <= x < 133:
        res = x ** 6 + atan(x ** 2 - 1 - x ** 3) ** 2 + 0.07
    else:
        res = 78 * x ** 4
    return float('%.2e' % res)
assert main(12) == -0.636
assert main(213) == 161000000000.0"
"import math

def main(y):
    if y < 36:
        return 11 * (87 * y ** 3 + 60) ** 7 + 78
    elif 36 <= y < 51:
        return 17 * (y ** 3 - 0.03 - 20 * y) ** 3 - y ** 12 - 14 * (y ** 3 - y ** 2) ** 5
    elif 51 <= y < 102:
        return 4 * math.log(y ** 3 + y ** 2) ** 3 - y ** 4 - 43 * (y ** 3 - 30 * y ** 2) ** 5
    else:
        return 93 + 79 * y - y ** 2 - 1"
"import math

def main(y):
    if y < 23:
        return (y ** 3 / 25 + 1) ** 3 + 2
    elif (y >= 23) & (y < 55):
        return (36 + 53 * y) ** 6 - 34 - 75 * math.sqrt(y) ** 7
    elif y >= 55:
        return 20 * y ** 5 - (27 * y ** 2 - 1 - y)"
"import math

def main(x):
    if x < 15:
        return 26 * x ** 6 - 23 * (x ** 2 - x ** 3 - 1) ** 5 - (x ** 2 - x) ** 2
    elif (x >= 15) & (x < 85):
        return x ** 5
    elif x >= 85:
        return 39 * math.fabs(x) ** 6 + 53"
"def main(y):
    if y < 55:
        result = y ** 7 + pow(91 * y ** 2 - y ** 3, 6) + 45
    elif 55 <= y < 101:
        result = y ** 5
    elif 101 <= y < 187:
        result = y + 18 * pow(7 * y ** 3, 5)
    elif 187 <= y < 285:
        step1 = 14 * pow(y, 4)
        step2 = 26 * pow(1 + y ** 2 + 61 * y, 5)
        step3 = pow(56 + 77 * y ** 3, 7)
        result = step1 + step2 + step3
    else:
        result = 12 * y ** 4 - 75 * y
    return result"
"import math
a = 273

def main(y):
    if 172 > y:
        result = y / 87
    elif (y >= 172) & (y < 249):
        result = 64 * y ** 4 + 12 * (6 * y + y ** 3 / 46 + 1) ** 2
    elif y >= 249:
        result = 21 * math.log2(y + 35 + 75 * y ** 2)
    return result
end_result = main(a)"
"from math import ceil, sin

def main(z):
    if z < 101:
        return z ** 6 + (45 * z ** 3) ** 2 / 87 + z ** 4
    elif z < 188:
        return sin(z) ** 7 - ceil(z ** 2) ** 4 / 35
    elif z < 226:
        return 33 * z ** 2 - 89 * (85 + z + z ** 2) ** 5
    else:
        return 35 * (54 * z ** 3 + z) ** 6"
"from math import atan

def main(z):
    if z < 69:
        return 6 * z ** 7 + 0.01 + 57 * (71 * z ** 3 - 45 * z - 1) ** 6
    elif z < 126:
        return 82 * z ** 5
    else:
        return atan(z + 76) ** 6"
"import math

def main(x):
    if x < 104:
        return 1 + 69 * math.floor(1 - x ** 2 - 2 * x ** 3) ** 2 + math.log2(x) ** 2
    elif 104 <= x < 159:
        return x ** 7 / 61 + x + (x ** 2 - 52 - 20 * x ** 3) ** 3
    elif 159 <= x < 229:
        return 19 * (x ** 2 / 64 + x + 1) ** 4 - abs(x) ** 5
    elif x >= 229:
        return 36 * (37 * x ** 2 - 30 * x ** 3) ** 2 - 97"
"from math import *

def main(z):
    if z < 158:
        return 45 * (z / 10 + 1 + 40 * z ** 2) ** 4
    elif 158 <= z and z < 212:
        return 1 + z
    elif z >= 212:
        return 29 * z - 9 * z ** 7 - tan(51 * z ** 3 + z ** 2 / 49)"
"import math

def main(x):
    if x < 15:
        return 1 + x ** 3 + 26 * (x + 71 * x ** 2 + 1) ** 6
    elif x >= 15 and x < 44:
        return x ** 7 + x + 0.07
    elif x >= 44 and x < 129:
        return math.ceil(x) ** 3
    else:
        return x ** 6 - x - 33 * math.atan(x) ** 2"
"import math

def main(x):
    if x < 75:
        value = math.cos(61 + 81 * x ** 2 + 78 * x) ** 5 - 23 * (x + x ** 2) ** 2 - 99 * x ** 2
        return float('%.2e' % value)
    if 75 <= x < 107:
        value = 33 * x ** 14
        return float('%.2e' % value)
    if 107 <= x < 206:
        value = 38 * math.ceil(x) ** 6
        return float('%.2e' % value)
    if x >= 206:
        value = 40 * math.fabs(x) + 77 + 22 * math.fabs(39 + x / 29 + x ** 2) ** 6
        return float('%.2e' % value)"
"from math import sin

def main(y):
    if y < 65:
        return 94 * y ** 4 + 58 * (87 - y ** 3) ** 5 + y ** 2
    elif y < 133:
        return 79 * y ** 5 + sin(y ** 3 + y ** 2) ** 2 + 12 * y
    elif y < 145:
        return 43 * (y + 73 * y ** 3 + y ** 2) ** 4 - sin(y ** 2)
    elif y < 211:
        return y ** 4
    else:
        return (15 * y - y ** 2) ** 7 - 82 * y"
"import math

def main(y):
    if y < 24:
        return y ** 7 + y ** 4
    elif 24 <= y < 118:
        return 30 * (52 * y ** 3) ** 7 + 83 * (1 + 38 * y) ** 6
    elif 118 <= y < 171:
        return y ** 7 / 28 - 12 * math.log(y) - y ** 3
    elif 171 <= y < 184:
        return 84 * y ** 3 + math.log2(10 * y ** 3 - y - 64 * y ** 2) ** 5 / 6
    else:
        return 1 + (55 - 29 * y ** 3 - y) ** 4 + 59 * (y ** 2 + 18 * y ** 3) ** 2"
"from math import floor, exp

def main(z):
    if z < -2:
        return 3 * (91 * z ** 3 + 20 * z ** 2 + 5) ** 7 + 41 * z
    elif z < 79:
        return z ** 6 + z + 40 * z ** 7
    elif z < 178:
        return 50 * z ** 4
    elif z < 197:
        return floor(z) ** 2
    else:
        return exp(z) ** 2"
"import math

def main(z):
    if z < 21:
        return 82 * math.fabs(1 + z ** 2) ** 2
    elif z < 65:
        return z ** 7 + 1 + (z ** 2 + z ** 3 + 30 * z) ** 6
    elif z < 160:
        return z ** 6 + z ** 3
    elif z < 205:
        return z ** 3
    else:
        return 45 * math.ceil(z) ** 4 + 17"
"import math

def main(y):
    result = 0
    a = 80 * pow(y, 3) - pow(y, 2) - 44 * y
    if y < -34:
        result = pow(y, 3) + pow(y, 8)
    elif -34 <= y < 15:
        result = 55 * pow(y, 2) - math.tan(y) - 82 * pow(math.atan(a), 7)
    elif 15 <= y < 28:
        result = 54 * pow(y, 2) / 93
    elif y >= 28:
        result = pow(y, 6) + 51 + 49 * pow(y, 4)
    return result"
"import math

def main(y):
    result = 0
    a = 83 * pow(y, 3) + 73 * y + pow(y, 2) / 81
    b = pow(y, 1 / 2)
    c = pow(y, 2) / 63
    if y < 114:
        result = 49 * pow(a, 3)
    elif 114 <= y < 193:
        result = pow(b, 7) - 18 * pow(y, 4) - pow(math.cos(y), 2)
    elif 193 <= y < 247:
        result = pow(y, 5) + pow(60 * y - 1, 4) + 90 * pow(y, 6)
    elif y >= 247:
        result = pow(c, 3)
    return result"
"import math

def main(y):
    if y < -70:
        value = (39 * y ** 3 - 31 * y ** 2 - 35 * y) ** 2 - math.ceil(92 * y + 1) ** 3
        return float('%.2e' % value)
    if -70 <= y < 23:
        value = 12 * math.exp(y) ** 5 + math.sin(y ** 3 + 31 * y) ** 3 + 95
        return float('%.2e' % value)
    if 23 <= y < 67:
        value = 82 - math.exp(y) ** 7 - 63 * y ** 2
        return float('%.2e' % value)
    if 67 <= y < 152:
        value = (33 * y ** 3) ** 6
        return float('%.2e' % value)
    if y >= 152:
        value = y ** 5
        return float('%.2e' % value)"
"from math import *

def main(y):
    if y < 67:
        return ceil(y ** 2 - 1 - 88 * y) ** 7 / 70 - abs(y) ** 3
    elif 67 <= y and y < 83:
        return y ** 3 - 78 - y ** 4 / 4
    elif y >= 83:
        return 34 * y ** 4 + 64 * y ** 6"
"def main(z):
    if z < 181:
        return z ** 5 - z
    if 181 <= z < 217:
        return z ** 4 / 9
    if 217 <= z < 310:
        return 44 * z
    else:
        return abs(z ** 3 + 42 * z ** 2) ** 3 - 40 - z ** 6"
"import math

def main(y):
    if y < 70:
        f = 18 * pow(y, 12) - pow(math.tan(y - 0.01), 3)
    elif y >= 70 and y < 136:
        f = pow(y, 3)
    elif y >= 136 and y < 185:
        f = pow(7 * y, 7) - 81 - pow(y, 6)
    elif y >= 185:
        f = 14 * y + 45 * pow(y, 4) + 77
    return f"
"import math

def main(z):
    if z < 72:
        return z ** 6 - z ** 2 - math.log10(z) ** 3
    elif 72 <= z < 130:
        return 1 + z ** 6
    elif z >= 130:
        return math.atan(z) ** 4 + 1 + (1 + z ** 3 / 23) ** 2"
"import math

def main(y):
    if y < -22:
        return 45 * math.ceil(y + 84 + 14 * y ** 3)
    elif -22 <= y < 45:
        return 28 + y ** 2 + math.ceil(52 * y ** 3)
    elif 45 <= y < 119:
        return y ** 2 + (69 * y) ** 3 + 56
    elif 119 <= y < 186:
        return abs(y) ** 6 / 61 + 69 * math.cos(y) ** 3 + 68 ** 2
    elif y >= 186:
        return (y ** 3 - 1) ** 7 / 44 - abs(y) ** 3 - math.sqrt(77 + y ** 3 + 10 * y ** 2) ** 4 / 29"
"def main(y):
    if y < -37:
        result = y ** 8 / 85 + 86 * y ** 7
        return result
    if y >= -37 and y < 13:
        result = 29 * y ** 6 - y ** 9 / 39
        return result
    if y >= 13 and y < 26:
        result = (y ** 3 + 66 * y + 1) ** 5 / 78 + y ** 6
        return result
    result = 89 * y ** 2 - (28 * y ** 2) ** 5 / 87 - 62
    return result"
"import math
from math import *

def main(y):
    if y < 151:
        v = 3 * (y / 43 - y ** 2 - 5) ** 7 - y / 69
        return v
    elif y >= 151 and y < 191:
        v = (7 + 9 * y + y ** 3) / 49
        return v
    elif y >= 191 and y < 245:
        v = 92 * y ** 4
        return v
    else:
        v1 = 93 * y ** 6 + 66 * sqrt(y) ** 7
        v2 = math.floor(y + y ** 2) ** 3 / 26
        return v1 + v2"
"from math import *

def main(z):
    if z < 19:
        f = 99 * z ** 2
        return f
    elif 19 <= z < 93:
        f = log(z) ** 3
        return f
    elif z >= 93:
        f = 48 * z
        return f"
"from math import *
import math

def main(y):
    if y < 81:
        f = 12 - 88 * y ** 2
        return float('%.2e' % f)
    if 81 <= y < 120:
        f = 16 * y ** 4 - 1
        return float('%.2e' % f)
    if 120 <= y < 185:
        f = (y - 34) ** 5 - 1
        return float('%.2e' % f)
    if 185 <= y < 214:
        f = math.log2(65 * y) ** 3
        return float('%.2e' % f)
    if y >= 214:
        f = 83 * sin(y) ** 6
        return float('%.2e' % f)"
"import math

def main(x):
    if x < 83:
        return 26 * math.fabs(91 * x ** 2) ** 5 - 2 - 31 * math.floor(x)
    if 83 <= x < 162:
        return 79 * math.exp(x ** 2 / 31 - x ** 3 - 1) ** 5
    if 162 <= x < 246:
        return (38 * x ** 2 + x / 22 + 1) ** 7 - (x ** 3 - x ** 2 - 1) ** 5
    if 246 <= x < 326:
        return math.atan(x) ** 2 - x ** 4 - 11
    if x >= 326:
        return 33 * math.tan(45 + x ** 3) ** 6 - 25 * x ** 7"
"import math

def main(z):
    if z < 57:
        x = (z ** 2 / 60 - 48 * z) ** 6
    elif 57 <= z < 94:
        x = 75 * z ** 7
    elif 94 <= z < 129:
        x = 77 + (95 * z ** 3 - 12 * z ** 2) ** 3
    elif 129 <= z < 143:
        x = 13 * (86 * z - z ** 3) ** 4
    else:
        x = z ** 6 + 31 * math.atan(z) ** 5
    return x"
"from math import log2, cos, fabs

def main(y):
    if y < 170:
        return y ** 4
    elif y < 219:
        return 60 * log2(y + y ** 2 + 84) ** 3 - 57 * cos(y) ** 4 - 7 * y ** 6
    else:
        return (y ** 3 - 4 * y - y ** 2) ** 4 - y ** 15 - 26 * fabs(y ** 3 - y / 61 - 25 * y ** 2) ** 7"
"import math

def main(y):
    if y < -12:
        return 45 * math.fabs(y) ** 7 - 90.0
    if (y >= -12) & (y < 61):
        return y ** 5.0
    if (y >= 61) & (y < 72):
        return 1 + y ** 6.0
    if y >= 72:
        return 1 + 94 * y + 68 * y ** 2.0"
"import math

def main(z):
    if z < 99:
        return 6 * z - 50 - 34 * (94 * z ** 3 - 65) ** 6 - math.log2(z) ** 4 / 59
    if 99 <= z < 147:
        return 63 * (z + z ** 3 + 17) ** 4 + 27 + 15 * math.ceil(z ** 3) ** 7
    if 147 <= z < 219:
        return (91 * z ** 2 + z) ** 2
    if 219 <= z < 237:
        return 23 * (z ** 3 / 47) ** 3
    return z ** 2 / 82 + 89 * math.ceil(z) ** 5"
"import math

def main(y):
    if y < -23:
        res = math.tan(y) ** 2 / 13 - y ** 5 - (6 * y ** 3) ** 7 / 21
    elif 5 > y >= -23:
        res = (29 * y ** 3) ** 7 / 54 - 69 - 45 * (1 + 56 * y)
    elif 39 > y >= 5:
        res = 24 * abs(y) ** 6 - 45 * (y ** 3 + y / 66) ** 7 - y ** 2
    elif y >= 39:
        res = y ** 2 + (12 + y ** 3 + y ** 2) ** 6 + 98 * y - y ** 2 - 3 * y ** 3
    return float('%.2e' % res)"
"import math

def main(y):
    if y < 32:
        return math.ceil(y) ** 3 - 56 * (y ** 2 / 62 - y) ** 5
    elif 32 <= y < 122:
        return (19 * y ** 3) ** 4
    elif 122 <= y < 199:
        return 19 * (21 * y ** 3 + y) ** 4 + 65 * math.sin(y ** 3) ** 7
    else:
        return 1 + (8 * y ** 2) ** 3"
"import math

def main(x):
    if x < 16:
        return 68 - 92 * math.sin(63 * x ** 3 - 60 - 45 * x ** 2) ** 3
    elif 16 <= x < 105:
        return x ** 3 + 49 * math.atan(72 * x - 1 - 78 * x ** 2) ** 7 + math.log(x ** 3 - x ** 2) ** 2
    elif 105 <= x < 195:
        return 45 * x ** 4
    elif 195 <= x < 233:
        return 17 * (x ** 3 / 84 - x ** 2) ** 5
    else:
        return (41 * x ** 3) ** 4 / 38 - 34 * (57 * x ** 3 + 1) ** 7"
"import math

def main(z):
    if z < 90:
        value = 71 * z ** 7
        return float(value)
    if 90 <= z < 171:
        value = 80 * (1 + 83 * z + z ** 3) + math.fabs(z) ** 7 + 47
        return float(value)
    if 171 <= z < 214:
        value = 49 * z ** 7
        return float(value)
    if z >= 214:
        value = (69 * z ** 3 + z / 52 + 90) ** 4
        return float(value)"
"from math import *

def main(z):
    if z < -5:
        f = (z ** 3 + z + 15 * z ** 2) ** 4 / 11
        return f
    elif -5 <= z < 34:
        f = 68 * z ** 4
        return f
    elif z >= 34:
        f = (1 + z ** 3 + 74 * z ** 2) ** 6 / 95
        f1 = 19 * log(1 + z ** 2 + 37 * z ** 3)
        return f - f1"
"import math

def main(y):
    if y < 28:
        return 46 + 16 * math.tan(y) + y ** 4
    if 28 <= y < 127:
        return (88 * y ** 2 + y ** 3 / 79) ** 6 + 99 * y ** 2
    if 127 <= y < 168:
        return y ** 3 + math.sin(y ** 2 / 25) + y ** 2
    if 168 <= y < 253:
        return math.tan(y) + 62 * y ** 6
    return 91 * y ** 2 + 55 * (55 * y - 94) ** 3 + y ** 15"
"import math

def main(x):
    if x < 126:
        return 54 * pow(x, 10)
    elif (x >= 126) & (x < 218):
        return pow(math.atan(pow(x, 2) + 1 + x / 4), 3) - 68 * pow(x, 5)
    else:
        return pow(63, 3) * pow(x, 9) / 30"
"import math

def main(y):
    if y < 22:
        return y ** 2
    elif 22 <= y < 64:
        return 1 + (16 + y ** 2) ** 6 + (86 * y ** 3 + 32) ** 2
    elif 64 <= y < 122:
        return 58 * abs(y ** 3 / 6) ** 2 + 1
    else:
        return 97 * (y ** 3 - y ** 2) ** 7 + math.sin(14 * y ** 2 - y ** 3 - y / 71) ** 2"
"import math

def main(y):
    if y < 24:
        return pow(math.tan(y - y * y - 0.5), 5) - y * y
    elif 24 <= y and y < 74:
        return pow(y, 2.5)
    else:
        return 38 * pow(y, 5)"
"import math

def main(x):
    if x < 68:
        return 0.01 - abs(x)
    elif 68 <= x < 147:
        return 29 * x ** 3 + x ** 2
    elif 147 <= x < 223:
        return math.log2(x) ** 2
    elif 223 <= x < 314:
        return math.log10(x) - 60 * math.tan(x) ** 4
    else:
        return x ** 5 - x ** 6 / 2"
"import math

def main(x):
    if x < 112:
        f = 7 * (x ** 2 + x ** 3) ** 2
    if x >= 112 and x < 147:
        f = math.cos(x ** 3 / 25 - 51 * x - x * 2) ** 5 + 88 * (10 + 75 * x ** 2) ** 6
    if x >= 147 and x < 158:
        f = x ** 3
    if x >= 158 and x < 237:
        f = x ** 4 - math.log(60 * x ** 3 + 1) ** 5
    if x >= 237:
        f = 31 * abs(x) ** 4
    return float('%.2e' % f)"
"from math import log10

def main(y):
    res = 0
    if y < 191:
        res = 35 * y ** 3 - y - 95 - (y - 72 * y ** 2 - y ** 3) ** 7
        return res
    elif 191 <= y < 282:
        res = 2 * (y ** 2 - y - 23) ** 5 + y
        return res
    elif 282 <= y < 347:
        res = y ** 4 + 92 * y ** 2
        return res
    elif 347 <= y < 426:
        res = 1 + 56 * log10(y) ** 5
        return res
    elif y >= 426:
        res = 79 * y ** 2 + 86 * (4 * y ** 3 - 1 - y ** 2)
        return res"
"import math

def main(y):
    if y >= 32:
        return (1 - 85 * y - y ** 2) ** 2 / 23 - (87 * y ** 3 + 66 * y) ** 6
    elif y < -46:
        return (1 - 36 * y) ** 6 + math.sin(y) ** 3 + y ** 5 / 50
    else:
        return 30 * y ** 4 + 85 * math.ceil(y) ** 2 + math.sin(y) ** 7"
"import math

def main(z):
    if z < 62:
        return (z ** 2 + 40) ** 6
    elif 62 <= z < 108:
        return 8 * (1 + 84 * z ** 2 + z ** 3)
    elif 108 <= z <= 139:
        a = (z ** 3 - 27 * z - 63 * z ** 2) ** 2
        b = math.log1p(3 * z ** 2 + 53 * z) ** 4
        c = 8526 * z ** 2
        return a - b - c
    elif z >= 139:
        a = (1 + z / 71 + z ** 2) ** 7
        b = 66 * (45 * z - 62 - z ** 2) ** 3
        return a + b"
"import math

def main(x):
    if x < 13:
        return 57 * (x + x ** 3 + 15) ** 2 - 1
    elif 13 <= x < 110:
        a = (60 * x ** 2 + 3 * x ** 3 + 0.03) ** 7 / 4
        b = 77 * math.ceil(x ** 2 / 87 + 39 * x) ** 2
        c = 27 * x ** 8
        return a + b + c
    elif x >= 110:
        return 66 * x - 40 * (90 * x ** 3 + 68 * x) ** 2"
"import math

def main(y):
    if y < 134:
        return math.floor(y) ** 2
    if 134 <= y < 209:
        return 44 * math.floor(y ** 2 / 93) ** 7
    if 209 <= y < 219:
        return 93 + y ** 4
    a = 63 * (19 * y ** 2 - 30 * y ** 3) ** 5
    b = 21 * y ** 7
    c = 57 * math.log(10) ** 2 * (y ** 3 + y / 31)
    return a + b + c"
"def main(z):
    if z < 51:
        return 1 + z ** 5
    elif 51 <= z and z < 95:
        return 9 * (z ** 2 - 69 * z ** 3 - 1) ** 5
    elif z >= 95:
        return 73 * z"
"def main(z):
    if z < 91:
        return 73 * (40 - z ** 2) ** 5
    if z < 124:
        return abs(z - 58 * z ** 2 - 1) ** 6 - z ** 4 - 34
    return 1 - (42 * z + z ** 3) ** 4 - 31 * (16 * z ** 2 + z + 47 * z ** 3) ** 6"
"import math

def main(y):
    if y < 94:
        return y ** 2 + 4 * (18 * y ** 3 - y ** 2 / 21 - 98) ** 4
    elif 94 <= y < 144:
        return 8 * math.tan(y) ** 5 + y ** 2 / 23
    elif 144 <= y < 230:
        return 44 * y ** 12
    else:
        return 27 + y + 1"
"import math

def main(z):
    if z < -50:
        return 35 + z ** 3
    if -50 <= z < 22:
        return z ** 4 + z ** 2
    if 22 <= z < 83:
        return 84 + z ** 7 + z ** 4 / 89
    if z >= 83:
        return 3 * math.log2(z) ** 7 - 80 * math.cos(1 - z) ** 4"
"import math

def main(y):
    if y < 130:
        f = (y - y ** 3 - y ** 2) ** 7 / 17
    elif 130 <= y < 218:
        f = math.log(y) ** 4 - 74 * y ** 7 - 1
    elif 218 <= y < 280:
        f = math.sin(74 * y ** 2 + 30 * y) ** 2 - y ** 3 - (y ** 2 + 18) ** 4
    else:
        f = 0.03 + 67 * y ** 2
    return f"
"import math

def main(y):
    if y < 23:
        return 7 * (1 + 12 * y ** 2 + 5 * y) ** 6 - 98 * math.ceil(82 * y + 46) ** 3 - math.ceil(y) ** 2
    elif 23 <= y < 88:
        return math.sqrt(y) ** 6 - math.cos(y) ** 4
    else:
        return (79 * y ** 3 + 33 * y + 73 * y ** 2) ** 3 / 64 - math.sqrt(y) ** 4"
"import math

def main(x):
    if x < -20:
        return x ** 4 - x ** 7 - 32
    if -20 <= x < 23:
        return 23 * math.log1p(x ** 3 + x) ** 3 + (x - 66 * x ** 3 - x ** 2) ** 5 / 16 + 71 * (x ** 2 + 90 * x ** 3) ** 4
    if 23 <= x <= 72:
        return x ** 6 / 77
    if 72 <= x <= 168:
        return 23 * math.fabs(x ** 2) ** 4 + 29 * x ** 3
    if x >= 168:
        return 67 * x ** 6 - 20 * x ** 3 - 65 * math.fabs(x) ** 4"
"def main(x):
    if x < 77:
        return 91 * (x ** 2 / 59 + 1 + 10 * x) ** 4
    elif 77 <= x and x < 121:
        return 1 + (22 * x ** 2 - 1 - 48 * x) ** 7
    elif x >= 121:
        return 68 * (x - 52 * x ** 3 - 19 * x ** 2) ** 6 - x ** 2
    else:
        return 1"
"import math

def main(z):
    if z < 103:
        return math.log2(z) + 25 * math.sin(z) ** 5
    elif 103 <= z < 128:
        return 2 * z ** 5
    elif 128 <= z < 215:
        return z ** 6 / 89
    else:
        return 1 - z ** 2 - math.ceil(85 * z ** 2) ** 3"
"from math import log

def main(z):
    if z < 46:
        return (z + 1 + 73 * z ** 3) ** 2
    elif 46 <= z < 91:
        return 24 * log(z, 10) - 40 * z ** 7
    elif 91 <= z < 163:
        return (69 * z ** 3) ** 2 + (23 * z + z ** 2) ** 6
    elif z >= 163:
        return 1 + 71 * (1 - z ** 3) ** 4"
"import math

def main(x):
    if x < 54:
        return 92 * x ** 4 + x ** 5 / 30
    elif 54 <= x < 148:
        return 24 * x ** 2 - 88 * x ** 6 - x ** 5
    elif 148 <= x < 163:
        return 89 * (x ** 3 + 1) ** 5
    elif x > 163:
        return 22 * x ** 3"
"import math

def main(z):
    if z < 8:
        return 39 * math.cos(z ** 2 - 49 * z ** 3) - math.atan(z) ** 2 - (56 * z ** 3 - 1 - z) ** 7
    elif 8 <= z < 65:
        return 68 * z ** 4 + z ** 5
    elif 65 <= z < 122:
        return 74 * z - (z ** 2 + z ** 3) - 64 * (z ** 3 + z ** 2) ** 4
    elif 122 <= z < 192:
        return 98 * z ** 6 + 56 * math.log(z ** 2 / 58 - z, 10) ** 3
    elif z >= 192:
        return 50 * (51 * z ** 2) ** 3 + (z ** 2 - 17 * z - 75 * z ** 3) ** 6 + 32"
"import math

def main(x):
    a = 94 * (x ** 3 - 1 - x ** 2) ** 3
    if x < 99:
        return 7 * x ** 12
    elif 99 <= x < 141:
        return x ** 3 + (1 - x ** 3 - x ** 2) ** 7
    elif 141 <= x < 189:
        return 40 * x ** 7 - math.log2(x) ** 5
    elif 189 <= x < 258:
        return 78 * math.cos(x ** 3 - 75 - 23 * x) - a
    elif x >= 258:
        return 79 * (15 * x ** 2) ** 4 - (94 * x ** 3 + 98 * x) ** 6
    return 0"
"import math

def main(z):
    if z < 132:
        return (z ** 2 / 62 - 62 * z ** 3 - 1) ** 7 + math.sin(z - 41) ** 5 / 63 + z
    elif 132 <= z < 164:
        return z ** 7
    elif 164 <= z < 181:
        return 66 * z ** 5 + z ** 3 / 39 - z - z ** 2 + 50 * (z ** 3 - 11 * z) ** 2
    elif z >= 181:
        return z ** 4"
"from math import sin, tan

def main(y):
    if y < 75:
        return y ** 7 / 65 - 24 * (71 - y ** 3 - y ** 2) ** 3 - y ** 6 / 50
    elif y < 97:
        return 70 * y
    elif y < 188:
        return y ** 7 + (y ** 3 / 27 + y ** 2 / 93) ** 2 / 11 + tan(y)
    else:
        return sin(y ** 3)"
"import math

def main(x):
    if x < 112:
        return 52 * x * x
    if 112 <= x < 153:
        return pow(x * x - 24 * x * x * x, 5) / 71 - pow(x, 7)
    if 153 <= x < 182:
        return 94 * pow(math.ceil(x), 5)
    if 182 <= x < 276:
        return 1 - 7 * pow(math.log10(x), 3) - (x * x * x / 11 + x * x)
    if x >= 276:
        return 12 * pow(x / 92 - 87 * x ** 3, 6) - pow(16 + x, 5)"
"import math

def main(z):
    if z < 154:
        return z ** 3
    elif z < 202 and z >= 154:
        return abs(97 - 99 * z ** 2 - z ** 3) - 84 * (32 * z - 39 * z ** 2 - 90 * z ** 3) ** 6
    elif z < 297 and z >= 202:
        return z ** 5 - z ** 6
    elif z < 328 and z >= 297:
        return (z ** 3 + 0.03 + 73 * z ** 2) ** 5 - 71 * math.cos(z) ** 7
    elif z >= 328:
        return (z ** 3 + 32) ** 2 + (92 * z - 1) ** 4"
"import math

def main(z):
    if z < 33:
        res1 = 6 * z ** 5 - 70 * z ** 4
        res2 = 16 * (78 * z - 77 * z ** 3 - 29) ** 2
        return res1 - res2
    elif 33 <= z < 108:
        return z ** 3 - 14 * z ** 2
    elif 108 <= z < 160:
        res1 = 20 * (90 * z - z ** 2 - 0.01)
        res2 = (z ** 2 / 84 - 10 * z - 0.03) ** 3
        return res1 + 1 + res2
    else:
        res1 = 43 * (z ** 3 - 85 * z - 48) ** 5
        res2 = 57 * math.cos(z) ** 6
        return res1 + z ** 7 + res2"
"import math

def main(y):
    if y < -55:
        return 64 * y ** 6 - y ** 4 / 13 - y ** 5
    if -55 <= y < 27:
        return 82 * (y - 89 * y ** 2) ** 6 + math.fabs(y) ** 7 + math.ceil(93 - y ** 3) ** 4
    if 27 <= y < 123:
        return (54 * y) ** 6 - 5 * y
    if y >= 123:
        return math.fabs(y) ** 3"
"import math

def main(x):
    if x < 65:
        return 36 * math.sin(92 ** x - x ** 3 / 65) ** 3 - 74 * x ** 2
    if 65 <= x < 140:
        return (94 * x ** 2) ** 4
    if 140 <= x < 210:
        return x ** 3 - 85 * (76 * x - 60 * x ** 2 - 1) ** 2 - 65 * x ** 4
    return (59 * x - 78 * x ** 3) ** 4"
"import math

def main(y):
    if y < 32:
        return (2 * y ** 3) ** 7 / 97 + 99 * (y ** 3 - 34 * y ** 2) ** 4 + 1
    elif y < 69:
        return 50 * math.tan(0.01 - y ** 3) ** 7 + 21 * y ** 5
    elif y < 95:
        return 0.02 + (y / 79 - 41 * y ** 3 - 89 * y ** 2) ** 4 + y ** 2
    else:
        return y ** 7 - y ** 6"
"import math

def main(x):
    if x < 9:
        res = 85 * (x + 51 * x ** 3 + 38 * x ** 2) ** 2
    elif 9 <= x < 28:
        res = math.cos(98 * x ** 2) ** 2 + math.log10(x) + 1
    elif 28 <= x < 116:
        res = x + 7 * x ** 4
    elif 116 <= x < 137:
        res = 72 * x ** 7 - (8 + x ** 2 + x ** 3) ** 6 / 43 - (1 + 64 * x ** 2 + 95 * x ** 3) ** 3 / 39
    else:
        res = x ** 4
    return res"
"import math

def main(x):
    if x < 57:
        result = 2 * x ** 6 - 46 * (36 * x ** 3 - x - 1) ** 3
        return result
    if x >= 57 and x < 128:
        result = 1 - (x ** 2 + 97 * x) - x ** 7 / 44
        return result
    if x >= 128 and x < 204:
        result1 = (36 + 22 * x ** 3 + 8 * x ** 2) ** 2
        result2 = math.sin(12 * x ** 3 + 65 * x + x ** 2) ** 6 + x ** 5
        result = result1 + result2
        return result
    if x >= 204 and x < 277:
        result = (45 * x ** 2 + 1 + 40 * x) ** 2 + 15 * x ** 4
        return result
    if x >= 277:
        result = 64 * (62 * x ** 2) ** 3 - 7 * (x / 53 - x ** 3 - 51 * x ** 2) ** 6
        return result"
"import math

def main(z):
    if z < -57:
        return z ** 3 / 44 + 82 * (57 * z ** 3 - 1 - z ** 2) ** 5 + 27
    elif -57 <= z < 14:
        return 34 * z ** 3 + 78 * z ** 2 + 50 - z ** 7
    else:
        return (54 * z ** 2 - z - 0.02) ** 5 + z ** 7 + z ** 3"
"import math

def main(z):
    if z < 98:
        return math.pow(math.cos(z), 4)
        +math.pow(15 * z * z - z / 52, 6) + 87
    elif z < 108:
        return math.pow(math.asin(z), 2)
        +math.pow(51 * z * z, 7)
    elif z < 204:
        return z * z * z
    else:
        return 23 * z * z - math.pow(z * z * z + 22, 7)
        -75 * z * z * z * z * z"
"from math import atan

def main(x):
    if x < 106:
        return (9 * x ** 2) ** 5 + x + 75 * (93 * x ** 3 - x - 96 * x ** 2) ** 7
    elif x < 156:
        return x ** 6
    else:
        return x ** 7 / 93 + 61 * (x ** 2 / 94) ** 4 + atan(x - 32 * x ** 2 - x ** 3) ** 5"
"import math

def main(y):
    if y < 56:
        return 65 + math.log(6 * y ** 2, math.e)
    elif 56 <= y < 146:
        return (y / 54) ** 3 - 10 * y ** 4 - math.fabs(y) ** 2 / 50
    elif 146 <= y < 219:
        return (y - 22 * y ** 2) ** 5
    elif 219 <= y < 299:
        return math.floor(y ** 3) ** 4
    elif y >= 299:
        return 96 * math.floor(1 - 68 * y ** 2 - y ** 3) ** 4"
"import math

def main(x):
    if x < 147:
        a = (88 * x ** 3 + 18 + x ** 2) ** 6
        b = (x ** 2 + 14 + 63 * x) ** 3
        return a - b
    elif 147 <= x < 240:
        return 52 * x ** 2 - math.atan(x ** 2 / 42) ** 7
    elif 240 <= x < 280:
        return 64 * x ** 5
    elif x >= 280:
        a = (68 * x) ** 2
        b = 42 * (17 * (x ** 3 / 26)) ** 4
        c = 78 * (55 * x ** 2) ** 7
        return a - b - c"
"import math

def main(y):
    if y < 95:
        return y ** 3 + (1 + y ** 3 / 57) ** 3 + math.sqrt(y) ** 6
    elif 95 <= y < 169:
        return math.sqrt(y) ** 4 + y ** 7 + 95 * (1 + y ** 2) ** 2
    elif 169 <= y < 245:
        return 74 * (y ** 3 / 80 + y / 80 + 1) ** 7 - 18 * math.atan(y / 4) ** 2 - 27 * (1 - 22 * y ** 3) ** 6
    else:
        return 1 + 49 * math.cos(87 * y ** 2 - 29 * y - 70 * y ** 3) ** 3"
"from math import ceil, log10

def main(z):
    if z < 92:
        return (1 - z) ** 4 + log10(z) ** 3
    elif z < 162:
        return 63 * ceil(z / 34) ** 5 - 43 * z ** 3 - 56 * (z - 0.01 - z ** 2) ** 6
    else:
        return (4 * z) ** 7 / 66 + 80 + 19 * z ** 6"
"import math

def main(y):
    if y < 93:
        return 24 * pow(12 * pow(y, 3), 6)
    if 93 <= y < 155:
        return 1 + 58 * (1 + y ** 2 + y / 85)
    if 155 <= y < 247:
        return y ** 3 - y ** 6 - 96 * (82 * y ** 3 - 1 - 85 * y ** 2)
    result1 = 78 * math.log10(y) ** 4
    result2 = math.log10(57 * y ** 3 + y) ** 7 / 86 + y ** 3
    return result1 - result2"
"import math

def main(y):
    if y < -47:
        f = math.sin(y) ** 2
    elif -47 <= y and y < 10:
        f = 43 * y - (11 * y ** 2) ** 7
    elif 10 <= y and y < 105:
        f = y ** 4 - 19
    elif 105 <= y and y < 179:
        f = y ** 18
    elif 179 <= y:
        f = y ** 6 - 33
    return f"
"from math import atan, sqrt, ceil

def main(y):
    if y < 27:
        return 1 + 86 * y ** 4 + y ** 2
    elif y < 125:
        return (y ** 3 - y) ** 5 - (ceil(y) / 47) ** 4 - (86 * y ** 2 + y) ** 3
    elif y < 187:
        return 32 * sqrt(y) ** 3 + 61
    else:
        return 3 * atan(y) ** 4"
"from math import sqrt

def main(y):
    if y < 87:
        return 16 * y ** 6 + 1 + y / 38 + 60 + y ** 3
    elif y < 153:
        return 1 - 89 * y ** 3
    else:
        return sqrt(y) / 40"
"import math

def main(x):
    if x < 54:
        return x
    if 54 <= x < 122:
        a = (x / 63 - x ** 3 - 1) ** 6
        b = 90 + 14 * x ** 3 + x
        return 2 + 15 * a + math.log10(b) ** 7
    if 122 <= x < 193:
        return x ** 4
    if x >= 193:
        c = 23 * (x ** 2 - 1) ** 2
        d = (48 - 49 * x ** 3 - 27 * x ** 2) ** 3
        return c + d / 16"
"from math import log, sin, atan

def main(z):
    if z < 49:
        return 1 + 34 * abs(z) ** 5
    elif 49 <= z < 66:
        return 1 - z ** 5 / 73 - z ** 7 / 93
    elif 66 <= z < 108:
        return 51 * log(z, 2) ** 7 - z ** 2 - 80 * z ** 3
    elif 108 <= z < 201:
        return 28 * (79 + 14 * z ** 2 + z ** 3) ** 3 - 27 * sin(z ** 3) - abs(z) ** 6
    else:
        return 20 * z - z ** 3 - z ** 5 - atan(z) ** 3"
"from math import sqrt

def main(x):
    if x < 67:
        return x ** 2 - 13 - x ** 3 - x ** 4
    elif 67 <= x < 108:
        return 87 + (73 * x - 1) ** 7 + 69 * sqrt(55 * x ** 2 - 54 * x) ** 3
    elif x >= 108:
        return x ** 6"
"import math as m

def main(x):
    if x < -2:
        return x / 56 + 82 * x ** 6
    elif -2 <= x < 58:
        return (25 * x - 14 * x ** 3) ** 4 / 43 + m.sqrt(38 * x ** 2 + x) ** 5
    elif 58 <= x < 139:
        return 44 + (71 * x ** 3 - 23 * x ** 2 - 1) ** 3 / 48
    elif x >= 139:
        return 77 * (x - x ** 2) ** 4 + 25 * m.exp(x) ** 3 + (15 * x ** 2 - 0.03 - x ** 3) ** 7"
"import math

def main(y):
    if y >= 155:
        return pow(math.cos(27 * y + pow(y, 3) / 15 + 47 * pow(y, 2)), 7) - 26 - 98 * pow(math.log2(y), 2)
    elif y >= 76:
        return 47 * pow(y, 2)
    elif y >= 59:
        return 13 * pow(30 * y, 4)
    else:
        return y + pow(y, 3) + pow(y, 7)"
"import math

def main(y):
    if y < 158:
        return y ** 7
    elif 158 <= y < 224:
        return 60 * math.tan(y) ** 2
    elif 224 <= y < 321:
        return math.sin(y) ** 5 + (4 * y ** 3) ** 6
    else:
        return 67 * math.tan(69 + y ** 3 + 64 * y) ** 5 + math.cos(y + 89 * y ** 3 + y ** 2 / 43) ** 6"
"import math

def main(z):
    if z < -16:
        return 33 * (39 + z ** 2) ** 2
    elif -16 <= z < 1:
        return math.sqrt(z ** 3 / 10 + z / 3 + 50) + z ** 3 + z ** 6 / 88
    elif 1 <= z < 82:
        return (z ** 3 + 50) ** 5
    elif 82 <= z < 104:
        return 37 * (80 * z ** 2 + z + 64 * z ** 3) ** 7
    elif z >= 104:
        return 52 * z ** 5 - 35 * z ** 7"
"import math

def main(x):
    if x < 24:
        return 96 * x ** 2 - x ** 5 - (x ** 2 / 31 - x ** 3 - 1) ** 4
    elif 24 <= x < 52:
        return x / 4
    elif 52 <= x < 72:
        return x ** 6 - 0.01 - 18 * (1 - x ** 3) ** 5
    elif 72 <= x < 146:
        return 46 * abs(x + x ** 2 + 1) ** 4 + 15 * (x ** 3 / 70 - 0.02) ** 5
    else:
        return (x ** 3 + x / 9) ** 6 - x ** 7 - (96 * x ** 3 - 1) ** 2"
"import math

def main(x):
    if x < 82:
        return 76 * (x ** 2 + 34 * x ** 3 + 95) ** 2
    if 82 <= x < 152:
        return (57 - x ** 2) ** 3 + (x ** 3 + x) ** 4 + 33 * math.tan(x)
    if 152 <= x < 247:
        return math.atan(20 * x ** 3 + 72 * x ** 2 + x) / 20 - x ** 4 - math.floor(20 * x + x ** 3 / 57 + x ** 2) ** 7
    if 247 <= x < 282:
        return (80 * x ** 3) ** 2 - 92 - x ** 6 / 15
    if x >= 282:
        return (11 * x ** 2 + 1 + 41 * x) ** 7 + 55 * x ** 2 + 67 * x"
"import math

def main(x):
    if x < 7:
        return math.tan(x) ** 4 - (x ** 3 + 61 * x) ** 3 - (85 * x ** 2 - 72) ** 7
    elif 7 <= x < 29:
        return (x ** 3 / 88 - 1 - 66 * x ** 2) ** 6 - (93 * x - x ** 2 - 79 * x ** 3) - (86 + x / 83) ** 5
    elif 29 <= x < 88:
        return 65 * x ** 4
    elif 88 <= x < 103:
        return 44 * x ** 7
    else:
        return x ** 2"
"import math

def main(x):
    if x < -7:
        part_1 = 29 * (x / 14 + x ** 3 + 80) ** 2
        part_2 = math.log(x - 13 * x ** 3 - 1) ** 4 + 45
        return part_1 + part_2
    if (x >= -7) & (x < 80):
        return (10 * x ** 3 + 71 * x ** 2 + x / 46) ** 4
    if (x >= 80) & (x < 141):
        return 4 * (75 * x ** 2 + 26 * x) ** 7
    if (x >= 141) & (x < 154):
        return x ** 3 - x ** 4 - 59 * x ** 5
    if x >= 154:
        return x ** 3"
"import math

def main(x):
    if x < -11:
        return x
    elif x >= -11 and x < 35:
        return 30 * (7 * x ** 3 - x ** 2) ** 4 - 6 * math.sin(1 + 50 * x ** 2 + 61 * x) ** 7
    elif x < 112 and x >= 35:
        return x ** 5
    else:
        return 57 * x ** 7 - math.log10(x + 1 + x ** 2) ** 3 - 0.02"
"import math

def main(z):
    if z < 66:
        return z ** 3 + (82 * z ** 3 - z ** 2 - 94 * z) ** 4 + z ** 6 / 88
    if 66 <= z < 91:
        return 72 * z ** 5 - (1 - 24 * z - z ** 3) - 11 * (z ** 2 + 1) ** 3
    if 91 <= z < 191:
        return math.ceil(z / 6 - z ** 3) ** 5 - 55 * math.atan(z) ** 2 - 24 * math.ceil(z)
    if z >= 191:
        return 98 * z ** 3"
"import math
from math import *

def main(x):
    if x < 85:
        res = pow(24 * x * x, 5) - 95 * x * x
    if 85 <= x < 156:
        res = 79 - pow(32 * x ** 3 + x, 5)
    if 156 <= x < 168:
        res = pow(75 * x * x - x ** 3, 6) + 58 * x
    if x >= 168:
        res = pow(x ** 3 + 82 * x + x * x, 5) - 99 * pow(36 * x + x * x / 89, 7)
    return res"
"from math import atan

def main(y):
    if y >= 208:
        return 8 * (y * y + 83 * y + y ** 3) ** 7 + 5
    if y >= 192:
        return y * y - 1 - y
    if y >= 117:
        return (66 * y ** 3) ** 5 - y ** 3
    if y >= 104:
        return (60 * y ** 3 + 43 * y) ** 2 + (y ** 3 + 23 * y * y) ** 4
    else:
        return 12 * atan(45 * y ** 3) ** 4 + 79 * (53 * y) ** 2"
"def main(x):
    if x < 23:
        return 0.06 + 21 * x ** 3 + 50 * x ** 4
    if 23 <= x < 117:
        return x ** 3
    if 117 <= x < 197:
        return 1 + 95 * x ** 3
    if x >= 197:
        return (18 * x - 92 * x ** 3 - 23 * x ** 2) ** 3 - 1 - x ** 2"
"import math

def main(z):
    if z < 67:
        return 15 * (5 * z ** 3) ** 7 + math.atan(z) ** 5 + 82 * z ** 2
    elif 67 <= z < 101:
        return 61 * (15 + 51 * z ** 3) ** 6
    elif 101 <= z < 164:
        return 9 * z + (73 * z ** 3) ** 2 + z ** 5
    else:
        return 15 * z ** 8 + 1"
"import math

def main(y):
    if y < 173:
        return y / 97 + (y ** 3 / 11) ** 7
    if 173 <= y < 270:
        return y ** 2 - 3 * y ** 4 - 56 * math.cos(y)
    if y >= 270:
        return math.sqrt(y) ** 6 - y ** 2 - 62 * int(y) ** 3"
"import math

def main(x):
    if x < 22:
        return math.tan(x) ** 2 + 98 * x ** 3
    if 22 <= x < 90:
        return 44 * math.log(x, 10) ** 7
    if 90 <= x < 162:
        return math.tan(90 * x - x ** 3) ** 5
    if x >= 162:
        return 61 + x ** 3"
"def main(x):
    if x < 3:
        return 9 * x ** 5
    elif x >= 3 and x < 97:
        return 17 * (29 - x ** 2 - x ** 3) ** 2 - 50 * (68 - x) ** 3 - x ** 4 / 16
    elif x >= 97 and x < 146:
        return 95 * (x ** 2 - 69) ** 4 - x ** 2
    elif x >= 146 and x < 188:
        return 0.03 + 6 * x + 13 * (x ** 3 + 59 * x ** 2) ** 3
    else:
        return 2 * x ** 7 + 97 * x ** 6 + x ** 4"
"import math

def main(y):
    if y < 187:
        return y ** 2
    elif y >= 187 and y < 279:
        return y ** 6 / 13 - 17 * (y ** 2 / 33 - 70)
    else:
        return (7 * y ** 3 - 54 * y ** 2 - 1) ** 3 + 71 + math.floor(y) ** 2 / 58"
"import math

def main(y):
    return math.cos(y) ** 3 if y < 120 else 71 * math.sin(y) + 29 * y ** 6 if y < 177 else 0.07 - 40 * math.atan(y ** 3 + 89 * y ** 2) ** 2 - 76 * (55 * y ** 3) ** 4 if y < 200 else y ** 8 if y < 236 else 6 * y ** 7"
"import math

def main(x):
    if x < 44:
        return x ** 6 / 12
    elif 44 <= x < 112:
        return math.floor(2 + x + x ** 3) ** 5 - 70 * math.floor(x) ** 4 - math.exp(x) ** 3
    elif 112 <= x < 205:
        return 77 * math.exp(x - 45 * x ** 2) ** 3 - 77 * (58 * x ** 2 + x ** 3) ** 4 - x ** 5
    elif 205 <= x < 231:
        return x ** 6 / 79 - 12 * x ** 3 - x ** 4 / 95
    else:
        return x ** 5 + math.ceil(42 * x ** 2) ** 6 + math.log10(x)"
"from math import cos, sin, log10, ceil, log

def main(x):
    if x < 119:
        return x - x ** 5 - cos(6 + x ** 2 + x ** 3) ** 4
    elif 119 <= x < 147:
        return 59 * sin(x) ** 4 + 9 * x + x ** 7
    elif 147 <= x < 179:
        return 93 * x ** 4 - 89 * log10(26 * x + x ** 3) ** 3
    elif 179 <= x < 238:
        return ceil(x) / 11 + 47
    elif x >= 238:
        return log(x) ** 4 / 92"
"import math

def main(x):
    if x < -6:
        return x ** 2 + (x ** 3 - 1) ** 3 + x ** 5
    elif -6 <= x < 57:
        return 46 * (x + 1 + 26 * x ** 3) - 36 - 63 * math.log2(x) ** 7
    elif 57 <= x < 151:
        return x ** 3 / 58
    elif 151 <= x < 183:
        return (1 - 24 * x ** 2) ** 4 + x ** 5
    else:
        return 40 * x ** 6"
"import math

def main(z):
    a = (83 + 6 * z ** 3) ** 5
    b = 88 * math.tan(z - 25 * z ** 3) ** 6 - 78 * z ** 7
    if z < 46:
        return 62 * z ** 6 - (78 * z ** 2 + z ** 3) ** 5
    if 46 <= z < 129:
        return a - b
    if 129 <= z < 146:
        return 43 * z ** 5 - (z ** 3 - 26) ** 4 - 20 * z ** 3 / 31
    return 67 * math.log1p(53 * z) ** 2 - (77 * z ** 2 - 24 * z)"
"import math

def main(z):
    if z < 78:
        return z ** 6 - (0.07 - 46 * z ** 2 - z) ** 5 - (z - z ** 3 / 84)
    if 78 <= z < 162:
        return z ** 2 + 64 * z
    if 162 <= z < 251:
        return (1 + 43 * z ** 2) ** 7
    return 66 * math.ceil(z ** 2 - z ** 3) ** 5"
"import math

def main(y):
    if y < 18:
        return 58 - (12 * y ** 2 + y) ** 7
    if 18 <= y < 82:
        return y ** 2 + 1 + 61 * y ** 3
    if 82 <= y < 122:
        return y ** 2
    if 122 <= y < 180:
        return 26 * y ** 12
    return 0.01 - 97 * y ** 6 - y ** 2"
"def main(z):
    if z < 56:
        return 38 * z - z ** 5 / 14
    if 56 <= z < 108:
        return (z ** 3 + 73 * z + 6 * z ** 2) ** 6 - z ** 7 / 4 - 93
    if 108 <= z < 197:
        return (71 * z ** 3 + z) ** 5 + 95 * z ** 7
    if z >= 197:
        return (88 + z ** 3) ** 4"
"import math

def main(y):
    if y < 90:
        return math.atan(y) ** 5 - 51 * math.cos(37 * y - 76 - y ** 2) ** 7
    elif 90 <= y < 159:
        return y / 26 - (61 * y ** 3) ** 3 / 85
    elif 159 <= y < 171:
        return 57 * (1 + 42 * y + y ** 3) ** 5
    elif 171 <= y < 194:
        return y ** 5
    else:
        return 19 * y ** 2 - 17"
"from math import *

def main(y):
    if y < 67:
        f = y ** 4 + (27 * y ** 2) ** 3
        return f
    elif 67 <= y < 106:
        f = y / 47 + (31 * y ** 2 - 0.25) ** 4 + 99 * y ** 18
        return f
    elif y >= 106:
        f = fabs(y) ** 7 - 24 * floor(y) ** 2
        return f"
"import math

def main(x):
    if x < 14:
        return 15 * (x ** 3 - 13) ** 5 - math.log(x + 1 + 49 * x ** 2) ** 4 / 68
    if 14 <= x < 67:
        return 78 * x ** 4
    if 67 <= x < 114:
        return 1 + 98 * x ** 5
    if 114 <= x < 161:
        return (38 * x ** 2 + 13 * x) ** 6 - (x ** 2 - 0.02 - 65 * x) ** 2 - (x + x ** 3 / 60)
    if x >= 161:
        return 74 * (73 * x ** 2 + x) ** 5 + 6 * x ** 7"
"import math

def main(z):
    if z < 127:
        return 66 * pow(0.02 - 39 * pow(z, 2) - z, 6)
    elif 127 <= z < 166:
        return (1 - 46 * pow(z, 2) - pow(z, 3)) / 72 - 41 * pow(z, 4)
    elif z >= 166:
        return pow(z, 2) + 35 * pow(5 * z, 4)"
"import math as m

def main(x):
    if x < -10:
        return (x / 30 - x ** 2 / 79) ** 5 / 69 + (54 * x ** 2 + 1 + 53 * x) ** 3
    if -10 <= x < 40:
        return (x ** 3 + 79 * x) ** 5 - x / 66 - (x ** 3 / 4 - 78 * x ** 2 - 79 * x) ** 6
    if x >= 40:
        return (81 - x ** 3) ** 6
    return"
"from math import ceil

def main(z):
    if z < -4:
        return ceil(z)
    elif -4 <= z < 74:
        return 73 * z - 75 * z ** 6
    elif z >= 74:
        return (87 * z) ** 2 + 53 * z ** 3 + z ** 7"
"def main(y):
    if y < 45:
        return y ** 5 - 7
    elif y < 96:
        return 10 * (38 + y ** 2) ** 3
    elif y < 163:
        return (y / 6) ** 5
    else:
        return 71 * y ** 5"
"import math

def main(z):
    if z < 141:
        return math.log(z, 10) ** 4 + 39 * math.tan(z) ** 3 + z ** 6
    elif 141 <= z < 165:
        return 1 - 91 * z
    elif 165 <= z < 247:
        return z ** 6 + 26
    else:
        return math.tan(36 * z ** 2 + 42 * z ** 3 + 93) ** 7 - 78 * math.log(z, 2) - z ** 5"
"import math

def main(x):
    if x < -3:
        return 18 * pow(71 * x ** 2 + 76 * x ** 3 + 0.5, 4)
    elif -3 <= x < 93:
        return 83 * (x ** 3 + 92 * x ** 2)
    elif 93 <= x < 171:
        return 32 * pow(x + 6 + x ** 2, 4) + 59 * x
    elif 171 <= x < 241:
        return x ** 2 / 73 + 1
    else:
        return 93 * math.tan(x) ** 2 + math.cos(1 - x - x ** 2) + 17 * pow(math.exp(0.01 - 57 * x ** 3 - 81 * x ** 2), 4)"
"import math

def main(x):
    if x < 55:
        return 55 * math.sin(x ** 3 - x) + 27 + 70 * (x ** 3 + x ** 2 / 24) ** 5
    if x >= 55 and x < 151:
        return 62 * (47 - x / 29) ** 2
    if x >= 151:
        return abs(x ** 3 + 1) ** 7"
"import math

def main(y):
    if y < 155:
        return (61 * y ** 3 + 70) ** 6 / 2 + 45 * y ** 2 / 41 + 61 * math.cos(y) ** 4
    if 155 <= y < 188:
        return (y ** 3 / 36 - y) ** 4
    if 188 <= y < 245:
        return 82 * y ** 5 + 1
    return 30 + y ** 5"
"import math

def main(y):
    if y < 39:
        return abs(22 * y ** 2 + 36 * y ** 3) ** 4 / 24 - 83 * y ** 2 - 29
    if 39 <= y < 74:
        return math.sqrt(y) + 25
    return 40 * (85 * y ** 2) ** 4"
"import math

def main(z):
    if z < 107:
        return 90 * math.sqrt(z) + (z ** 3 / 86 + z) ** 5 + 92 * z ** 2
    if 107 <= z < 120:
        return z ** 3
    if z >= 120:
        return 1 - 25 * z ** 6"
"import math

def main(x):
    if x < 79:
        return (65 * x ** 3) ** 2
    if 79 <= x < 134:
        return math.ceil(x) ** 5 + x ** 2 + 75 * (3 * x + x ** 2)
    if 134 <= x < 211:
        return 51 * (x ** 3 - 6 * x) ** 3 + x
    if 211 <= x < 248:
        return (35 * x ** 3 + x + x ** 2) ** 0.5 + 89 * x ** 3
    return 96 * math.ceil(22 - 28 * x ** 3) ** 2 - x ** 3"
"import math

def main(y):
    if y < 41:
        return 29 * pow(math.cos(y - 75 * y ** 2 - 1), 4) - 60
    elif 41 <= y and y < 97:
        return 2 * y ** 2
    elif 97 <= y and y < 123:
        return y - 87 - 99 * y ** 2 - 84
    elif y >= 123:
        return 11 * math.log(y ** 3 / 37 - y ** 2 / 30 - 0.09) ** 5 - y ** 4 / 33"
"import math

def main(z):
    if z < -8:
        return z
    if -8 <= z < 63:
        return z ** 4 + (78 + z / 85 + z ** 3 / 31) ** 6
    if z >= 63:
        return 98 - (21 * z + 1) ** 2 / 37 - (z - 92 * z ** 3)"
"from math import ceil, atan

def main(x):
    if x < 126:
        return 1 - 98 * ceil(x ** 2 + 1 + x ** 3) - 64 * ceil(x) ** 4
    elif 126 <= x < 221:
        return 47 * x ** 5 + x ** 6
    elif 221 <= x < 304:
        return x - 1
    elif 304 <= x < 379:
        return 63 * atan(26 * x ** 2 + 6 * x + 1) ** 2 + 1
    elif x >= 379:
        return x ** 2"
"import math

def main(x):
    if x < 31:
        return x ** 4 - 29
    elif 31 <= x < 129:
        a = 7 + (x ** 3 / 78) ** 4
        b = math.sqrt(11 * x - x ** 2 / 22) ** 3 / 65
        return a + b
    elif 129 <= x < 159:
        return 64 * (x ** 2 - 89) ** 3
    elif x >= 159:
        a = 62 * (28 * x + 42 * x ** 3 + 40) ** 5
        b = math.cos(x) ** 2 / 23
        return a - b"
"import math

def main(z):
    if z < 89:
        return 25 * (0.02 + z ** 2) - 49 * (30 * z ** 3 - z - 41) ** 3 - 83
    if 89 <= z < 179:
        return math.tan(z) - z ** 5 / 88
    if 179 <= z < 192:
        return (86 * z ** 2 - 2 * z ** 3) / 33 - 87 * (z ** 2 / 72 + z ** 3 / 71 + 97) ** 2
    if 192 <= z < 249:
        return z ** 4
    if z >= 249:
        return z - 66 * (z ** 3 / 56 + 1 + z) ** 4"
"import math

def main(y):
    if y < 174:
        return (y ** 3 + y ** 2) ** 7
    elif 174 <= y < 235:
        return y ** 5 + 73 * math.sin(y ** 2 - 4 * y) ** 4
    elif 235 <= y < 255:
        return 68 * y ** 6
    else:
        return 58 * (97 * y) ** 2"
"import math

def main(y):
    if y < 134:
        return 28 * (y ** 3 - y / 98) ** 2
    if 134 <= y < 182:
        return 2 * math.cos(y ** 3 - 12 - y) + (math.tan(y) ** 4 + y ** 6)
    if 182 <= y < 193:
        return 1 - 6 * (y ** 2 + 0.06 + y / 53) ** 3
    return 41 * math.sin(1 - 86 * y ** 3 - 53 * y ** 2) ** 6 + 63 * math.log(y ** 2, 10)"
"import math

def main(z):
    if z < 42:
        return math.cos(z / 38 - 69 * z ** 3) + z ** 18 + z ** 7
    elif 42 <= z < 122:
        return math.cos(z) ** 4
    else:
        return 30 * z ** 7 + z ** 5"
"import math

def main(y):
    if y < 9:
        return (y + 44 * y ** 3) ** 3 + (1 + y / 95 + y ** 2) ** 2 / 7
    elif 9 <= y < 98:
        return y ** 5 - y - abs(y) ** 4
    else:
        return 42 * (81 * (y ** 2 - y ** 3)) ** 2 + 1 + (1 + y ** 3 + 6 * y) ** 7"
"import math

def main(x):
    if x < 20:
        return math.tan(54 + x ** 2 + x) / 94 + 48
    elif 20 <= x <= 116:
        return (2 - x ** 2 - x ** 3) ** 6 / 31 - math.exp(x) ** 7
    elif x >= 116:
        return 15 * math.tan(x) ** 2"
"from math import cos, fabs

def main(x):
    if x < -68:
        r = 76 * (x ** 3 / 93 + 40 * x) ** 3 + 92 * (51 * x) ** 7
    elif -68 <= x and x < 8:
        r = fabs(x)
    elif 8 <= x and x < 74:
        r = x ** 7 + 35 * cos(x) ** 3
    else:
        r = x ** 5 + 54 * (27 * x + 1) ** 2 + 94 * x ** 3
    return r"
"from math import *

def main(x):
    if x < 51:
        f = 75 * atan(x) ** 6 - 49 * (x + 43 + x ** 2) ** 7 - 75 * x
        return f
    elif 51 <= x < 122:
        f = 43 * x ** 2 + 75 * x ** 10
        return f
    else:
        f = 6 * (1 + x / 15 + 81 * x ** 2) ** 2 - x ** 5
        return f"
"import math

def main(z):
    if z < 134:
        return 13 * math.tan(z) + (z ** 2 / 52 - z ** 3) ** 6
    elif 134 <= z < 157:
        return math.ceil(z) ** 5 - z ** 3 / 53 - (z ** 3 + 1)
    elif 157 <= z < 193:
        return math.atan(1 - z ** 3) - 75 * (98 * z ** 2 + 70 * z ** 3) ** 5
    else:
        return z ** 5"
"import math

def main(z):
    if z < 48:
        return 24 * math.tan(z) + 0.07
    if 48 <= z and z < 78:
        return pow(z * z / 16, 3)
    if 78 <= z and z < 175:
        return z
    if 175 <= z and z < 258:
        return pow(z, 4) - (z * z + z)
    if z >= 258:
        return 56 * pow(z, 3)"
"import math as m

def main(x):
    if x < 85:
        return 19 - x ** 3
    if 85 <= x < 123:
        return x - x ** 6 - 13 * x ** 3
    if 123 <= x < 186:
        return 6 * (x + 63 * x ** 2) ** 3 + 35 * (18 - 7 * x) ** 6
    else:
        return m.log(x) ** 6"
"import math

def main(x):
    if x < 103:
        return (88 * x + 59 * x ** 2) ** 2 - 59
    if 103 <= x < 195:
        return 89 * x ** 2
    if 195 <= x < 268:
        return 42 * (66 * x - 98 * x ** 2 - x ** 3) ** 5 + 39 * x ** 3
    if 268 <= x < 343:
        return (x ** 2 / 76) ** 3 + 74 * x ** 2 + 73 * x + 90 * x ** 3 + x ** 5 / 52
    return (1 - x) ** 2 - 56 * x ** 6 - 1"
"import math

def main(x):
    if x < 122:
        return x ** 6 / 55 + 1 + (7 * x ** 2) ** 3 / 43
    if 122 <= x < 163:
        return 58 * math.tan(x) ** 6
    if 163 <= x < 256:
        return (x / 59 - x ** 3) ** 3 / 7
    if x >= 256:
        return 77 * (x ** 2 / 74 - 84 * x - 75 * x ** 3) ** 5 - 36 * math.log2(x ** 3 + x ** 2) ** 4 - (41 * x ** 3 + x ** 2 / 69) ** 3"
"import math

def main(z):
    if z < -55:
        return z ** 2
    elif -55 <= z < -16:
        return 21 - (20 + z ** 2) ** 7 / 84
    elif -16 <= z < 54:
        return math.ceil(z ** 2 + z) ** 2
    elif z >= 54:
        return z / 38 - 56 * z ** 4"
"from math import sqrt, log10, atan

def main(y):
    if y < 50:
        return 38 * sqrt(y) ** 6 - 99 * log10(y) ** 5 - 89 * y ** 3
    elif y < 114:
        return 27 - 43 * (41 * y ** 2 + y ** 3) ** 4
    elif y < 133:
        return y ** 2 / 99 - 82 - y ** 6
    else:
        return y ** 2 + 16 * atan(y) ** 7"
"import math

def main(z):
    if z < 127:
        return 10 * z
    if 127 <= z and z < 142:
        return 8 * (31 * z) ** 4
    if 142 <= z and z < 183:
        return 24 * z ** 5
    if z >= 183:
        return 68 * math.atan(77 * z ** 3 + 95 * z) ** 2"
"import math as m

def main(z):
    if z < 159:
        return 73 * m.log10(z) ** 2 - 16 * m.ceil(z) ** 4
    elif 250 > z >= 159:
        return 88 * (z ** 2 - z - z ** 3)
    elif 250 <= z < 334:
        return z ** 5 + z ** 6
    elif 380 > z >= 334:
        return m.log10(62 * z ** 3) ** 4 / 59 - z ** 2
    else:
        return z ** 4 / 71 + 89 * m.atan(3 * z + 0.03 + 24 * z ** 3)"
"import math

def main(y):
    if y < 142:
        return y ** 6
    if 142 <= y < 212:
        return 52 * y ** 2
    if 212 <= y < 292:
        return y / 88 - 96 * (93 * y ** 3) ** 3 - 60 * y ** 5
    return 14 * y ** 4 + y ** 3"
"import math

def main(x):
    if x < 161:
        value = 73 * x - 41 * x ** 3 - 2 * (x - 62 - x ** 2 / 32) ** 2
        return value
    if x >= 161 and x < 257:
        value = (48 + 74 * x ** 2) ** 7 + (x ** 3 / 46 + 75 * x + 61) ** 4 + 6 * x ** 5
        return value
    if x >= 257 and x < 335:
        value = 60 * math.sqrt(x ** 2 / 20 - 13 * x) + 76 * (84 * x ** 2) ** 3 + 0.02
        return value
    if x >= 335:
        value = 70 * x + 3 + 96 * (0.001 - 45 * x) ** 7
        return value"
"from math import log2
from math import tan

def main(z):
    if z < 26:
        return z ** 6 + z ** 7
    if z >= 26 and z < 96:
        return 20 * int(z ** 3 + 1) ** 2
    if z >= 96 and z < 181:
        return 36 - (z + z ** 3) - 49 * log2(79 * z) ** 4
    if z >= 181 and z < 195:
        return z ** 5 - log2(z) ** 6 - tan(51 * z ** 2) ** 3
    if z >= 195:
        return z - (z + 2 * z ** 2 + 18) ** 2 - z ** 3"
"import math

def main(z):
    if z < 40:
        return (z ** 2 + z ** 3 + 2 * z) ** 3 - 17
    if z >= 40 and z < 71:
        return z
    if z >= 71:
        return 16 * (56 * z ** 3) ** 2 + 83 * math.log(z) ** 5 + 1"
"import math

def main(z):
    if z < 133:
        r1 = math.log(z, 2) ** 7
        r2 = 93 * z ** 2 - 72 * z ** 3
        r3 = (15 * z + z ** 2 + z ** 3) ** 6
        return r1 - r2 - r3
    elif z >= 133 and z < 149:
        r1 = z ** 4 + 1 + z
        return r1
    elif z >= 149:
        return abs(z) ** 2"
"import math

def main(x):
    if x < 60:
        return 11 * x ** 7 + 59 * x ** 4
    elif x < 82 and x >= 60:
        return x ** 9
    elif x < 121 and x >= 82:
        return 26 * math.exp(x) ** 6 - 32 * x ** (1 / 2) - 38 * x ** 4
    elif x < 216 and x >= 121:
        return x
    elif x > 216:
        return 99 - 68 * math.log(11 * x ** 3 + 1, 2) ** 4 - 54 * x ** 6"
"from math import log

def main(y):
    if y < -6:
        return (17 * y ** 2 - 75 - 49 * y ** 3) ** 4
    elif -6 <= y < 28:
        return 68 * (y ** 3 - 15 * y ** 2) ** 4 - 1
    elif 28 <= y < 73:
        return 70 * log(y) ** 3 + 61 * y ** 2
    elif y >= 73:
        return 46 - 92 * y ** 6 - 81 * (y - y ** 2) ** 2"
"import math

def main(z):
    if z < 158:
        s = math.log2(z + 2 * z ** 2 + 1) ** 2
    elif 158 < z < 240:
        s = 91 * z ** 7
    else:
        s = 16 * (z / 50) ** 5 - (z ** 3 - z / 84) ** 2
    return s"
"import math

def main(y):
    if y < 5:
        s = (y ** 2 / 83) ** 5 - 63 * y
        return s
    elif 5 <= y < 96:
        s = 94 * math.atan(y) ** 4 + y + y
        return s
    elif y >= 96:
        s = y ** 6 - 39 * y - 91 * y ** 5
        return s"
"from math import cos, ceil

def main(x):
    if x < 180:
        return x ** 2
    elif 180 <= x < 236:
        return x ** 4
    elif 236 <= x < 313:
        return 65 * x ** 5 + 27 * x ** 6 + ceil(x) ** 3
    elif x >= 313:
        return 49 * cos(27 * x ** 2 - 69 * x ** 3) ** 7 - 81 * x ** 2 - 80 * (1 + 7 * x ** 2) ** 6"
"import math

def main(x):
    if x < -44:
        res1 = 32 * (69 * x ** 2 - x - 30 * x ** 3) ** 4
        res2 = 24 * math.floor(94 * x ** 3 - 1)
        res3 = 24 * (x ** 2 - x - 58 * x ** 3) ** 6
        return res1 - res2 - res3
    elif -44 <= x < 5:
        res1 = 12 * math.sin(x ** 3 + 1) ** 7
        res2 = 78 * math.atan(x) ** 2
        res3 = math.tan(99 * x - 29 * x ** 3 - 91) ** 5
        return res1 + res2 + res3
    elif 5 <= x < 48:
        res1 = (61 * x ** 3 - 1 - x ** 2 / 43) ** 5
        res2 = 43 * (92 * x ** 3 - x ** 2) ** 4
        return res1 + res2
    else:
        return math.sqrt(x) ** 7 + 32 * x ** 5"
"import math

def main(z):
    if z < 2:
        return abs(z) ** 7
    elif 2 <= z < 101:
        return math.sqrt(z) ** 5 + (z ** 2 / 81 + 24 * z + 22 * z ** 3) ** 6
    elif 101 <= z < 145:
        return (z ** 2 / 64 - 18 * z) ** 3 + 51 * math.ceil(z) + 2 * abs(1 + 97 * z ** 2 + z ** 3) ** 7
    else:
        return 3 * z ** 4"
"import math

def main(z):
    if z < 46:
        return 8 * z ** 4 + z
    if 46 <= z < 142:
        return 66 * z ** 2 - math.log10(z) ** 5 - math.log10(z) ** 6
    if 142 <= z < 188:
        return (44 + z ** 2 + 99 * z) ** 4 - 1
    return (32 + z ** 2) ** 5 / 17"
"import math

def main(x):
    if x < 155:
        return (x ** 3 - x) ** 3 + 0.02 + (x ** 3 / 9 + 1) ** 5
    elif x < 176 and x >= 155:
        return (x ** 2 - x ** 3 - 32) ** 5
    elif x < 220 and x >= 176:
        return x
    elif x < 309 and x >= 220:
        return 1 + 3 * x + x ** 6
    elif x >= 309:
        return math.cos(13 * x ** 2)"
"import math

def main(z):
    if z < -60:
        return z ** 4
    elif z >= -60 and z < 22:
        z1 = (41 * z) ** 3 - 3 * (z ** 3 - z ** 2 - z)
        return z1
    elif z >= 22 and z < 73:
        z1 = 34 * z ** 6 + (z / 33 + z ** 3 + 60) ** 4 + math.tan(z)
        return z1
    elif z >= 73 and z < 97:
        z1 = z ** 6 / 56 + 87 * z ** 5 + 1
        return z1
    elif z >= 97:
        z1 = 2 * math.atan(z) ** 5
        return z1"
"import math

def main(x):
    if x < 1:
        return x ** 2
    elif x < 57:
        return abs(71 * x ** 3 - 72 * x - 1) ** 3 + 73 * x ** 2
    else:
        return 11 - (x ** 3 + 56) ** 2 / 46 - 61 * (x + 32) ** 6"
"def main(z):
    if z < 4:
        res = 72 * z ** 2 + z ** 6
    elif z >= 4 and z < 78:
        res = (88 * z) ** 3 - z
    else:
        res = z ** 7 + 98 * z ** 4 + 2 * z ** 6
    return res"
"import math

def main(x):
    if x < 32:
        return 80 * x + x ** 7 + (1 - 51 * x - 65 * x * x) ** 2
    if x >= 32 and x < 126:
        return math.sqrt(x) - (36 * x ** 3 - 15 * x ** 2) ** 3 / 34
    else:
        return x + (1 + x) ** 6"
"def main(y):
    if y < 26:
        f = y ** 4 + 49 * (y ** 2 + 68 * y) ** 2 + 56
        return f
    elif 26 <= y < 109:
        f = y ** 6
        return f
    elif 109 <= y < 183:
        f = 66 * y ** 3 - 6 * y
        return f
    elif 183 <= y < 279:
        f = 24 * (55 * y) ** 3
        return f
    elif y >= 279:
        f = 1 - (y ** 3 + 46 * y ** 2 + 68 * y) ** 2 - (68 - 21 * y ** 2 - y ** 3) ** 4
        return f"
"import math

def main(z):
    if z < 77:
        return 26 + 80 * z ** 7 + 18 * (z ** 2 - 52) ** 5
    elif z <= z < 168:
        return 58 * (abs(z) - 0.02) ** 5 + 51 * z ** 4
    elif 168 <= z < 181:
        return z ** 4
    elif 181 <= z < 280:
        return 12 * math.atan(42 * z ** 2 - 21 * z ** 3 - z) + 0.06 + 39 * z ** 3
    else:
        return 12 * (z ** 3 - z) ** 3 - 88 * z ** 2 - 63 * z"
"import math

def main(z):
    if z < 140:
        return 89 + 41 * pow(11 * pow(z, 3) - 1 - pow(z, 2), 3) + 16 * pow(z, 4)
    if 140 <= z < 237:
        return pow(math.log(z, 2), 6) / 9 - 1
    if z >= 237:
        return 8 * pow(91 * z - pow(z, 3) - 62, 5) + 45 * pow(81 + 68 * pow(z, 2), 6) + 70 * math.cos(0.03 + pow(z, 3) + z)"
"def main(y):
    if y < 18:
        return y ** 2 + (y ** 3 - 52 * y) ** 7 + 57 * (y - y ** 2 - 1) ** 3
    elif 18 <= y < 82:
        return 58 * (43 * y) ** 2 - abs(97 * y + y ** 2) - y ** 6
    elif 82 <= y < 121:
        return 39 * y ** 4
    elif 121 <= y < 132:
        return (y ** 2 - 76 * y ** 3) ** 4 - 18 * (87 * y ** 3) ** 6
    elif y >= 132:
        return (43 * y ** 3 + y ** 2 + 1) ** 4"
"from math import ceil

def main(y):
    if y < 94:
        return 1 - (45 * y ** 3 - y ** 2 / 41 - 0.03) ** 7
    elif y < 122:
        return ceil(y) ** 3 / 9
    elif y < 214:
        return y ** 7 / 89
    elif y < 274:
        return y ** 5 - 83 - 22 * y ** 3
    else:
        return 73 * (y + y ** 2 / 62 + 0.05) ** 2"
"def main(z):
    if z < 112:
        res = 46 * (70 + 33 * z + 55 * z ** 3) ** 4 - 48 * z - 1
    elif 112 <= z < 202:
        res = (94 - z) ** 5 + 1
    elif z >= 202:
        res = z ** 4 - (z ** 3 + 54) ** 7 - 92 * (72 + 13 * z + z ** 3)
    return res"
"import math

def main(x):
    if x < 116:
        f = 72 * math.exp(x) ** 2
    elif x >= 116 and x < 152:
        f = 43 * math.tan(x) ** 5
    elif x >= 152 and x < 194:
        f = math.sin(x) ** 2
    elif x >= 194 and x < 239:
        f = x ** 3 / 73 - (44 * x ** 2 + x ** 3 / 5) ** 6 / 21
    elif x >= 239:
        f = 38 * x ** 2 + 1
    return f"
"import math

def main(z):
    if z < 75:
        return 55 * math.floor(z) ** 7
    elif z < 142:
        return 54 * (z ** 2 - 59) ** 5 - 50 * (1 - z ** 2 / 47 - z / 23) - 82 * z ** 7
    elif z < 176:
        return (z ** 2 / 51) ** 6 + 75 * math.cos(z) ** 4
    else:
        return 62 * (86 * z - 72 * z ** 3) ** 2 + z ** 5 + z ** 14"
"import math

def result_1(y):
    return 91 * y ** 7 + y ** 3

def result_2(y):
    return y ** 7 / 36 + (y * y / 93 + 1 + y) ** 5 + 43 * y ** 4

def result_3(y):
    return y ** 7 / 89

def result_4(y):
    return 96 * math.fabs(y ** 3 - 25 * y - 46) ** 7

def main(y):
    if y < 5:
        return result_1(y)
    elif y >= 5 and y < 73:
        return result_2(y)
    elif y >= 73 and y < 146:
        return result_3(y)
    else:
        return result_4(y)"
"from math import *

def main(x):
    if x < 110:
        return 97 * x ** 3
    elif 110 <= x < 191:
        return fabs(x) ** 2 / 86
    elif x >= 191:
        return (52 * x ** 2) ** 7"
"import math

def main(y):
    res = 0
    if y < 96:
        res = (7 * y ** 2) ** 6 - y ** 10 - (1 + y + y ** 2)
    elif 96 <= y < 119:
        res = 1 + y ** 4 / 15 + math.atan(y) ** 2
    elif 119 <= y < 188:
        res = 67 * y ** 7
    elif 188 <= y < 251:
        res = (88 * y ** 2 + 79 * y + y ** 3 / 77) ** 5
    elif y >= 251:
        res = (38 * y ** 2 - y - y ** 3) ** 2 + 1 + y ** 7
    return res"
"import math

def main(x):
    if x < 77:
        return x ** 3 - x ** 2 - x - (90 * x ** 3 - x - 46) ** 6 - x ** 2 / 34
    if 77 <= x < 119:
        return 85 * x ** 21 + x ** 2
    if 119 <= x < 171:
        return math.tan(21 * x - x ** 3) + x ** 3 + 27 * abs(x) ** 5
    if 171 <= x < 207:
        return 92 * x ** 6
    if x >= 207:
        return math.atan(x) - 8 * (40 - 29 * x ** 2 - x ** 3) ** 2"
"import math

def main(z):
    if z < -18:
        z1 = 34 * z ** 5 - 81 * z ** 2 - z ** 4
        return z1
    elif z >= -18 and z < 57:
        z1 = z ** 3 - 28 * math.ceil(68 * z ** 3 + 93 * z ** 2) ** 7
        return z1
    elif z >= 57 and z < 107:
        return 29 * z ** 7
    elif z >= 107 and z < 188:
        z1 = 1 + math.sqrt(z) + math.acos(81 * z ** 2) ** 4
        return z1
    elif z >= 188:
        z1 = 1 + (1 - 55 * z ** 3 - 46 * z ** 2) ** 7
        return z1"
"import math

def main(y):
    if y < 153:
        return 49 * y ** 5 + 42 * y + 1 + 32 * math.cos(y) ** 7
    if 153 <= y < 228:
        return 89 * y ** 6 + 6 * (43 * y ** 3) ** 7 + 58 * (53 - y ** 2 / 4 - y) ** 4
    if 228 <= y < 293:
        return 18 * math.exp(5) * (0.01 - y ** 3) - (y ** 2 + 49 + 95 * y ** 3) ** 6
    return 52 * math.tan(y)"
"import math

def main(y):
    if y < 26:
        return 82 * math.atan(51 * y ** 2 + 71 * y) + math.tan(y ** 3 + 71 * y ** 2) ** 3
    elif 26 <= y < 112:
        return (1 - 2 * y ** 3) ** 4 - (98 * y ** 3) ** 7 - 1
    else:
        return 49 * math.asin(y) ** 7 + 0.05"
"import math

def main(y):
    if y < 3:
        s = math.floor(y) ** 4 + 0.01
        return s
    elif 3 <= y < 40:
        s = 0.06 + y ** 7
        return s
    else:
        return y ** 3"
"import math

def main(y):
    if y < 20:
        return (34 - y ** 2) ** 6
    elif 20 <= y < 35:
        return 36 * y ** 6
    else:
        return 55 * y ** 2"
"import math

def main(x):
    if x < 62:
        return x ** 6
    if 62 <= x < 160:
        return x ** 6 + 98 * x ** 2
    return 12 - math.atan(68 - x ** 2) ** 7 / 76 - math.atan(x) ** 2"
"import math

def main(y):
    if y < 46:
        s = 64 * (50 * y ** 3 + 43 * y + y ** 2) ** 3
        return s
    elif 46 <= y < 140:
        s = y ** 7 + 34 * math.tan(y ** 3) + 23
        return s
    else:
        a = y ** 2 / 11 + math.ceil(y ** 3 - 1 - 30 * y) ** 3
        b = (39 * y - 97 * y ** 2) ** 7
        s = a + b
        return s"
"from math import cos, log2, log10

def main(z):
    if z < 105:
        return 0.02 - pow(log2(58 * pow(z, 3) + z + 1), 7) / 16 - 45 * log10(pow(z, 3) + 66 * z * z + z)
    elif z < 195:
        return pow(cos(60 * z * z + z), 6) - pow(z, 4)
    elif z < 287:
        return pow(91 * pow(z, 3) + 63 + 85 * z * z, 4)
    else:
        return 5 * pow(z + pow(z, 3) + z * z, 6) + pow(z, 7) + 1"
"from math import floor, sin

def main(z):
    if z < 82:
        return 98 * floor(z) ** 5 + (17 - z) ** 3 + sin(1 + 51 * z + z ** 2 / 27)
    elif z < 112:
        return 58 * (z + 93) ** 6
    elif z < 174:
        return 34 * z ** 7 + z ** 6 / 19 + 44
    else:
        return 62 * z ** 2"
"from math import floor, log

def main(x):
    if x < -11:
        return 96 * (50 * x) ** 4 + x ** 6
    elif x < 18:
        return x ** 4 + 1 + 78 * floor(x) ** 6
    elif x < 77:
        return x ** 3 - 10 - 27 * x ** 4
    elif x < 95:
        return 32 * x ** 2
    else:
        return log(1 + x ** 3) ** 3"
"import math

def main(z):
    if z < 45:
        f = math.sin(z)
    elif 45 <= z < 130:
        f = 1 + z / 29 + 77 * z ** 2 + z ** 3 + 25 * (z ** 2 / 71 - z) ** 4
    elif 130 <= z < 156:
        f = 94 * z ** 4 + (42 - 57 * z ** 2) ** 5
    else:
        f = z
    return f"
"from math import sin

def main(x):
    if x < 113:
        return (64 * x ** 3 - x ** 2) ** 6
    elif 113 <= x < 203:
        return (65 * x ** 2 + 4 * x) ** 2 - 15 * x ** 6
    elif x >= 203:
        return sin(0.03 - 10 * x ** 2) ** 4"
"import math as m

def p1(y):
    return 91 * (14 * y - 71 * y ** 3) ** 3

def p2(y):
    return 17 * y / 84

def p3(y):
    return m.sqrt(y) ** 7

def main(y):
    if y < 18:
        return p1(y)
    elif 18 <= y < 92:
        return p2(y)
    elif y >= 92:
        return p3(y)"
"def main(x):
    if x < -46:
        return x ** 3 + 39 * x
    elif -46 <= x < 1:
        return x ** 7
    elif x >= 1:
        return 28 * (93 * x ** 3 + x ** 2) ** 7 - 6789 * x ** 3 - 0.02"
"import math

def main(x):
    if x < 138:
        f = 55 * math.floor(x + 38 + x ** 3) ** 6 + x ** 7 / 68 + (51 * x - x ** 2) ** 5
    if 138 <= x < 185:
        f = 48 * x ** 6 - 85 * x
    if 185 <= x < 268:
        f = (82 * x ** 3 - 1) ** 6 + (x ** 2 + x) ** 7 / 9 + x ** 2 / 49
    if x >= 268:
        f = pow(math.exp(x), 2) / 4 - (6 * x ** 2 - 2 * x ** 3 - 18) ** 6 - 63 * math.sqrt(x) ** 5
    return f"
"import math

def main(y):
    if y < -52:
        f = 1 + math.log(54 * y - y ** 2 - y ** 3) ** 6 / 58 + 29 * y ** 7
    if -52 <= y < 4:
        f = 53 * (91 * y ** 2) ** 4
    if 4 <= y < 62:
        f = math.ceil(92 * y) ** 3 - math.sqrt(y) ** 6
    if y >= 62:
        f = y ** 3 / 60 + y ** 6 + 42
    return f"