// https://contest.ucup.ac/contest/1828/problem/9576
pub mod solution {
//{"name":"M. Ordainer of Inexorable Judgment","group":"Universal Cup - The 3rd Universal Cup. Stage 16: Nanjing","url":"https://contest.ucup.ac/contest/1828/problem/9576","interactive":false,"timeLimit":1000,"tests":[{"input":"3 1 0 1 1\n1 2\n2 1\n2 2\n","output":"1.000000000000\n"},{"input":"3 1 0 1 2\n1 2\n2 1\n2 2\n","output":"1.570796326795\n"},{"input":"3 1 0 1 10000\n1 2\n2 1\n2 2\n","output":"2500.707752257475\n"}],"testType":"single","input":{"type":"stdin","fileName":null,"pattern":null},"output":{"type":"stdout","fileName":null,"pattern":null},"languages":{"java":{"taskClass":"MOrdainerOfInexorableJudgment"}}}

use crate::algo_lib::collections::min_max::MinimMaxim;
use crate::algo_lib::geometry::circle::Circle;
use crate::algo_lib::geometry::geometry_utils::canonize_angle;
use crate::algo_lib::geometry::geometry_utils::canonize_angle_base;
use crate::algo_lib::geometry::point::Point;
use crate::algo_lib::geometry::ray::Ray;
use crate::algo_lib::io::input::Input;
use crate::algo_lib::io::output::Output;
use crate::algo_lib::misc::test_type::TaskType;

use crate::algo_lib::misc::test_type::TestType;
use crate::algo_lib::numbers::num_traits::algebra::Zero;
use crate::algo_lib::numbers::real::Real;
use crate::algo_lib::numbers::real::RealReader;

type PreCalc = ();

fn solve(input: &mut Input, out: &mut Output, _test_case: usize, _data: &mut PreCalc) {
    let n = input.read_size();
    let dir = input.read::<Point<Real>>().angle();
    let d = input.read_real();
    let mut t = input.read_real();
    let points = input.read_vec::<Point<Real>>(n);

    let circle = Circle::new(Point::origin(), d);
    let base_dir = points[0].angle();
    let mut max_angle = base_dir;
    let mut min_angle = base_dir;

    for p in points {
        let tangent = circle.tangent_points(p);
        for t in tangent {
            let angle = Ray::new(t, p).angle();
            let delta = canonize_angle(angle - base_dir);
            if delta > 0. {
                max_angle.maxim(base_dir + delta);
            } else {
                min_angle.minim(base_dir + delta);
            }
        }
    }
    let span = max_angle - min_angle;
    let mut dir = canonize_angle_base(dir - min_angle, Real::zero());
    let mut ans = Real::zero();
    if dir < span {
        let rotate = (span - dir).min(t);
        t -= rotate;
        ans += rotate;
        dir = span;
    }
    while t > 0. {
        let rotate = (2. * Real::PI - dir).min(t);
        t -= rotate;
        let rotate = span.min(t);
        t -= rotate;
        ans += rotate;
        dir = span;
    }
    out.print_line(ans);
}

pub static TEST_TYPE: TestType = TestType::Single;
pub static TASK_TYPE: TaskType = TaskType::Classic;

pub(crate) fn run(mut input: Input, mut output: Output) -> bool {
    let mut pre_calc = ();

    match TEST_TYPE {
        TestType::Single => solve(&mut input, &mut output, 1, &mut pre_calc),
        TestType::MultiNumber => {
            let t = input.read();
            for i in 1..=t {
                solve(&mut input, &mut output, i, &mut pre_calc);
            }
        }
        TestType::MultiEof => {
            let mut i = 1;
            while input.peek().is_some() {
                solve(&mut input, &mut output, i, &mut pre_calc);
                i += 1;
            }
        }
    }
    output.flush();
    match TASK_TYPE {
        TaskType::Classic => input.is_empty(),
        TaskType::Interactive => true,
    }
}

}
pub mod algo_lib {
pub mod collections {
pub mod iter_ext {
pub mod find_count {
pub trait IterFindCount<T: PartialEq>: Iterator<Item = T> + Sized {
    fn find_eq(mut self, item: T) -> Option<usize> {
        self.position(|r| r == item)
    }
    fn count_eq(self, item: &T) -> usize {
        self.filter(|r| r == item).count()
    }
}

impl<T: PartialEq, I: Iterator<Item = T>> IterFindCount<T> for I {}
}
}
pub mod min_max {
pub trait MinimMaxim<Rhs = Self>: PartialOrd + Sized {
    fn minim(&mut self, other: Rhs) -> bool;

    fn maxim(&mut self, other: Rhs) -> bool;
}

impl<T: PartialOrd> MinimMaxim for T {
    fn minim(&mut self, other: Self) -> bool {
        if other < *self {
            *self = other;
            true
        } else {
            false
        }
    }

    fn maxim(&mut self, other: Self) -> bool {
        if other > *self {
            *self = other;
            true
        } else {
            false
        }
    }
}

impl<T: PartialOrd> MinimMaxim<T> for Option<T> {
    fn minim(&mut self, other: T) -> bool {
        match self {
            None => {
                *self = Some(other);
                true
            }
            Some(v) => v.minim(other),
        }
    }

    fn maxim(&mut self, other: T) -> bool {
        match self {
            None => {
                *self = Some(other);
                true
            }
            Some(v) => v.maxim(other),
        }
    }
}
}
pub mod vec_ext {
pub mod default {
pub fn default_vec<T: Default>(len: usize) -> Vec<T> {
    let mut v = Vec::with_capacity(len);
    for _ in 0..len {
        v.push(T::default());
    }
    v
}
}
}
}
pub mod geometry {
pub mod base {
use crate::algo_lib::numbers::num_traits::algebra::Ring;

pub trait Base: Copy + Ring + 'static {}

impl<T: Copy + Ring + 'static> Base for T {}
}
pub mod circle {
use crate::algo_lib::geometry::base::Base;
use crate::algo_lib::geometry::line::Line;
use crate::algo_lib::geometry::point::Point;
use crate::algo_lib::numbers::real::Real;

pub struct Circle<T> {
    pub center: Point<T>,
    pub radius: T,
}

impl<T> Circle<T> {
    pub fn new(center: Point<T>, radius: T) -> Self {
        Circle { center, radius }
    }
}

impl<T: Base + Ord> Circle<T> {
    pub fn contains(&self, point: Point<T>) -> bool {
        self.center.square_dist_point(point) <= self.radius * self.radius
    }
}

impl Circle<Real> {
    pub fn intersect_line(&self, l: Line<Real>) -> Vec<Point<Real>> {
        let dist = l.dist_point(self.center);
        if dist > self.radius {
            return vec![];
        }
        let perp = l.perpendicular(self.center);
        let base = l.intersect(perp);
        if dist == self.radius {
            return vec![base];
        }
        let delta = (self.radius * self.radius - dist * dist).sqrt();
        vec![
            base + Point::new(perp.a, perp.b) * delta,
            base - Point::new(perp.a, perp.b) * delta,
        ]
    }

    pub fn intersect_circle(&self, d: Circle<Real>) -> Vec<Point<Real>> {
        let dist = self.center.dist_point(d.center);
        if dist == 0. {
            return vec![];
        }
        let a = 2. * (d.center.x - self.center.x);
        let b = 2. * (d.center.y - self.center.y);
        let f = d.radius * d.radius - self.radius * self.radius + self.center.value_square()
            - d.center.value_square();
        let l = Line::new(a, b, f);
        self.intersect_line(l)
    }

    pub fn tangent_points(&self, p: Point<Real>) -> Vec<Point<Real>> {
        let dist = self.center.dist_point(p);
        if dist < self.radius {
            return vec![];
        }
        if dist == self.radius {
            return vec![p];
        }
        let power = Circle::new(p, ((dist - self.radius) * (dist + self.radius)).sqrt());
        self.intersect_circle(power)
    }
}
}
pub mod geometry_utils {
use crate::algo_lib::numbers::num_traits::algebra::Zero;
use crate::algo_lib::numbers::real::Real;

pub fn canonize_angle(angle: Real) -> Real {
    canonize_angle_base(angle, Real::zero() - Real::PI)
}

pub fn canonize_angle_base(angle: Real, base: Real) -> Real {
    let two = 2.;
    let mut angle = angle;
    while angle < base - Real::epsilon() {
        angle += Real::PI * two;
    }
    while angle > base + Real::PI * two - Real::epsilon() {
        angle -= Real::PI * two;
    }
    angle
}
}
pub mod line {
use crate::algo_lib::geometry::base::Base;
use crate::algo_lib::geometry::point::Point;
use crate::algo_lib::numbers::num_traits::algebra::Field;
use crate::algo_lib::numbers::real::IntoReal;
use crate::algo_lib::numbers::real::Real;
use std::any::Any;
use std::any::TypeId;

#[derive(Copy, Clone, Ord, PartialOrd, Hash)]
#[allow(clippy::derived_hash_with_manual_eq)]
pub struct Line<T: Base> {
    pub a: T,
    pub b: T,
    pub c: T,
}

impl<T: Base> Line<T> {
    pub fn new(a: T, b: T, c: T) -> Self {
        if a.type_id() == TypeId::of::<Real>() {
            let a = *(&a as &dyn Any).downcast_ref::<Real>().unwrap();
            let b = *(&b as &dyn Any).downcast_ref::<Real>().unwrap();
            let c = *(&c as &dyn Any).downcast_ref::<Real>().unwrap();
            let h = Real::hypot(a, b);
            let a = a / h;
            let b = b / h;
            let c = c / h;
            Self {
                a: *(&a as &dyn Any).downcast_ref::<T>().unwrap(),
                b: *(&b as &dyn Any).downcast_ref::<T>().unwrap(),
                c: *(&c as &dyn Any).downcast_ref::<T>().unwrap(),
            }
        } else {
            Self { a, b, c }
        }
    }
}

impl<T: Base> Line<T> {
    pub fn value(&self, p: Point<T>) -> T {
        self.a * p.x + self.b * p.y + self.c
    }

    pub fn parallel(&self, p: Point<T>) -> Line<T> {
        Line::new(self.a, self.b, T::zero() - self.a * p.x - self.b * p.y)
    }

    pub fn perpendicular(&self, p: Point<T>) -> Line<T> {
        Line::new(-self.b, self.a, self.b * p.x - self.a * p.y)
    }

    pub fn is_parallel(&self, other: Line<T>) -> bool {
        self.a * other.b == self.b * other.a
    }

    pub fn is_perpendicular(&self, other: Line<T>) -> bool {
        self.a * other.a + self.b * other.b == T::zero()
    }
}

impl<T: Base> Eq for Line<T> {}

impl<T: Base> PartialEq for Line<T> {
    fn eq(&self, other: &Self) -> bool {
        self.a * other.b == self.b * other.a && self.b * other.c == self.c * other.b
    }
}

impl<T: Field + Base> Line<T> {
    pub fn intersect(&self, other: Line<T>) -> Point<T> {
        let det = self.a * other.b - other.a * self.b;
        let x = (self.b * other.c - other.b * self.c) / det;
        let y = (other.a * self.c - self.a * other.c) / det;
        Point::new(x, y)
    }

    pub fn square_dist_point(&self, p: Point<T>) -> T {
        let val = self.value(p);
        val * val / (self.a * self.a + self.b * self.b)
    }
}

impl<T: Field + Base + IntoReal> Line<T> {
    pub fn dist_point(&self, p: Point<T>) -> Real {
        self.square_dist_point(p).into_real().sqrt()
    }
}

impl<T: Base + PartialEq> Line<T> {
    pub fn contains(&self, p: Point<T>) -> bool {
        self.value(p) == T::zero()
    }
}
}
pub mod point {
use crate::algo_lib::geometry::base::Base;
use crate::algo_lib::geometry::geometry_utils::canonize_angle;
use crate::algo_lib::geometry::line::Line;
use crate::algo_lib::io::input::Input;
use crate::algo_lib::io::input::Readable;
use crate::algo_lib::io::output::Output;
use crate::algo_lib::io::output::Writable;
use crate::algo_lib::numbers::num_traits::algebra::Zero;
use crate::algo_lib::numbers::real::IntoReal;
use crate::algo_lib::numbers::real::Real;
use std::ops::Add;
use std::ops::AddAssign;
use std::ops::Div;
use std::ops::DivAssign;
use std::ops::Mul;
use std::ops::MulAssign;
use std::ops::Sub;
use std::ops::SubAssign;

#[derive(Copy, Clone, Hash, Ord, PartialOrd, Eq, PartialEq)]
pub struct Point<T> {
    pub x: T,
    pub y: T,
}

impl<T> Point<T> {
    pub fn new(x: T, y: T) -> Self {
        Self { x, y }
    }
}

impl<T: Zero> Point<T> {
    pub fn origin() -> Self {
        Self::new(T::zero(), T::zero())
    }
}

impl<T: Base> Point<T> {
    pub fn square_dist_point(&self, p: Self) -> T {
        let delta = *self - p;
        delta * delta
    }

    pub fn line(&self, p: Self) -> Line<T> {
        let a = self.y - p.y;
        let b = p.x - self.x;
        Line::new(a, b, T::zero() - a * self.x - b * self.y)
    }

    pub(crate) fn value_square(&self) -> T {
        *self * *self
    }
}

impl<T: Base + IntoReal> Point<T> {
    pub fn dist_point(&self, p: Self) -> Real {
        self.square_dist_point(p).into_real().sqrt()
    }
}

impl Point<Real> {
    pub fn from_polar(r: Real, alpha: Real) -> Self {
        Self::new(r * alpha.cos(), r * alpha.sin())
    }

    pub fn angle(&self) -> Real {
        Real::atan2(self.y, self.x)
    }

    pub fn angle_to(&self, p: Self) -> Real {
        canonize_angle(p.angle() - self.angle()).abs()
    }

    pub fn value(&self) -> Real {
        Real::hypot(self.x, self.y)
    }
}

impl<T: AddAssign> Add for Point<T> {
    type Output = Point<T>;

    fn add(mut self, rhs: Self) -> Self::Output {
        self += rhs;
        self
    }
}

impl<T: AddAssign> AddAssign for Point<T> {
    fn add_assign(&mut self, rhs: Self) {
        self.x += rhs.x;
        self.y += rhs.y;
    }
}

impl<T: SubAssign> Sub for Point<T> {
    type Output = Point<T>;

    fn sub(mut self, rhs: Self) -> Self::Output {
        self -= rhs;
        self
    }
}

impl<T: SubAssign> SubAssign for Point<T> {
    fn sub_assign(&mut self, rhs: Self) {
        self.x -= rhs.x;
        self.y -= rhs.y;
    }
}

impl<T: MulAssign + Copy> MulAssign<T> for Point<T> {
    fn mul_assign(&mut self, rhs: T) {
        self.x *= rhs;
        self.y *= rhs;
    }
}

impl<T: MulAssign + Copy> Mul<T> for Point<T> {
    type Output = Point<T>;

    fn mul(mut self, rhs: T) -> Self::Output {
        self *= rhs;
        self
    }
}

impl<T: DivAssign + Copy> DivAssign<T> for Point<T> {
    fn div_assign(&mut self, rhs: T) {
        self.x /= rhs;
        self.y /= rhs;
    }
}

impl<T: DivAssign + Copy> Div<T> for Point<T> {
    type Output = Point<T>;

    fn div(mut self, rhs: T) -> Self::Output {
        self /= rhs;
        self
    }
}

impl<T: Mul<Output = U>, U: Add> Mul for Point<T> {
    type Output = U::Output;

    fn mul(self, rhs: Self) -> Self::Output {
        self.x * rhs.x + self.y * rhs.y
    }
}

impl<T: Writable> Writable for Point<T> {
    fn write(&self, output: &mut Output) {
        self.x.write(output);
        ' '.write(output);
        self.y.write(output);
    }
}

impl<T: Readable> Readable for Point<T> {
    fn read(input: &mut Input) -> Self {
        let x = input.read();
        let y = input.read();
        Self::new(x, y)
    }
}
}
pub mod ray {
use crate::algo_lib::geometry::base::Base;
use crate::algo_lib::geometry::line::Line;
use crate::algo_lib::geometry::point::Point;
use crate::algo_lib::numbers::num_traits::algebra::Field;
use crate::algo_lib::numbers::num_traits::algebra::One;
use crate::algo_lib::numbers::real::IntoReal;
use crate::algo_lib::numbers::real::Real;

pub struct Ray<T> {
    pub origin: Point<T>,
    pub direction: Point<T>,
}

impl<T> Ray<T> {
    pub fn new(origin: Point<T>, direction: Point<T>) -> Self {
        Self { origin, direction }
    }
}

impl<T: Base> Ray<T> {
    pub fn line(&self) -> Line<T> {
        self.origin.line(self.direction)
    }
}

impl<T: Base + Ord> Ray<T> {
    pub fn contains(&self, p: Point<T>) -> bool {
        if p == self.origin {
            return true;
        }
        let line = self.line();
        if !line.contains(p) {
            return false;
        }
        if self.direction.x != self.origin.x
            && (p.x > self.origin.x) != (self.direction.x > self.origin.x)
        {
            return false;
        }
        if self.direction.y != self.origin.y
            && (p.y > self.origin.y) != (self.direction.y > self.origin.y)
        {
            return false;
        }
        true
    }
}

impl<T: Field + Base + Ord> Ray<T> {
    pub fn intersect_ray(&self, other: Self) -> Option<Point<T>> {
        let l1 = self.line();
        let l2 = other.line();
        if l1.is_parallel(l2) {
            return None;
        }
        let p = l1.intersect(l2);
        if self.contains(p) && other.contains(p) {
            Some(p)
        } else {
            None
        }
    }

    pub fn square_dist_point(&self, p: Point<T>) -> T {
        let line = self.line();
        let perp = line.perpendicular(p);
        let pp = line.intersect(perp);
        if self.contains(pp) {
            pp.square_dist_point(p)
        } else {
            self.origin.square_dist_point(p)
        }
    }
}

impl<T: Field + Base + Ord + IntoReal> Ray<T> {
    pub fn dist_point(&self, p: Point<T>) -> Real {
        self.square_dist_point(p).into_real().sqrt()
    }
}

impl Ray<Real> {
    pub fn angle(&self) -> Real {
        (self.direction - self.origin).angle()
    }

    pub fn from_angle(origin: Point<Real>, angle: Real) -> Self {
        Self::new(origin, origin + Point::from_polar(Real::one(), angle))
    }
}
}
}
pub mod io {
pub mod input {
use crate::algo_lib::collections::vec_ext::default::default_vec;
use std::io::Read;

pub struct Input<'s> {
    input: &'s mut (dyn Read + Send),
    buf: Vec<u8>,
    at: usize,
    buf_read: usize,
}

macro_rules! read_impl {
    ($t: ty, $read_name: ident, $read_vec_name: ident) => {
        pub fn $read_name(&mut self) -> $t {
            self.read()
        }

        pub fn $read_vec_name(&mut self, len: usize) -> Vec<$t> {
            self.read_vec(len)
        }
    };

    ($t: ty, $read_name: ident, $read_vec_name: ident, $read_pair_vec_name: ident) => {
        read_impl!($t, $read_name, $read_vec_name);

        pub fn $read_pair_vec_name(&mut self, len: usize) -> Vec<($t, $t)> {
            self.read_vec(len)
        }
    };
}

impl<'s> Input<'s> {
    const DEFAULT_BUF_SIZE: usize = 4096;

    pub fn new(input: &'s mut (dyn Read + Send)) -> Self {
        Self {
            input,
            buf: default_vec(Self::DEFAULT_BUF_SIZE),
            at: 0,
            buf_read: 0,
        }
    }

    pub fn new_with_size(input: &'s mut (dyn Read + Send), buf_size: usize) -> Self {
        Self {
            input,
            buf: default_vec(buf_size),
            at: 0,
            buf_read: 0,
        }
    }

    pub fn get(&mut self) -> Option<u8> {
        if self.refill_buffer() {
            let res = self.buf[self.at];
            self.at += 1;
            if res == b'\r' {
                if self.refill_buffer() && self.buf[self.at] == b'\n' {
                    self.at += 1;
                }
                return Some(b'\n');
            }
            Some(res)
        } else {
            None
        }
    }

    pub fn peek(&mut self) -> Option<u8> {
        if self.refill_buffer() {
            let res = self.buf[self.at];
            Some(if res == b'\r' { b'\n' } else { res })
        } else {
            None
        }
    }

    pub fn skip_whitespace(&mut self) {
        while let Some(b) = self.peek() {
            if !b.is_ascii_whitespace() {
                return;
            }
            self.get();
        }
    }

    pub fn next_token(&mut self) -> Option<Vec<u8>> {
        self.skip_whitespace();
        let mut res = Vec::new();
        while let Some(c) = self.get() {
            if c.is_ascii_whitespace() {
                break;
            }
            res.push(c);
        }
        if res.is_empty() {
            None
        } else {
            Some(res)
        }
    }

    //noinspection RsSelfConvention
    pub fn is_exhausted(&mut self) -> bool {
        self.peek().is_none()
    }

    //noinspection RsSelfConvention
    pub fn is_empty(&mut self) -> bool {
        self.skip_whitespace();
        self.is_exhausted()
    }

    pub fn read<T: Readable>(&mut self) -> T {
        T::read(self)
    }

    pub fn read_vec<T: Readable>(&mut self, size: usize) -> Vec<T> {
        let mut res = Vec::with_capacity(size);
        for _ in 0..size {
            res.push(self.read());
        }
        res
    }

    pub fn read_char(&mut self) -> u8 {
        self.skip_whitespace();
        self.get().unwrap()
    }

    read_impl!(u32, read_unsigned, read_unsigned_vec);
    read_impl!(u64, read_u64, read_u64_vec);
    read_impl!(usize, read_size, read_size_vec, read_size_pair_vec);
    read_impl!(i32, read_int, read_int_vec, read_int_pair_vec);
    read_impl!(i64, read_long, read_long_vec, read_long_pair_vec);
    read_impl!(i128, read_i128, read_i128_vec);

    fn refill_buffer(&mut self) -> bool {
        if self.at == self.buf_read {
            self.at = 0;
            self.buf_read = self.input.read(&mut self.buf).unwrap();
            self.buf_read != 0
        } else {
            true
        }
    }
}

pub trait Readable {
    fn read(input: &mut Input) -> Self;
}

impl Readable for u8 {
    fn read(input: &mut Input) -> Self {
        input.read_char()
    }
}

impl<T: Readable> Readable for Vec<T> {
    fn read(input: &mut Input) -> Self {
        let size = input.read();
        input.read_vec(size)
    }
}

macro_rules! read_integer {
    ($($t:ident)+) => {$(
        impl Readable for $t {
            fn read(input: &mut Input) -> Self {
                input.skip_whitespace();
                let mut c = input.get().unwrap();
                let sgn = match c {
                    b'-' => {
                        c = input.get().unwrap();
                        true
                    }
                    b'+' => {
                        c = input.get().unwrap();
                        false
                    }
                    _ => false,
                };
                let mut res = 0;
                loop {
                    assert!(c.is_ascii_digit());
                    res *= 10;
                    let d = (c - b'0') as $t;
                    if sgn {
                        res -= d;
                    } else {
                        res += d;
                    }
                    match input.get() {
                        None => break,
                        Some(ch) => {
                            if ch.is_ascii_whitespace() {
                                break;
                            } else {
                                c = ch;
                            }
                        }
                    }
                }
                res
            }
        }
    )+};
}

read_integer!(i8 i16 i32 i64 i128 isize u16 u32 u64 u128 usize);

macro_rules! tuple_readable {
    ($($name:ident)+) => {
        impl<$($name: Readable), +> Readable for ($($name,)+) {
            fn read(input: &mut Input) -> Self {
                ($($name::read(input),)+)
            }
        }
    }
}

tuple_readable! {T}
tuple_readable! {T U}
tuple_readable! {T U V}
tuple_readable! {T U V X}
tuple_readable! {T U V X Y}
tuple_readable! {T U V X Y Z}
tuple_readable! {T U V X Y Z A}
tuple_readable! {T U V X Y Z A B}
tuple_readable! {T U V X Y Z A B C}
tuple_readable! {T U V X Y Z A B C D}
tuple_readable! {T U V X Y Z A B C D E}
tuple_readable! {T U V X Y Z A B C D E F}

impl Read for Input<'_> {
    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
        if self.at == self.buf_read {
            self.input.read(buf)
        } else {
            let mut i = 0;
            while i < buf.len() && self.at < self.buf_read {
                buf[i] = self.buf[self.at];
                i += 1;
                self.at += 1;
            }
            Ok(i)
        }
    }
}
}
pub mod output {
use crate::algo_lib::collections::vec_ext::default::default_vec;
use std::cmp::Reverse;
use std::io::stderr;
use std::io::Stderr;
use std::io::Write;

#[derive(Copy, Clone)]
pub enum BoolOutput {
    YesNo,
    YesNoCaps,
    PossibleImpossible,
    Custom(&'static str, &'static str),
}

impl BoolOutput {
    pub fn output(&self, output: &mut Output, val: bool) {
        (if val { self.yes() } else { self.no() }).write(output);
    }

    fn yes(&self) -> &str {
        match self {
            BoolOutput::YesNo => "Yes",
            BoolOutput::YesNoCaps => "YES",
            BoolOutput::PossibleImpossible => "Possible",
            BoolOutput::Custom(yes, _) => yes,
        }
    }

    fn no(&self) -> &str {
        match self {
            BoolOutput::YesNo => "No",
            BoolOutput::YesNoCaps => "NO",
            BoolOutput::PossibleImpossible => "Impossible",
            BoolOutput::Custom(_, no) => no,
        }
    }
}

pub struct Output<'s> {
    output: &'s mut dyn Write,
    buf: Vec<u8>,
    at: usize,
    auto_flush: bool,
    bool_output: BoolOutput,
    precision: Option<usize>,
}

impl<'s> Output<'s> {
    const DEFAULT_BUF_SIZE: usize = 4096;

    pub fn new(output: &'s mut dyn Write) -> Self {
        Self {
            output,
            buf: default_vec(Self::DEFAULT_BUF_SIZE),
            at: 0,
            auto_flush: false,
            bool_output: BoolOutput::YesNoCaps,
            precision: None,
        }
    }

    pub fn new_with_auto_flush(output: &'s mut dyn Write) -> Self {
        Self {
            output,
            buf: default_vec(Self::DEFAULT_BUF_SIZE),
            at: 0,
            auto_flush: true,
            bool_output: BoolOutput::YesNoCaps,
            precision: None,
        }
    }

    pub fn flush(&mut self) {
        if self.at != 0 {
            self.output.write_all(&self.buf[..self.at]).unwrap();
            self.output.flush().unwrap();
            self.at = 0;
        }
    }

    pub fn print<T: Writable>(&mut self, s: T) {
        s.write(self);
        self.maybe_flush();
    }

    pub fn print_line<T: Writable>(&mut self, s: T) {
        self.print(s);
        self.put(b'\n');
        self.maybe_flush();
    }

    pub fn put(&mut self, b: u8) {
        self.buf[self.at] = b;
        self.at += 1;
        if self.at == self.buf.len() {
            self.flush();
        }
    }

    pub fn maybe_flush(&mut self) {
        if self.auto_flush {
            self.flush();
        }
    }

    pub fn print_per_line<T: Writable>(&mut self, arg: &[T]) {
        self.print_per_line_iter(arg.iter());
    }

    pub fn print_iter<T: Writable, I: Iterator<Item = T>>(&mut self, iter: I) {
        let mut first = true;
        for e in iter {
            if first {
                first = false;
            } else {
                self.put(b' ');
            }
            e.write(self);
        }
    }

    pub fn print_line_iter<T: Writable, I: Iterator<Item = T>>(&mut self, iter: I) {
        self.print_iter(iter);
        self.put(b'\n');
    }

    pub fn print_per_line_iter<T: Writable, I: Iterator<Item = T>>(&mut self, iter: I) {
        for e in iter {
            e.write(self);
            self.put(b'\n');
        }
    }

    pub fn set_bool_output(&mut self, bool_output: BoolOutput) {
        self.bool_output = bool_output;
    }
    pub fn set_precision(&mut self, precision: Option<usize>) {
        self.precision = precision;
    }
    pub fn get_precision(&self) -> Option<usize> {
        self.precision
    }
}

impl Write for Output<'_> {
    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
        let mut start = 0usize;
        let mut rem = buf.len();
        while rem > 0 {
            let len = (self.buf.len() - self.at).min(rem);
            self.buf[self.at..self.at + len].copy_from_slice(&buf[start..start + len]);
            self.at += len;
            if self.at == self.buf.len() {
                self.flush();
            }
            start += len;
            rem -= len;
        }
        self.maybe_flush();
        Ok(buf.len())
    }

    fn flush(&mut self) -> std::io::Result<()> {
        self.flush();
        Ok(())
    }
}

pub trait Writable {
    fn write(&self, output: &mut Output);
}

impl Writable for &str {
    fn write(&self, output: &mut Output) {
        output.write_all(self.as_bytes()).unwrap();
    }
}

impl Writable for String {
    fn write(&self, output: &mut Output) {
        output.write_all(self.as_bytes()).unwrap();
    }
}

impl Writable for char {
    fn write(&self, output: &mut Output) {
        output.put(*self as u8);
    }
}

impl Writable for u8 {
    fn write(&self, output: &mut Output) {
        output.put(*self);
    }
}

impl<T: Writable> Writable for [T] {
    fn write(&self, output: &mut Output) {
        output.print_iter(self.iter());
    }
}

impl<T: Writable, const N: usize> Writable for [T; N] {
    fn write(&self, output: &mut Output) {
        output.print_iter(self.iter());
    }
}

impl<T: Writable + ?Sized> Writable for &T {
    fn write(&self, output: &mut Output) {
        T::write(self, output)
    }
}

impl<T: Writable> Writable for Vec<T> {
    fn write(&self, output: &mut Output) {
        self.as_slice().write(output);
    }
}

impl Writable for () {
    fn write(&self, _output: &mut Output) {}
}

macro_rules! write_to_string {
    ($($t:ident)+) => {$(
        impl Writable for $t {
            fn write(&self, output: &mut Output) {
                self.to_string().write(output);
            }
        }
    )+};
}

write_to_string!(u16 u32 u64 u128 usize i8 i16 i32 i64 i128 isize);

macro_rules! tuple_writable {
    ($name0:ident $($name:ident: $id:tt )*) => {
        impl<$name0: Writable, $($name: Writable,)*> Writable for ($name0, $($name,)*) {
            fn write(&self, out: &mut Output) {
                self.0.write(out);
                $(
                out.put(b' ');
                self.$id.write(out);
                )*
            }
        }
    }
}

tuple_writable! {T}
tuple_writable! {T U:1}
tuple_writable! {T U:1 V:2}
tuple_writable! {T U:1 V:2 X:3}
tuple_writable! {T U:1 V:2 X:3 Y:4}
tuple_writable! {T U:1 V:2 X:3 Y:4 Z:5}
tuple_writable! {T U:1 V:2 X:3 Y:4 Z:5 A:6}
tuple_writable! {T U:1 V:2 X:3 Y:4 Z:5 A:6 B:7}
tuple_writable! {T U:1 V:2 X:3 Y:4 Z:5 A:6 B:7 C:8}

impl<T: Writable> Writable for Option<T> {
    fn write(&self, output: &mut Output) {
        match self {
            None => (-1).write(output),
            Some(t) => t.write(output),
        }
    }
}

impl Writable for bool {
    fn write(&self, output: &mut Output) {
        let bool_output = output.bool_output;
        bool_output.output(output, *self)
    }
}

impl<T: Writable> Writable for Reverse<T> {
    fn write(&self, output: &mut Output) {
        self.0.write(output);
    }
}

static mut ERR: Option<Stderr> = None;

pub fn err() -> Output<'static> {
    unsafe {
        if ERR.is_none() {
            ERR = Some(stderr());
        }
        Output::new_with_auto_flush(ERR.as_mut().unwrap())
    }
}
}
}
pub mod misc {
pub mod test_type {
pub enum TestType {
    Single,
    MultiNumber,
    MultiEof,
}

pub enum TaskType {
    Classic,
    Interactive,
}
}
}
pub mod numbers {
pub mod num_traits {
pub mod algebra {
use crate::algo_lib::numbers::num_traits::invertible::Invertible;
use std::ops::Add;
use std::ops::AddAssign;
use std::ops::Div;
use std::ops::DivAssign;
use std::ops::Mul;
use std::ops::MulAssign;
use std::ops::Neg;
use std::ops::Rem;
use std::ops::RemAssign;
use std::ops::Sub;
use std::ops::SubAssign;

pub trait Zero {
    fn zero() -> Self;
}

pub trait One {
    fn one() -> Self;
}

pub trait AdditionMonoid: Add<Output = Self> + AddAssign + Zero + Eq + Sized {}

impl<T: Add<Output = Self> + AddAssign + Zero + Eq> AdditionMonoid for T {}

pub trait AdditionMonoidWithSub: AdditionMonoid + Sub<Output = Self> + SubAssign {}

impl<T: AdditionMonoid + Sub<Output = Self> + SubAssign> AdditionMonoidWithSub for T {}

pub trait AdditionGroup: AdditionMonoidWithSub + Neg<Output = Self> {}

impl<T: AdditionMonoidWithSub + Neg<Output = Self>> AdditionGroup for T {}

pub trait MultiplicationMonoid: Mul<Output = Self> + MulAssign + One + Eq + Sized {}

impl<T: Mul<Output = Self> + MulAssign + One + Eq> MultiplicationMonoid for T {}

pub trait IntegerMultiplicationMonoid:
    MultiplicationMonoid + Div<Output = Self> + Rem<Output = Self> + DivAssign + RemAssign
{
}

impl<T: MultiplicationMonoid + Div<Output = Self> + Rem<Output = Self> + DivAssign + RemAssign>
    IntegerMultiplicationMonoid for T
{
}

pub trait MultiplicationGroup:
    MultiplicationMonoid + Div<Output = Self> + DivAssign + Invertible<Output = Self>
{
}

impl<T: MultiplicationMonoid + Div<Output = Self> + DivAssign + Invertible<Output = Self>>
    MultiplicationGroup for T
{
}

pub trait SemiRing: AdditionMonoid + MultiplicationMonoid {}

impl<T: AdditionMonoid + MultiplicationMonoid> SemiRing for T {}

pub trait SemiRingWithSub: AdditionMonoidWithSub + SemiRing {}

impl<T: AdditionMonoidWithSub + SemiRing> SemiRingWithSub for T {}

pub trait Ring: SemiRing + AdditionGroup {}

impl<T: SemiRing + AdditionGroup> Ring for T {}

pub trait IntegerSemiRing: SemiRing + IntegerMultiplicationMonoid {}

impl<T: SemiRing + IntegerMultiplicationMonoid> IntegerSemiRing for T {}

pub trait IntegerSemiRingWithSub: SemiRingWithSub + IntegerSemiRing {}

impl<T: SemiRingWithSub + IntegerSemiRing> IntegerSemiRingWithSub for T {}

pub trait IntegerRing: IntegerSemiRing + Ring {}

impl<T: IntegerSemiRing + Ring> IntegerRing for T {}

pub trait Field: Ring + MultiplicationGroup {}

impl<T: Ring + MultiplicationGroup> Field for T {}

macro_rules! zero_one_integer_impl {
    ($($t: ident)+) => {$(
        impl Zero for $t {
            fn zero() -> Self {
                0
            }
        }

        impl One for $t {
            fn one() -> Self {
                1
            }
        }
    )+};
}

zero_one_integer_impl!(i128 i64 i32 i16 i8 isize u128 u64 u32 u16 u8 usize);
}
pub mod invertible {
pub trait Invertible {
    type Output;

    fn inv(&self) -> Option<Self::Output>;
}
}
}
pub mod real {
use crate::algo_lib::collections::iter_ext::find_count::IterFindCount;
use crate::algo_lib::io::input::Input;
use crate::algo_lib::io::input::Readable;
use crate::algo_lib::io::output::Output;
use crate::algo_lib::io::output::Writable;
use crate::algo_lib::numbers::num_traits::algebra::One;
use crate::algo_lib::numbers::num_traits::algebra::Zero;
use crate::algo_lib::numbers::num_traits::invertible::Invertible;
use std::cmp::Ordering;
use std::ops::Add;
use std::ops::AddAssign;
use std::ops::Deref;
use std::ops::DerefMut;
use std::ops::Div;
use std::ops::DivAssign;
use std::ops::Mul;
use std::ops::MulAssign;
use std::ops::Neg;
use std::ops::Sub;
use std::ops::SubAssign;

#[derive(Copy, Clone, Debug, Default)]
pub struct Real(pub f64);

impl Real {
    pub fn round(&self) -> i64 {
        self.0.round() as i64
    }
    pub fn ceil(&self) -> i64 {
        self.0.ceil() as i64
    }
    pub fn floor(&self) -> i64 {
        self.0.floor() as i64
    }
    pub fn with_precision(&self, precision: usize) -> String {
        let res = format!("{:.*}", precision, self.0);
        if res.starts_with('-') && res.chars().count_eq(&'0') == precision + 1 {
            res[1..].to_string()
        } else {
            res
        }
    }
}

#[allow(clippy::non_canonical_partial_ord_impl)]
impl PartialOrd for Real {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        if self == other {
            Some(Ordering::Equal)
        } else if self.0 < other.0 {
            Some(Ordering::Less)
        } else {
            Some(Ordering::Greater)
        }
    }
}

impl PartialOrd<f64> for Real {
    fn partial_cmp(&self, other: &f64) -> Option<Ordering> {
        self.partial_cmp(&Real(*other))
    }
}

impl PartialOrd<Real> for f64 {
    fn partial_cmp(&self, other: &Real) -> Option<Ordering> {
        Real(*self).partial_cmp(other)
    }
}

impl PartialEq<f64> for Real {
    fn eq(&self, other: &f64) -> bool {
        self.eq(&Real(*other))
    }
}

impl PartialEq<Real> for f64 {
    fn eq(&self, other: &Real) -> bool {
        Real(*self).eq(other)
    }
}

impl PartialEq for Real {
    fn eq(&self, other: &Self) -> bool {
        (self.0 - other.0).abs() < Real::epsilon().0
    }
}

impl Eq for Real {}

impl Ord for Real {
    fn cmp(&self, other: &Self) -> Ordering {
        self.partial_cmp(other).unwrap()
    }
}

impl AddAssign for Real {
    fn add_assign(&mut self, rhs: Self) {
        self.0 += rhs.0;
    }
}

impl AddAssign<f64> for Real {
    fn add_assign(&mut self, rhs: f64) {
        self.0 += rhs;
    }
}

impl Add for Real {
    type Output = Self;

    fn add(mut self, rhs: Self) -> Self::Output {
        self += rhs;
        self
    }
}

impl Add<f64> for Real {
    type Output = Self;

    fn add(mut self, rhs: f64) -> Self::Output {
        self += rhs;
        self
    }
}

impl Add<Real> for f64 {
    type Output = Real;

    fn add(self, rhs: Real) -> Self::Output {
        Real(self + rhs.0)
    }
}

impl SubAssign for Real {
    fn sub_assign(&mut self, rhs: Self) {
        self.0 -= rhs.0;
    }
}

impl SubAssign<f64> for Real {
    fn sub_assign(&mut self, rhs: f64) {
        self.0 -= rhs;
    }
}

impl Sub for Real {
    type Output = Self;

    fn sub(mut self, rhs: Self) -> Self::Output {
        self -= rhs;
        self
    }
}

impl Sub<f64> for Real {
    type Output = Self;

    fn sub(mut self, rhs: f64) -> Self::Output {
        self -= rhs;
        self
    }
}

impl Sub<Real> for f64 {
    type Output = Real;

    fn sub(self, rhs: Real) -> Self::Output {
        Real(self - rhs.0)
    }
}

impl MulAssign for Real {
    fn mul_assign(&mut self, rhs: Self) {
        self.0 *= rhs.0;
    }
}

impl MulAssign<f64> for Real {
    fn mul_assign(&mut self, rhs: f64) {
        self.0 *= rhs;
    }
}

impl Mul for Real {
    type Output = Self;

    fn mul(mut self, rhs: Self) -> Self::Output {
        self.0 *= rhs.0;
        self
    }
}

impl Mul<f64> for Real {
    type Output = Self;

    fn mul(mut self, rhs: f64) -> Self::Output {
        self.0 *= rhs;
        self
    }
}

impl Mul<Real> for f64 {
    type Output = Real;

    fn mul(self, rhs: Real) -> Self::Output {
        Real(self * rhs.0)
    }
}

impl DivAssign for Real {
    fn div_assign(&mut self, rhs: Self) {
        self.0 /= rhs.0;
    }
}

impl DivAssign<f64> for Real {
    fn div_assign(&mut self, rhs: f64) {
        self.0 /= rhs;
    }
}

impl Div for Real {
    type Output = Self;

    fn div(mut self, rhs: Self) -> Self::Output {
        self /= rhs;
        self
    }
}

impl Div<f64> for Real {
    type Output = Self;

    fn div(mut self, rhs: f64) -> Self::Output {
        self /= rhs;
        self
    }
}

impl Div<Real> for f64 {
    type Output = Real;

    fn div(self, rhs: Real) -> Self::Output {
        Real(self / rhs.0)
    }
}

impl Neg for Real {
    type Output = Self;

    fn neg(self) -> Self::Output {
        Self(-self.0)
    }
}

impl Zero for Real {
    fn zero() -> Self {
        Self(0.0)
    }
}

impl One for Real {
    fn one() -> Self {
        Self(1.0)
    }
}

static mut EPSILON: Real = Real(1e-9);

impl Real {
    pub const PI: Self = Self(std::f64::consts::PI);

    pub fn abs(&self) -> Self {
        Self(self.0.abs())
    }

    pub fn sqrt(&self) -> Self {
        Self(self.0.sqrt())
    }

    pub fn sin(&self) -> Self {
        Self(self.0.sin())
    }

    pub fn cos(&self) -> Self {
        Self(self.0.cos())
    }

    pub fn tan(&self) -> Self {
        Self(self.0.tan())
    }

    pub fn hypot(x: Self, y: Self) -> Self {
        Self(f64::hypot(x.0, y.0))
    }

    pub fn atan2(y: Self, x: Self) -> Self {
        Self(f64::atan2(y.0, x.0))
    }

    pub fn epsilon() -> Self {
        unsafe { EPSILON }
    }

    pub fn set_epsilon(eps: impl Into<Self>) {
        unsafe {
            EPSILON = eps.into();
        }
    }
}

impl Deref for Real {
    type Target = f64;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl DerefMut for Real {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl Invertible for Real {
    type Output = Self;

    fn inv(&self) -> Option<Self::Output> {
        if self == &Self::zero() {
            None
        } else {
            Some(Self(1.0 / self.0))
        }
    }
}

impl Readable for Real {
    fn read(input: &mut Input) -> Self {
        Self(
            String::from_utf8(input.next_token().unwrap())
                .unwrap()
                .parse()
                .unwrap(),
        )
    }
}

impl Writable for Real {
    fn write(&self, output: &mut Output) {
        match output.get_precision() {
            Some(precision) => {
                self.with_precision(precision).write(output);
            }
            None => {
                self.0.to_string().write(output);
            }
        }
    }
}

pub trait RealReader {
    fn read_real(&mut self) -> Real;
    fn read_real_vec(&mut self, n: usize) -> Vec<Real>;
}

impl RealReader for Input<'_> {
    fn read_real(&mut self) -> Real {
        self.read()
    }

    fn read_real_vec(&mut self, n: usize) -> Vec<Real> {
        self.read_vec(n)
    }
}

pub trait IntoReal {
    fn into_real(self) -> Real;
}

impl IntoReal for Real {
    fn into_real(self) -> Real {
        self
    }
}

macro_rules! into_real {
    ($($t: ident)+) => {$(
        impl IntoReal for $t {
            fn into_real(self) -> Real {
                Real(self as f64)
            }
        }

        impl From<$t> for Real {
            fn from(x: $t) -> Self {
                Real(x as f64)
            }
        }
    )+};
}

into_real!(u8 u16 u32 u64 u128 usize i8 i16 i32 i64 i128 isize f64);
}
}
}
fn main() {
    let mut sin = std::io::stdin();
    let input = algo_lib::io::input::Input::new(&mut sin);
    let mut stdout = std::io::stdout();
    let output = algo_lib::io::output::Output::new(&mut stdout);
    solution::run(input, output);
}