#![allow(unused_imports, unused_macros)] use kyoproio::*; use std::{ collections::*, io::{self, prelude::*}, iter, mem::{replace, swap}, }; fn run(mut kin: I, out: O) { let mut out = KOutput::new(out); let [a, b, c, d, e, f]: [f64; 6] = kin.input(); // ax^2 + by^2 + cx + dy + e = f // u((x - s)^2 + (y - t)^2) = ur^2 // u(x^2 - 2sx + s^2 + y^2 - 2ty + t^2) = ur^2 // u = a = b // s = -c / 2u // t = -d / 2u // u(r^2 - s^2 - t^2) = f - e // r^2 = (f - e + (c ^ 2 + d ^ 2) / 4a) / a assert_eq!(a, b); let r2 = (f - e + (c * c + d * d) / (4. * a)) / a; let r = r2.sqrt(); outln!(out, r); } // ----------------------------------------------------------------------------- fn main() -> io::Result<()> { std::thread::Builder::new() .stack_size(64 * 1024 * 1024) .spawn(|| { run( KInput::new(io::stdin().lock()), io::BufWriter::new(io::stdout().lock()), ) })? .join() .unwrap(); Ok(()) } // ----------------------------------------------------------------------------- pub mod kyoproio { use std::{ io::prelude::*, iter::FromIterator, marker::PhantomData, mem::{self, MaybeUninit}, ptr, slice, str, }; pub trait Input { fn bytes(&mut self) -> &[u8]; fn str(&mut self) -> &str { str::from_utf8(self.bytes()).unwrap() } fn input(&mut self) -> T { T::input(self) } fn iter(&mut self) -> Iter { Iter(self, PhantomData) } fn seq>(&mut self, n: usize) -> B { self.iter().take(n).collect() } } pub struct KInput { src: R, buf: Vec, pos: usize, len: usize, } impl KInput { pub fn new(src: R) -> Self { Self { src, buf: vec![0; 1 << 16], pos: 0, len: 0, } } fn read(&mut self) -> usize { if self.pos > 0 { self.buf.copy_within(self.pos..self.len, 0); self.len -= self.pos; self.pos = 0; } else if self.len >= self.buf.len() { self.buf.resize(2 * self.buf.len(), 0); } let read = self.src.read(&mut self.buf[self.len..]).unwrap(); self.len += read; read } } impl Input for KInput { fn bytes(&mut self) -> &[u8] { loop { while let Some(d) = self.buf[self.pos..self.len] .iter() .position(u8::is_ascii_whitespace) { let p = self.pos; self.pos += d + 1; if d > 0 { return &self.buf[p..p + d]; } } if self.read() == 0 { return &self.buf[mem::replace(&mut self.pos, self.len)..self.len]; } } } } pub struct Iter<'a, T, I: ?Sized>(&'a mut I, PhantomData<*const T>); impl<'a, T: InputItem, I: Input + ?Sized> Iterator for Iter<'a, T, I> { type Item = T; fn next(&mut self) -> Option { Some(self.0.input()) } fn size_hint(&self) -> (usize, Option) { (!0, None) } } pub trait InputItem: Sized { fn input(src: &mut I) -> Self; } impl InputItem for Vec { fn input(src: &mut I) -> Self { src.bytes().to_owned() } } macro_rules! from_str { { $($T:ty)* } => { $(impl InputItem for $T { fn input(src: &mut I) -> Self { src.str().parse::<$T>().unwrap() } })* } } from_str! { String char bool f32 f64 } macro_rules! parse_int { { $($I:ty: $U:ty)* } => { $(impl InputItem for $I { fn input(src: &mut I) -> Self { let f = |s: &[u8]| s.iter().fold(0, |x, b| 10 * x + (b & 0xf) as $I); let s = src.bytes(); if let Some((&b'-', t)) = s.split_first() { -f(t) } else { f(s) } } } impl InputItem for $U { fn input(src: &mut I) -> Self { src.bytes().iter().fold(0, |x, b| 10 * x + (b & 0xf) as $U) } })* }; } parse_int! { isize:usize i8:u8 i16:u16 i32:u32 i64:u64 i128:u128 } macro_rules! tuple { ($H:ident $($T:ident)*) => { impl<$H: InputItem, $($T: InputItem),*> InputItem for ($H, $($T),*) { fn input(src: &mut I) -> Self { ($H::input(src), $($T::input(src)),*) } } tuple!($($T)*); }; () => {} } tuple!(A B C D E F G); macro_rules! array { { $($N:literal)* } => { $(impl InputItem for [T; $N] { fn input(src: &mut I) -> Self { let mut arr = MaybeUninit::uninit(); let ptr = arr.as_mut_ptr() as *mut T; unsafe { for i in 0..$N { ptr.add(i).write(src.input()); } arr.assume_init() } } })* }; } array! { 1 2 3 4 5 6 7 8 } pub struct KOutput { dest: W, delim: bool, } impl KOutput { pub fn new(dest: W) -> Self { Self { dest, delim: false } } pub fn bytes(&mut self, s: &[u8]) { self.dest.write_all(s).unwrap(); } pub fn byte(&mut self, b: u8) { self.bytes(slice::from_ref(&b)); } pub fn output(&mut self, x: T) { if self.delim { self.byte(b' '); } self.delim = true; x.output(self); } pub fn ln(&mut self) { self.delim = false; self.byte(b'\n'); self.flush_debug(); } pub fn inner(&mut self) -> &mut W { &mut self.dest } pub fn seq>(&mut self, iter: I) { for x in iter.into_iter() { self.output(x); } } pub fn flush(&mut self) { self.dest.flush().unwrap(); } pub fn flush_debug(&mut self) { if cfg!(debug_assertions) { self.flush(); } } } pub trait OutputItem { fn output(self, dest: &mut KOutput); } impl OutputItem for &str { fn output(self, dest: &mut KOutput) { dest.bytes(self.as_bytes()); } } impl OutputItem for char { fn output(self, dest: &mut KOutput) { self.encode_utf8(&mut [0; 4]).output(dest); } } macro_rules! output_fmt { ($($T:ty)*) => { $(impl OutputItem for $T { fn output(self, dest: &mut KOutput) { write!(dest.inner(), "{}", self).unwrap(); } })* } } output_fmt!(f32 f64); macro_rules! output_int { ($conv:ident; $U:ty; $($T:ty)*) => { $(impl OutputItem for $T { fn output(self, dest: &mut KOutput) { let mut buf = MaybeUninit::<[u8; 20]>::uninit(); unsafe { let ptr = buf.as_mut_ptr() as *mut u8; let ofs = $conv(self as $U, ptr, 20); dest.bytes(slice::from_raw_parts(ptr.add(ofs), 20 - ofs)); } } } impl OutputItem for &$T { fn output(self, dest: &mut KOutput) { (*self).output(dest); } })* }; } output_int!(i64_to_bytes; i64; isize i8 i16 i32 i64); output_int!(u64_to_bytes; u64; usize u8 u16 u32 u64); static DIGITS_LUT: &[u8; 200] = b"0001020304050607080910111213141516171819\ 2021222324252627282930313233343536373839\ 4041424344454647484950515253545556575859\ 6061626364656667686970717273747576777879\ 8081828384858687888990919293949596979899"; unsafe fn i64_to_bytes(x: i64, buf: *mut u8, len: usize) -> usize { let (neg, x) = if x < 0 { (true, -x) } else { (false, x) }; let mut i = u64_to_bytes(x as u64, buf, len); if neg { i -= 1; *buf.add(i) = b'-'; } i } unsafe fn u64_to_bytes(mut x: u64, buf: *mut u8, len: usize) -> usize { let lut = DIGITS_LUT.as_ptr(); let mut i = len; let mut two = |x| { i -= 2; ptr::copy_nonoverlapping(lut.add(2 * x), buf.add(i), 2); }; while x >= 10000 { let rem = (x % 10000) as usize; two(rem % 100); two(rem / 100); x /= 10000; } let mut x = x as usize; if x >= 100 { two(x % 100); x /= 100; } if x >= 10 { two(x); } else { i -= 1; *buf.add(i) = x as u8 + b'0'; } i } #[macro_export] macro_rules! out { ($out:expr, $($args:expr),*) => {{ $($out.output($args);)* }}; } #[macro_export] macro_rules! outln { ($out:expr) => { $out.ln(); }; ($out:expr, $($args:expr),*) => {{ out!($out, $($args),*); outln!($out); }} } #[macro_export] macro_rules! kdbg { ($($v:expr),*) => { if cfg!(debug_assertions) { dbg!($($v),*) } else { ($($v),*) } } } }