<filename>projects/src/main/python/CodeJam/Y11R5P1/dennislissov/generated_py_bb93a4d1acf540c3b7c8dfd80359bd28.py
import sys
sys.path.append('/home/george2/Raise/ProgramRepair/CodeSeer/projects/src/main/python')
from CodeJam.Y11R5P1.dennislissov.A import *

def func_3ba6780ca418469a885da55554034725(y, x):
    area += (x - px) * (y + py) / 2
    px, py = x, y
    return py


def func_16bfa03b301e43139f8f644e5e7cbce6(y, x):
    area += (x - px) * (y + py) / 2
    px, py = x, y
    return area


def func_5726577868614ce7b084d034f2376af6(y, x):
    area += (x - px) * (y + py) / 2
    px, py = x, y
    return px


def func_dabbc99813184aeea69a2f2d636dea55(ax, px, py):
    y = py + (y - py) / (x - px) * (ax - px)
    x = ax
    return x


def func_d0b5903d9cd747d2b4b964585933d19f(ax, px, py):
    y = py + (y - py) / (x - px) * (ax - px)
    x = ax
    return y


def func_5e4c1430509d4af995186639565f815e():
    px = 0
    py = 0
    return px


def func_1ca08860d10b4cf8aedded11e9dffb1a():
    px = 0
    py = 0
    return py


def func_95288f9c7bff4bf682e6cf6ba68a8ba9():
    py = 0
    area = 0
    return py


def func_f0ab3dbecaef42e5be66cbfb734b7890():
    py = 0
    area = 0
    return area


def func_f2b586b319aa4cb98bfb783ddd7addcb(Y, X, ax):
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return px


def func_23ca7fa984f94fb3bfd7a107f4210e78(Y, X, ax):
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return x


def func_214e65bd98004678b3eeba446027da4f(Y, X, ax):
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return y


def func_daf1c94df0584af692b5f4bcea188648(Y, X, ax):
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return area


def func_b759ad0d09e94f0ca1ec6405fa944e58(Y, X, ax):
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return py


def func_9ed2c74c0e6244e4ab8a4f0968336c03(area, ax, px, py):
    if ax < x:
        y = py + (y - py) / (x - px) * (ax - px)
        x = ax
    return area


def func_970a7c8ba3704e9491127e3947e0f97b():
    px = 0
    py = 0
    area = 0
    return px


def func_92b324bab0d74577a806743dce7beb52():
    px = 0
    py = 0
    area = 0
    return area


def func_e87e2a34f8cf4dd4aac49c50a0e53958():
    px = 0
    py = 0
    area = 0
    return py


def func_0697bf4db790456998f4524105458519(Y, X, ax):
    py = 0
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return py


def func_6f78f82a300f490c91a7d12da591655e(Y, X, ax):
    py = 0
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return x


def func_9faf09f55d8547e697b03888eb6faad5(Y, X, ax):
    py = 0
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return y


def func_8d0048a94dd640f9ae614473ce1fa916(Y, X, ax):
    py = 0
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return area


def func_557dcb3fb31b4f728f8a7bdca9e3e339(Y, X, ax):
    py = 0
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return px


def func_b00db3e3d55f476597b206c0f54ca686(Y, X, ax):
    px = 0
    py = 0
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return py


def func_9796002a7e484de685cf089d82775124(Y, X, ax):
    px = 0
    py = 0
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return y


def func_25a25b6a067440b8abb0cda23274198e(Y, X, ax):
    px = 0
    py = 0
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return area


def func_7b65d97fa3534bcdbedbcad451839552(Y, X, ax):
    px = 0
    py = 0
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return x


def func_f36584730d6b46698e631ec2eaf1e0f6(Y, X, ax):
    px = 0
    py = 0
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return px


def func_c8e909b1d8ef45bb81720100de8be90b(ncase, infile):
    print('Case #{nc}'.format(nc=ncase + 1))
    W, L, U, G = (int(s) for s in infile.readline().split())
    return W


def func_9faea165cee94f6aa49cf54e20f95a12(ncase, infile):
    print('Case #{nc}'.format(nc=ncase + 1))
    W, L, U, G = (int(s) for s in infile.readline().split())
    return G


def func_e80907eba6cf46c6a8137886b8e2c14c(ncase, infile):
    print('Case #{nc}'.format(nc=ncase + 1))
    W, L, U, G = (int(s) for s in infile.readline().split())
    return L


def func_f75d55cd2b1b409db59d7afe7c13087f(ncase, infile):
    print('Case #{nc}'.format(nc=ncase + 1))
    W, L, U, G = (int(s) for s in infile.readline().split())
    return s


def func_c9bb9573097a4c6aae46b4a2cc64276f(ncase, infile):
    print('Case #{nc}'.format(nc=ncase + 1))
    W, L, U, G = (int(s) for s in infile.readline().split())
    return U


def func_9f3ec1b85566455a95126385cf4e1f6c(Lp, infile):
    W, L, U, G = (int(s) for s in infile.readline().split())
    Lp = [[int(s) for s in infile.readline().split()] for i in xrange(L)]
    return i


def func_36e0888b67d74a9399f251b686416a94(Lp, infile):
    W, L, U, G = (int(s) for s in infile.readline().split())
    Lp = [[int(s) for s in infile.readline().split()] for i in xrange(L)]
    return G


def func_d81dfa3ea87e4bd0993037f02057bfab(Lp, infile):
    W, L, U, G = (int(s) for s in infile.readline().split())
    Lp = [[int(s) for s in infile.readline().split()] for i in xrange(L)]
    return U


def func_c2dec506230345dd97211ee64cb98359(Lp, infile):
    W, L, U, G = (int(s) for s in infile.readline().split())
    Lp = [[int(s) for s in infile.readline().split()] for i in xrange(L)]
    return L


def func_7aac99e646d94133aa7e23ab7bf64166(Lp, infile):
    W, L, U, G = (int(s) for s in infile.readline().split())
    Lp = [[int(s) for s in infile.readline().split()] for i in xrange(L)]
    return W


def func_b5c4f36135cf44ed877f852a51ed28df(Lp, infile):
    W, L, U, G = (int(s) for s in infile.readline().split())
    Lp = [[int(s) for s in infile.readline().split()] for i in xrange(L)]
    return s


def func_3cf08fece0a440de9549151f95996078(Ly, Uy, X):
    Y = Uy - Ly
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))
    return area


def func_2d7c562e9b0148198e7fde596a113ed2(Ly, Uy, X):
    Y = Uy - Ly
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))
    return Y


def func_659622b0340743c88c95b497a41a557d(Y, X):
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    return area


def func_396e1081307e40ce8f745bd0f137bf1e(Y, X, G):

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    return NAs


def func_eb77d078893e4f8aa2e7bdbe0984a0d0(Y, X, G):

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    return area


def func_beb781dcbb554bf2aebc9aa2f7370eae(area, W, G):
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return NA


def func_243ebc5672064a3f94074f635acf6021(area, W, G):
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return NAs


def func_4df8196ffbfc4d768e65e55a8edab4eb(area, W, G):
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return points


def func_f54dac81ea4543c2a1e561ea5ae647af(Lp, ncase, infile):
    print('Case #{nc}'.format(nc=ncase + 1))
    W, L, U, G = (int(s) for s in infile.readline().split())
    Lp = [[int(s) for s in infile.readline().split()] for i in xrange(L)]
    return W


def func_03f0a47b81f54349894ae80e3df364cc(Lp, ncase, infile):
    print('Case #{nc}'.format(nc=ncase + 1))
    W, L, U, G = (int(s) for s in infile.readline().split())
    Lp = [[int(s) for s in infile.readline().split()] for i in xrange(L)]
    return U


def func_c6a0c02b9aa94adcae8667d220d24ee3(Lp, ncase, infile):
    print('Case #{nc}'.format(nc=ncase + 1))
    W, L, U, G = (int(s) for s in infile.readline().split())
    Lp = [[int(s) for s in infile.readline().split()] for i in xrange(L)]
    return s


def func_2114f611135a404083fa23b8de1119d5(Lp, ncase, infile):
    print('Case #{nc}'.format(nc=ncase + 1))
    W, L, U, G = (int(s) for s in infile.readline().split())
    Lp = [[int(s) for s in infile.readline().split()] for i in xrange(L)]
    return L


def func_02054700d55544478b42e9b9e89ac0ca(Lp, ncase, infile):
    print('Case #{nc}'.format(nc=ncase + 1))
    W, L, U, G = (int(s) for s in infile.readline().split())
    Lp = [[int(s) for s in infile.readline().split()] for i in xrange(L)]
    return G


def func_947c0533be5744958f4bfe8f064a2a61(Lp, ncase, infile):
    print('Case #{nc}'.format(nc=ncase + 1))
    W, L, U, G = (int(s) for s in infile.readline().split())
    Lp = [[int(s) for s in infile.readline().split()] for i in xrange(L)]
    return i


def func_154098a41bec4dfdb03c4488e331d346(Ly, Uy, X):
    Y = Uy - Ly
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    return area


def func_119cdf377a34446489b65815cb8fa1b0(Ly, Uy, X):
    Y = Uy - Ly
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    return Y


def func_9e28664f45ad426ea5464abb2c10bdda(Y, X, G):
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    return NAs


def func_83c5c4d9fce24768b443d8707779be7a(Y, X, G):
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    return area


def func_b8d2303212d1411abe8f1b7731b8c215(Y, X, W, G):

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return area


def func_786c6689b60a439982c75bc980c41591(Y, X, W, G):

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return points


def func_2ca12634fb254c38be3999190921e11c(Y, X, W, G):

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return NA


def func_933ba58dabc946cab8d749e628cb13f8(Y, X, W, G):

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return NAs


def func_5032443b55fc49c386c19c4f27d8d31f(Ly, Uy, X, G):
    Y = Uy - Ly
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    return Y


def func_56b85182ae2a432ebe43cc4137476bab(Ly, Uy, X, G):
    Y = Uy - Ly
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    return area


def func_08eb2639638648dc8e6413685c237454(Ly, Uy, X, G):
    Y = Uy - Ly
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    return NAs


def func_e1563650f1644cd8adc532a3cdb0e48c(Y, X, W, G):
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return points


def func_16c3d286b53a4185a059acb7cdd941b7(Y, X, W, G):
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return area


def func_1beea74415db416c8f122bf52ae540ce(Y, X, W, G):
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return NAs


def func_83c47fbce0804f06bb936b2044fccb53(Y, X, W, G):
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return NA


def func_f86ebe05fa1c4b76a19fe4214980a2e0(Ly, Uy, X, W, G):
    Y = Uy - Ly
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return Y


def func_d474fb9112a84f449df6eccd94f0701a(Ly, Uy, X, W, G):
    Y = Uy - Ly
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return NAs


def func_ec7540897fbc4859bba13c825191236c(Ly, Uy, X, W, G):
    Y = Uy - Ly
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return NA


def func_617d4017aed54cd1a47436ee5f6a9c77(Ly, Uy, X, W, G):
    Y = Uy - Ly
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return area


def func_9798caccb3644af2822a2f2778317aed(Ly, Uy, X, W, G):
    Y = Uy - Ly
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return points

<filename>projects/src/main/python/CodeJam/Y11R5P1/dennislissov/generated_py_bb93a4d1acf540c3b7c8dfd80359bd28.py
import sys
sys.path.append('/home/george2/Raise/ProgramRepair/CodeSeer/projects/src/main/python')
from CodeJam.Y11R5P1.dennislissov.A import *

def func_3ba6780ca418469a885da55554034725(y, x):
    area += (x - px) * (y + py) / 2
    px, py = x, y
    return py


def func_16bfa03b301e43139f8f644e5e7cbce6(y, x):
    area += (x - px) * (y + py) / 2
    px, py = x, y
    return area


def func_5726577868614ce7b084d034f2376af6(y, x):
    area += (x - px) * (y + py) / 2
    px, py = x, y
    return px


def func_dabbc99813184aeea69a2f2d636dea55(ax, px, py):
    y = py + (y - py) / (x - px) * (ax - px)
    x = ax
    return x


def func_d0b5903d9cd747d2b4b964585933d19f(ax, px, py):
    y = py + (y - py) / (x - px) * (ax - px)
    x = ax
    return y


def func_5e4c1430509d4af995186639565f815e():
    px = 0
    py = 0
    return px


def func_1ca08860d10b4cf8aedded11e9dffb1a():
    px = 0
    py = 0
    return py


def func_95288f9c7bff4bf682e6cf6ba68a8ba9():
    py = 0
    area = 0
    return py


def func_f0ab3dbecaef42e5be66cbfb734b7890():
    py = 0
    area = 0
    return area


def func_f2b586b319aa4cb98bfb783ddd7addcb(Y, X, ax):
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return px


def func_23ca7fa984f94fb3bfd7a107f4210e78(Y, X, ax):
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return x


def func_214e65bd98004678b3eeba446027da4f(Y, X, ax):
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return y


def func_daf1c94df0584af692b5f4bcea188648(Y, X, ax):
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return area


def func_b759ad0d09e94f0ca1ec6405fa944e58(Y, X, ax):
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return py


def func_9ed2c74c0e6244e4ab8a4f0968336c03(area, ax, px, py):
    if ax < x:
        y = py + (y - py) / (x - px) * (ax - px)
        x = ax
    return area


def func_970a7c8ba3704e9491127e3947e0f97b():
    px = 0
    py = 0
    area = 0
    return px


def func_92b324bab0d74577a806743dce7beb52():
    px = 0
    py = 0
    area = 0
    return area


def func_e87e2a34f8cf4dd4aac49c50a0e53958():
    px = 0
    py = 0
    area = 0
    return py


def func_0697bf4db790456998f4524105458519(Y, X, ax):
    py = 0
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return py


def func_6f78f82a300f490c91a7d12da591655e(Y, X, ax):
    py = 0
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return x


def func_9faf09f55d8547e697b03888eb6faad5(Y, X, ax):
    py = 0
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return y


def func_8d0048a94dd640f9ae614473ce1fa916(Y, X, ax):
    py = 0
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return area


def func_557dcb3fb31b4f728f8a7bdca9e3e339(Y, X, ax):
    py = 0
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return px


def func_b00db3e3d55f476597b206c0f54ca686(Y, X, ax):
    px = 0
    py = 0
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return py


def func_9796002a7e484de685cf089d82775124(Y, X, ax):
    px = 0
    py = 0
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return y


def func_25a25b6a067440b8abb0cda23274198e(Y, X, ax):
    px = 0
    py = 0
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return area


def func_7b65d97fa3534bcdbedbcad451839552(Y, X, ax):
    px = 0
    py = 0
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return x


def func_f36584730d6b46698e631ec2eaf1e0f6(Y, X, ax):
    px = 0
    py = 0
    area = 0
    for x, y in zip(X, Y):
        if x == px:
            px, py = x, y
            continue
        if ax < x:
            y = py + (y - py) / (x - px) * (ax - px)
            x = ax
        area += (x - px) * (y + py) / 2
        px, py = x, y
        if x == ax:
            break
    return px


def func_c8e909b1d8ef45bb81720100de8be90b(ncase, infile):
    print('Case #{nc}'.format(nc=ncase + 1))
    W, L, U, G = (int(s) for s in infile.readline().split())
    return W


def func_9faea165cee94f6aa49cf54e20f95a12(ncase, infile):
    print('Case #{nc}'.format(nc=ncase + 1))
    W, L, U, G = (int(s) for s in infile.readline().split())
    return G


def func_e80907eba6cf46c6a8137886b8e2c14c(ncase, infile):
    print('Case #{nc}'.format(nc=ncase + 1))
    W, L, U, G = (int(s) for s in infile.readline().split())
    return L


def func_f75d55cd2b1b409db59d7afe7c13087f(ncase, infile):
    print('Case #{nc}'.format(nc=ncase + 1))
    W, L, U, G = (int(s) for s in infile.readline().split())
    return s


def func_c9bb9573097a4c6aae46b4a2cc64276f(ncase, infile):
    print('Case #{nc}'.format(nc=ncase + 1))
    W, L, U, G = (int(s) for s in infile.readline().split())
    return U


def func_9f3ec1b85566455a95126385cf4e1f6c(Lp, infile):
    W, L, U, G = (int(s) for s in infile.readline().split())
    Lp = [[int(s) for s in infile.readline().split()] for i in xrange(L)]
    return i


def func_36e0888b67d74a9399f251b686416a94(Lp, infile):
    W, L, U, G = (int(s) for s in infile.readline().split())
    Lp = [[int(s) for s in infile.readline().split()] for i in xrange(L)]
    return G


def func_d81dfa3ea87e4bd0993037f02057bfab(Lp, infile):
    W, L, U, G = (int(s) for s in infile.readline().split())
    Lp = [[int(s) for s in infile.readline().split()] for i in xrange(L)]
    return U


def func_c2dec506230345dd97211ee64cb98359(Lp, infile):
    W, L, U, G = (int(s) for s in infile.readline().split())
    Lp = [[int(s) for s in infile.readline().split()] for i in xrange(L)]
    return L


def func_7aac99e646d94133aa7e23ab7bf64166(Lp, infile):
    W, L, U, G = (int(s) for s in infile.readline().split())
    Lp = [[int(s) for s in infile.readline().split()] for i in xrange(L)]
    return W


def func_b5c4f36135cf44ed877f852a51ed28df(Lp, infile):
    W, L, U, G = (int(s) for s in infile.readline().split())
    Lp = [[int(s) for s in infile.readline().split()] for i in xrange(L)]
    return s


def func_3cf08fece0a440de9549151f95996078(Ly, Uy, X):
    Y = Uy - Ly
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))
    return area


def func_2d7c562e9b0148198e7fde596a113ed2(Ly, Uy, X):
    Y = Uy - Ly
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))
    return Y


def func_659622b0340743c88c95b497a41a557d(Y, X):
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    return area


def func_396e1081307e40ce8f745bd0f137bf1e(Y, X, G):

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    return NAs


def func_eb77d078893e4f8aa2e7bdbe0984a0d0(Y, X, G):

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    return area


def func_beb781dcbb554bf2aebc9aa2f7370eae(area, W, G):
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return NA


def func_243ebc5672064a3f94074f635acf6021(area, W, G):
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return NAs


def func_4df8196ffbfc4d768e65e55a8edab4eb(area, W, G):
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return points


def func_f54dac81ea4543c2a1e561ea5ae647af(Lp, ncase, infile):
    print('Case #{nc}'.format(nc=ncase + 1))
    W, L, U, G = (int(s) for s in infile.readline().split())
    Lp = [[int(s) for s in infile.readline().split()] for i in xrange(L)]
    return W


def func_03f0a47b81f54349894ae80e3df364cc(Lp, ncase, infile):
    print('Case #{nc}'.format(nc=ncase + 1))
    W, L, U, G = (int(s) for s in infile.readline().split())
    Lp = [[int(s) for s in infile.readline().split()] for i in xrange(L)]
    return U


def func_c6a0c02b9aa94adcae8667d220d24ee3(Lp, ncase, infile):
    print('Case #{nc}'.format(nc=ncase + 1))
    W, L, U, G = (int(s) for s in infile.readline().split())
    Lp = [[int(s) for s in infile.readline().split()] for i in xrange(L)]
    return s


def func_2114f611135a404083fa23b8de1119d5(Lp, ncase, infile):
    print('Case #{nc}'.format(nc=ncase + 1))
    W, L, U, G = (int(s) for s in infile.readline().split())
    Lp = [[int(s) for s in infile.readline().split()] for i in xrange(L)]
    return L


def func_02054700d55544478b42e9b9e89ac0ca(Lp, ncase, infile):
    print('Case #{nc}'.format(nc=ncase + 1))
    W, L, U, G = (int(s) for s in infile.readline().split())
    Lp = [[int(s) for s in infile.readline().split()] for i in xrange(L)]
    return G


def func_947c0533be5744958f4bfe8f064a2a61(Lp, ncase, infile):
    print('Case #{nc}'.format(nc=ncase + 1))
    W, L, U, G = (int(s) for s in infile.readline().split())
    Lp = [[int(s) for s in infile.readline().split()] for i in xrange(L)]
    return i


def func_154098a41bec4dfdb03c4488e331d346(Ly, Uy, X):
    Y = Uy - Ly
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    return area


def func_119cdf377a34446489b65815cb8fa1b0(Ly, Uy, X):
    Y = Uy - Ly
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    return Y


def func_9e28664f45ad426ea5464abb2c10bdda(Y, X, G):
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    return NAs


def func_83c5c4d9fce24768b443d8707779be7a(Y, X, G):
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    return area


def func_b8d2303212d1411abe8f1b7731b8c215(Y, X, W, G):

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return area


def func_786c6689b60a439982c75bc980c41591(Y, X, W, G):

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return points


def func_2ca12634fb254c38be3999190921e11c(Y, X, W, G):

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return NA


def func_933ba58dabc946cab8d749e628cb13f8(Y, X, W, G):

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return NAs


def func_5032443b55fc49c386c19c4f27d8d31f(Ly, Uy, X, G):
    Y = Uy - Ly
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    return Y


def func_56b85182ae2a432ebe43cc4137476bab(Ly, Uy, X, G):
    Y = Uy - Ly
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    return area


def func_08eb2639638648dc8e6413685c237454(Ly, Uy, X, G):
    Y = Uy - Ly
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    return NAs


def func_e1563650f1644cd8adc532a3cdb0e48c(Y, X, W, G):
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return points


def func_16c3d286b53a4185a059acb7cdd941b7(Y, X, W, G):
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return area


def func_1beea74415db416c8f122bf52ae540ce(Y, X, W, G):
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return NAs


def func_83c47fbce0804f06bb936b2044fccb53(Y, X, W, G):
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return NA


def func_f86ebe05fa1c4b76a19fe4214980a2e0(Ly, Uy, X, W, G):
    Y = Uy - Ly
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return Y


def func_d474fb9112a84f449df6eccd94f0701a(Ly, Uy, X, W, G):
    Y = Uy - Ly
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return NAs


def func_ec7540897fbc4859bba13c825191236c(Ly, Uy, X, W, G):
    Y = Uy - Ly
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return NA


def func_617d4017aed54cd1a47436ee5f6a9c77(Ly, Uy, X, W, G):
    Y = Uy - Ly
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return area


def func_9798caccb3644af2822a2f2778317aed(Ly, Uy, X, W, G):
    Y = Uy - Ly
    area = sum((Y[1:] + Y[:-1]) / 2 * (X[1:] - X[:-1]))

    def cumul_area(ax):
        px = 0
        py = 0
        area = 0
        for x, y in zip(X, Y):
            if x == px:
                px, py = x, y
                continue
            if ax < x:
                y = py + (y - py) / (x - px) * (ax - px)
                x = ax
            area += (x - px) * (y + py) / 2
            px, py = x, y
            if x == ax:
                break
        return area
    NAs = np.arange(1, G, dtype='float') * area / G
    points = [bisect(lambda x: cumul_area(x) - NA, 0, W) for NA in NAs]
    return points

#{nc}'.format(nc=ncase + 1)) #{nc}'.format(nc=ncase + 1)) #{nc}'.format(nc=ncase + 1)) #{nc}'.format(nc=ncase + 1)) #{nc}'.format(nc=ncase + 1)) #{nc}'.format(nc=ncase + 1)) #{nc}'.format(nc=ncase + 1)) #{nc}'.format(nc=ncase + 1)) #{nc}'.format(nc=ncase + 1)) #{nc}'.format(nc=ncase + 1)) #{nc}'.format(nc=ncase + 1))