Problem:
﻿Score: 100 points

Problem Statement

In AtCoder city, there are five antennas standing in a straight line. They are called Antenna A, B, C, D and E from west to east, and their coordinates are a, b, c, d and e, respectively.

Two antennas can communicate directly if the distance between them is k or less, and they cannot if the distance is greater than k.

Determine if there exists a pair of antennas that cannot communicate directly.

Here, assume that the distance between two antennas at coordinates p and q (p < q) is q - p.

Constraints

a, b, c, d, e and k are integers between 0 and 123 (inclusive).

a < b < c < d < e

Input

Input is given from Standard Input in the following format:

a
b
c
d
e
k

Output

Print :( if there exists a pair of antennas that cannot communicate directly, and print Yay! if there is no such pair.

Sample Input 1

1
2
4
8
9
15

Sample Output 1

Yay!

In this case, there is no pair of antennas that cannot communicate directly, because:

the distance between A and B is 2 - 1 = 1

the distance between A and C is 4 - 1 = 3

the distance between A and D is 8 - 1 = 7

the distance between A and E is 9 - 1 = 8

the distance between B and C is 4 - 2 = 2

the distance between B and D is 8 - 2 = 6

the distance between B and E is 9 - 2 = 7

the distance between C and D is 8 - 4 = 4

the distance between C and E is 9 - 4 = 5

the distance between D and E is 9 - 8 = 1

and none of them is greater than 15. Thus, the correct output is Yay!.

Sample Input 2

15
18
26
35
36
18

Sample Output 2

:(

In this case, the distance between antennas A and D is 35 - 15 = 20 and exceeds 18, so they cannot communicate directly.
Thus, the correct output is :(.

Solution in Rust (1.15.1) (judge verdict: Accepted)

#![allow(non_snake_case, unused_imports)]
//////////////////////////////// LIBRARY START ////////////////////////////////
#[macro_use]
pub mod contest {
    #[macro_use]
    pub mod io {
        /// Scanner
        ///
        /// # Example
        /// ```
        /// use contest::io::Scanner;
        /// let mut sc = Scanner::new("1 2 \n\n \r\t \n 3.5".as_bytes());
        /// assert_eq!("1".to_string(), sc.next::<String>());
        /// assert_eq!(2, sc.next());
        /// assert_eq!(3.5, sc.next());
        ///
        /// // To create a scanner from stdin:
        /// Scanner::new(std::io::stdin());
        /// ```
        use std;
        use std::io;
        use std::io::BufRead;

        pub struct Scanner<R: io::Read> {
            br: io::BufReader<R>,
            // Read tokens are stored in reversed order per line.
            buf: Vec<String>,
        }

        pub fn new<R: io::Read>(r: R) -> Scanner<R> {
            Scanner::new(r)
        }

        impl<R: io::Read> Scanner<R> {
            #[inline]
            pub fn new(r: R) -> Scanner<R> {
                Scanner {
                    br: io::BufReader::new(r),
                    buf: vec![],
                }
            }
            #[inline]
            pub fn next<T>(&mut self) -> T
            where
                T: std::str::FromStr,
                T::Err: std::fmt::Debug,
            {
                self.next_string()
                    .map(|s| s.parse::<T>().expect("Parse failed: "))
                    .expect("Unexpected EOF")
            }
            #[inline]
            pub fn next2<T1, T2>(&mut self) -> (T1, T2)
            where
                T1: std::str::FromStr,
                T2: std::str::FromStr,
                T1::Err: std::fmt::Debug,
                T2::Err: std::fmt::Debug,
            {
                (self.next(), self.next())
            }
            fn next_string(&mut self) -> Option<String> {
                self.buf.pop().or_else(|| match self.update() {
                    true => self.next_string(),
                    false => None,
                })
            }
            #[inline]
            fn update(&mut self) -> bool {
                let mut s = String::new();
                let res = self.br.read_line(&mut s);
                match res.expect("I/O error.") {
                    0 => false,
                    _ => {
                        self.buf = s.split_whitespace().map(|x| x.to_string()).rev().collect();
                        true
                    }
                }
            }
        }

        #[test]
        fn test_next() {
            let mut sc = new("hoge".as_bytes());
            let s: String = sc.next();
            assert_eq!("hoge", s);
        }
    }
    #[macro_use]
    pub mod prelude {
        use std::fmt;
        use std::iter::FromIterator;
        use std::ops::*;

        /// `Vec` indexable with `i32`, `i64` or `usize`.
        #[derive(Clone, Debug, PartialEq, PartialOrd)]
        pub struct MyVec<T>(pub Vec<T>);

        /// Creates `MyVec`
        #[macro_export]
        macro_rules! v {
    ( $( $x:expr ),* ) => {
        MyVec(vec![ $( $x, )* ])
    };
    ( $x:expr ; $n:expr ) => {
        {
            MyVec(vec![$x; $n as usize])
        }
    };
}

        impl<T: fmt::Display> fmt::Display for MyVec<T> {
            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                let n = self.len();
                for i in 0..n {
                    let r = if i < n - 1 {
                        writeln!(f, "{}", self.0[i])
                    } else {
                        write!(f, "{}", self.0[i])
                    };
                    if r.is_err() {
                        return r;
                    }
                }
                Ok(())
            }
        }

        impl<T> Deref for MyVec<T> {
            type Target = Vec<T>;

            #[inline]
            fn deref(&self) -> &Vec<T> {
                &self.0
            }
        }

        impl<T> DerefMut for MyVec<T> {
            #[inline]
            fn deref_mut(&mut self) -> &mut Vec<T> {
                &mut self.0
            }
        }

        impl<T> FromIterator<T> for MyVec<T> {
            #[inline]
            fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
                MyVec(Vec::from_iter(iter))
            }
        }

        impl<T, I: ToUsize> Index<I> for MyVec<T> {
            type Output = T;

            #[inline]
            fn index(&self, i: I) -> &T {
                &self.0[i.to_usize()]
            }
        }

        impl<T, I: ToUsize> IndexMut<I> for MyVec<T> {
            #[inline]
            fn index_mut(&mut self, i: I) -> &mut T {
                &mut self.0[i.to_usize()]
            }
        }

        pub trait ToUsize: Sized {
            fn to_usize(self) -> usize;
        }

        impl ToUsize for i32 {
            #[inline]
            fn to_usize(self) -> usize {
                self as usize
            }
        }

        impl ToUsize for i64 {
            #[inline]
            fn to_usize(self) -> usize {
                self as usize
            }
        }

        impl ToUsize for usize {
            #[inline]
            fn to_usize(self) -> usize {
                self
            }
        }

        #[test]
        fn test_myvec() {
            let mut x = v![3, 2, 1];
            x.sort();
            assert_eq!(vec![1, 2, 3], *x);
            let i = 1i32;
            assert_eq!(2, x[i]);
            x[i] = 3;
            assert_eq!(3, x[i]);
            let u = 1usize;
            assert_eq!(3, x[u]);
            x[u] = 2;
            assert_eq!(2, x[u]);
            assert_eq!(2, x[1]);

            assert_eq!("MyVec([1, 2, 3])", format!("{:?}", x));
            assert_eq!(v![1, 2, 3], x);

            assert_eq!("1\n2\n3", format!("{}", x));

            let mut y = v![v![1, 2]; 3];
            y[0][0] = 2;
            assert_eq!(vec![2, 2], *y[0]);
            assert_eq!(vec![1, 2], *y[1]);
        }
    }
}
//////////////////////////////// LIBRARY END ////////////////////////////////
#[macro_use]
use contest::io::Scanner;
use contest::prelude::MyVec;

fn main() {
    let mut sc = Scanner::new(std::io::stdin());
    let a = sc.next::<i32>();
    let _ = sc.next::<i32>();
    let _ = sc.next::<i32>();
    let _ = sc.next::<i32>();
    let e = sc.next::<i32>();
    let k = sc.next::<i32>();
    let res = if e - a <= k { "Yay!" } else { ":(" };
    println!("{}", res);
}