В НИИ метеорологии решили изучить процесс образования водоемов на различных рельефах местности во время дождя

# file = open('input.txt', encoding='utf-8')
# input = lambda: file.readline().rstrip()
 
n, H = input().split()
n, H = int(n), float(H)
p = [(*map(float, input().split()), ) for _ in range(n + 1)]
w = p[-1][0] - p[0][0]   # lake width
b = min(y for x, y in p) # lake bottom
t = max(y for x, y in p) # lake top
s = []
 
from itertools import pairwise
for (x1, y1), (x2, y2) in pairwise(p):
    if y1 > y2: y1, y2 = y2, y1
    s.append((y1 - b, y2 - b, x2 - x1, y2 - y1))
 
def g(y1, y2, dx, dy, h):
    # area of segment (trapezoid or rectangle or empty)
    return \
        0 if h < y1 else \
        (h - y2 + dy / 2) * dx if y2 < h else \
        (h - y1) * (h - y1) * dx / dy / 2
 
def f(h): 
    # total area of lake
    return sum(g(*si, h) for si in s)
 
# binary search
hl, hr = 0, t - b + H
while 1e-10 < abs(hl - hr):
    h = (hl + hr) / 2
    if f(h) < H * w: hl = h
    else: hr = h
 
print(h := (hl + hr) / 2)
 
# print(f(h), f(h)/w)             # 119 7
# print(f(15.8446), f(15.8446)/w) # 104 6 - WTF???

class Math:
    eps = 1e-7
 
    @staticmethod
    def eq(x: float, y: float):
        return abs(x - y) < Math.eps
    
    @staticmethod
    def le(x: float, y: float):
        return x - Math.eps < y
    
class Point:
    def __init__(p, x: float, y: float):
        p.x, p.y = x, y
 
    def __repr__(p):
        return f'({p.x}, {p.y})'
 
class Line:
    def __init__(l, a: Point, b: Point):
        l.a, l.b = a, b
 
    def by_y(l, y: float):
        dx, dy = l.a.x - l.b.x, l.a.y - l.b.y
        return Point(l.a.x + (y - l.a.y) * dx / dy, y)
    
    def __repr__(p):
        return f'L[{p.a} - {p.b}]'
    
class Trapezoid:
    def __init__(t, left: Line, right: Line):
        t.left, t.right = left, right
    
    def area(t, bottom_y: float, top_y: float):
        '''Площадь по двум основаниям'''
        dy = top_y - bottom_y
        s0 = t.right.by_y(bottom_y).x - t.left.by_y(bottom_y).x
        s1 = t.right.by_y(top_y).x - t.left.by_y(top_y).x
        return max(0, (s0 + s1) * dy / 2)
    
    def height(t, bottom_y: float, area: float):
        '''Высота по основанию и площади'''
        # можно вывести закрытую формулу
        # но прямые left и right могут быть параллельными
        hl, hr = 0, 1
        while t.area(bottom_y, bottom_y + hr) < area: hr *= 2
        while not Math.eq(hl, hr):
            h = (hl + hr) / 2
            if t.area(bottom_y, bottom_y + h) < area: hl = h
            else: hr = h
        return (hl + hr) / 2
 
class Lake:
    @property
    def is_overflown(lake) -> bool:
        raise NotImplemented
    
    @property
    def width(lake) -> float: 
        raise NotImplemented
    
    @property
    def wall_left(lake) -> Line:
        raise NotImplemented
    
    @property
    def wall_right(lake) -> Line:
        raise NotImplemented
    
    @property
    def empty_left_wall(lake) -> list[Point]:
        raise NotImplemented
    
    @property
    def empty_right_wall(lake) -> list[Point]:
        raise NotImplemented
    
    @property
    def threshold(lake) -> float:
        '''Объем, после наливания которого меняется динамика'''
        raise NotImplemented
    
    def pour(lake, volume):
        '''Налить сверху объем меньший порогового значения'''
        raise NotImplemented
    
    def pour_from_left(lake, volume): 
        '''Перелить из чаши слева объем меньший порогового значения'''
        raise NotImplemented
 
    def pour_from_right(lake, volume):
        '''Перелить из чаши справа объем меньший порогового значения'''
        raise NotImplemented
    
    def pour_big_volume(lake, volume):
        while not (Math.le(volume, 0) or Math.le(th := lake.threshold, 0)):
            dv = min(volume, th)
            lake.pour(dv)
            volume -= dv
        return volume
 
    def find_max_deep(lake) -> float:
        '''Максимальная глубина жидкости среди всех чашек'''
        raise NotImplemented
    
    def find_bottom(lake) -> Point:
        '''Самая нижняя точка'''
        raise NotImplemented
    
    def find_volume(lake) -> float:
        '''Общий объем влитой жидкости'''
        raise NotImplemented
    
    @staticmethod
    def build(points: list[Point]) -> 'Lake':
        # несложно заменить на линейный алгоритм со стеком
 
        # ищем локальный максимум по Y,
        # т.к. все Y различны, то он либо единственный либо его нет
        local_max = None
        for i in range(1, len(points) - 1):
            if points[i-1].y < points[i].y > points[i+1].y and \
                not (local_max and points[local_max].y > points[i].y):
                local_max = i
 
        # если локальный максимум существует, то создаем пару чашек
        return (LakePair(
                    Lake.build(points[:local_max + 1]), 
                    Lake.build(points[local_max:])) 
                if local_max else LakeCup(points))
 
class LakeCup(Lake):
    '''Модель выпуклого вниз озера.'''
 
    def __init__(cup, points: list[Point]):
        cup.points = points
        cup.bottom_idx = 0      # любая точка с наименьшим y
        cup.wall_left_idx = 0   # левая точка с наименьшим y
        cup.wall_right_idx = 0  # правая точка с наименьшим y
        for i, pi in enumerate(points): # просто поиск минимумов в массиве
            if pi.y < points[cup.bottom_idx].y: cup.bottom_idx = i
            if not (Math.le(points[cup.wall_left_idx].y, pi.y)): cup.wall_left_idx = i
            if Math.le(pi.y, points[cup.wall_right_idx].y): cup.wall_right_idx = i
 
        cup.water = cup.bottom.y
        cup.volume = 0
 
    @property
    def width(cup): 
        return cup.points[-1].x - cup.points[0].x
    
    @property
    def bottom(cup): 
        return cup.points[cup.bottom_idx]
    
    @property
    def is_overflown(cup):
        top = min(cup.points[0].y, cup.points[-1].y)
        return Math.le(top, cup.water)
 
    @property
    def wall_left(cup):
        return Line(
            cup.points[cup.wall_left_idx - 1], 
            cup.points[cup.wall_left_idx])
    
    @property
    def wall_right(cup):
        return Line(
            cup.points[cup.wall_right_idx], 
            cup.points[cup.wall_right_idx + 1])
    
    @property
    def threshold(cup):
        yl = cup.points[cup.wall_left_idx - 1].y
        yr = cup.points[cup.wall_right_idx + 1].y
        t = Trapezoid(cup.wall_left, cup.wall_right)
        return t.area(cup.water, min(yl, yr))
    
    def pour(cup, volume):
        t = Trapezoid(cup.wall_left, cup.wall_right)
        cup.water += t.height(cup.water, volume)
        cup.wall_left_idx -= Math.le(cup.wall_left.a.y, cup.water)
        cup.wall_left_idx = max(1, cup.wall_left_idx)
        cup.wall_right_idx += Math.le(cup.wall_right.b.y, cup.water)
        cup.wall_right_idx = min(len(cup.points) - 2, cup.wall_right_idx)
        cup.volume += volume
 
    def pour_from_left(cup, volume):
        cup.pour(volume)
        cup.volume += volume
 
    def pour_from_right(cup, volume):
        cup.pour(volume)
        cup.volume += volume
 
    @property
    def empty_left_wall(cup):
        return cup.points[:cup.wall_left_idx] + \
            [cup.wall_left.by_y(cup.water)]
    
    @property
    def empty_right_wall(cup):
        return [cup.wall_right.by_y(cup.water)] + \
            cup.points[cup.wall_right_idx + 1:]
    
    def find_max_deep(cup):
        return cup.water - cup.bottom.y
    
    def find_bottom(cup):
        return cup.bottom
    
    def find_volume(cup):
        return cup.volume
 
class LakePair(Lake):
    '''Модель озера из двух смежных чаш. 
    Жидкость сначала наливается в обе пропорционально
    ширине чаш, затем одна из пустых или идет перелив 
    из меньшей в большую (методами pour_from_left/right). 
    После того как уровень воды в обоих сравняется создаётся
    вспомогательная "надчаша", и заполняется она'''
 
    def __init__(pair, left: Lake, right: Lake):
        pair.left, pair.right = left, right
        pair.overcup: LakeCup = None
 
    @property
    def is_overflown(pair):
        return pair.overcup and pair.overcup.is_overflown
    
    @property
    def width(pair): 
        return pair.left.width + pair.right.width
    
    @property
    def wall_left(pair):
        return pair.overcup and pair.overcup.wall_left \
            or pair.left.wall_left
    
    @property
    def wall_right(pair):
        return pair.overcup and pair.overcup.wall_right \
            or pair.right.wall_right
    
    @property
    def ratio(pair):
        wl, wr = pair.left.width, pair.right.width
        return wl / (wl + wr), wr / (wl + wr)
    
    @property
    def threshold(pair):
        if pair.overcup: return pair.overcup.threshold
        if pair.left.is_overflown: return pair.right.threshold
        if pair.right.is_overflown: return pair.left.threshold
        tl, tr = pair.left.threshold, pair.right.threshold
        ql, qr = pair.ratio
        return min(tl / ql, tr / qr)
    
    def pour(pair, volume):
        if pair.overcup: return pair.overcup.pour(volume)
        if pair.left.is_overflown: pair.right.pour(volume)
        elif pair.right.is_overflown: pair.left.pour(volume)
        else:
            ql, qr = pair.ratio
            pair.left.pour(ql * volume)
            pair.right.pour(qr * volume)
        pair.update_overcup()
 
    def pour_from_left(pair, volume):
        if pair.overcup: return pair.overcup.pour_from_left(volume)
        if pair.left.is_overflown: pair.right.pour_from_left(volume)
        else: pair.left.pour_from_left(volume)
        pair.update_overcup()
 
    def pour_from_right(pair, volume):
        if pair.overcup: return pair.overcup.pour_from_right(volume)
        if pair.right.is_overflown: pair.left.pour_from_right(volume)
        else: pair.right.pour_from_right(volume)
        pair.update_overcup()
 
    def update_overcup(pair):
        if not pair.left.is_overflown: return
        if not pair.right.is_overflown: return
        pair.overcup = LakeCup(
            pair.empty_left_wall + 
            pair.empty_right_wall
        )
 
    @property
    def empty_left_wall(pair):
        cup = pair.overcup or pair.left
        return cup.empty_left_wall
    
    @property
    def empty_right_wall(pair):
        cup = pair.overcup or pair.right
        return cup.empty_right_wall
    
    def find_max_deep(pair):
        h1 = max(pair.left.find_max_deep(), pair.right.find_max_deep())
        h2 = pair.overcup.find_max_deep() if pair.overcup else 0
        return h1 + h2
    
    def find_bottom(pair):
        return min(
            pair.left.find_bottom(),
            pair.right.find_bottom(),
            key = lambda p: p.y)
    
    def find_volume(pair):
        v1 = pair.left.find_volume()
        v2 = pair.right.find_volume()
        v3 = pair.overcup.find_volume() if pair.overcup else 0
        return v1 + v2 + v3

import pygame as pg
import random as rnd
 
class Model:
    def __init__(m, points: list[tuple[float, float]]):
        lx, ux = min(x for x,y in points), max(x for x,y in points)
        ly, uy = min(y for x,y in points), max(y for x,y in points)
        uy += max(1, (uy - ly)) * 0.2
        m.points = ((points[0][0], uy), *points, (points[-1][0], uy))
        m.points = [Point(x, y) for x, y in m.points]
        m.bounds = pg.Rect(lx, ly, ux - lx, uy - ly)
        m.lake = Lake.build(m.points)
 
    @staticmethod
    def random():
        k = rnd.randrange(5, 20)
        x = rnd.sample(range(100), k)
        y = rnd.sample(range(100), k)
        x.sort()
        return Model([*zip(x, y)])
 
class PGWnd:
    def __init__(wnd, size = (550, 400), margin = 30, fps = 60, style=pg.RESIZABLE):
        if pg.init()[1]: raise Exception
        wnd.model: Model = None
        wnd.clock = pg.time.Clock()
        wnd.screen = pg.display.set_mode(size, style)
        wnd.font = pg.font.SysFont(pg.font.get_default_font(), 20)
        wnd.margin = margin
        wnd.fps = fps
 
    def to_screen(wnd, p: Point):
        x, y = p.x, p.y
        rx = (wnd.screen.get_width() - 2 * wnd.margin) / wnd.model.bounds.width
        ry = (wnd.screen.get_height() - 2 * wnd.margin) / wnd.model.bounds.height
        x = wnd.margin + (x - wnd.model.bounds.left) * rx
        y = wnd.screen.get_height() - wnd.margin - (y - wnd.model.bounds.top) * ry
        return x, y
 
    def run(wnd):
        while not pg.event.get(pg.QUIT):
            wnd.screen.fill(0x1f1f1f)
            wnd.draw_model()
            pg.display.update()
            wnd.update_model()
            wnd.clock.tick(wnd.fps)
            
    def update_model(wnd):
        full_rect_volume_per_second = 20
        w, h = wnd.model.bounds.size
        dv = h * w / full_rect_volume_per_second / wnd.fps
        left = wnd.model.lake.pour_big_volume(dv)
        if left > 0: wnd.model = Model.random()
 
    def draw_poly(wnd, points: list[Point], color=0, line_color=0, width=1, closed=True):
        points = [*map(wnd.to_screen, points)]
        if closed: pg.draw.polygon(wnd.screen, color, points)
        if width: pg.draw.lines(wnd.screen, line_color, closed, points, width) 
 
    def draw_model(wnd):
        if not wnd.model: return
        wnd.draw_lake(wnd.model.lake)
        wnd.draw_deeps(wnd.model.lake)
        wnd.draw_poly(wnd.model.points, line_color=0xffffff, closed=False, width=3)
        wnd.draw_statictics()
 
    def draw_lake(wnd, lake: Lake):
        match lake:
            case LakeCup(): wnd.draw_cup(lake)
            case LakePair(): wnd.draw_pair(lake)
            
    def draw_pair(wnd, pair: LakePair):
        wnd.draw_lake(pair.left)
        wnd.draw_lake(pair.right)
        if not pair.overcup: return
        wnd.draw_cup(pair.overcup)
 
    def draw_cup(wnd, cup: LakeCup):
        if not cup.water: return
        points = [
            cup.wall_left.by_y(cup.water),
            *cup.points[cup.wall_left_idx : cup.wall_right_idx + 1],
            cup.wall_right.by_y(cup.water)]
        wnd.draw_poly(points, 0x1177AE, width=0, closed=True)
 
    def draw_deeps(wnd, lake: Lake):
        if isinstance(lake, LakePair):
            if lake.overcup: 
                wnd.draw_deep(lake.overcup.water, lake)
            else:
                wnd.draw_deeps(lake.left)
                wnd.draw_deeps(lake.right)
        elif isinstance(lake, LakeCup):
            wnd.draw_deep(lake.water, lake)
 
    def draw_deep(wnd, water: float, lake: Lake):
        deep = lake.find_max_deep()
        bottom = lake.find_bottom() 
        b = wnd.to_screen(bottom)
        t = wnd.to_screen(Point(bottom.x, water))
        pg.draw.line(wnd.screen, 0xffffff, b, t)
 
        text = wnd.font.render(f'{deep:.2f}', True, 0xffffffff)
        text_rect = text.get_rect()
        text_rect.midbottom = t
        wnd.screen.blit(text, text_rect)
 
    def draw_statictics(wnd):
        volume = wnd.model.lake.find_volume()
        max_deep = wnd.model.lake.find_max_deep()
        text1 = wnd.font.render(f'volume: {volume:13.4f}', True, 0xFFED00ff)
        text2 = wnd.font.render(f'max_deep: {max_deep:9.4f}', True, 0xFFED00ff)
        rc1, rc2 = text1.get_rect(), text2.get_rect()
        w, h, m = *wnd.screen.get_size(), wnd.margin
        rc2.bottomleft = m, h - m
        rc1.bottomleft = rc2.topleft
        wnd.screen.blit(text1, rc1)
        wnd.screen.blit(text2, rc2)
 
wnd = PGWnd()
wnd.model = Model([(-5, 10), (-3, 4), (-1, 6), (1, -4), (4, 17), (5, 3), (9, 5), (12, 15)])
wnd.model = Model.random()
wnd.run()

h, line = 7.00, [(-5, 10), (-3, 4), (-1, 6), (1, -4), (4, 17), (5, 3), (9, 5), (12, 15)]
 
big_y = max(y for x, y in line) + 1e7
line = (line[0][0], big_y), *line, (line[-1][0], big_y)
lake = Lake.build([Point(x, y) for x, y in line])
lake.pour_big_volume(lake.width * h)
print(lake.find_max_deep()) # 15.844619423151016