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: Runtime Error)

// This code is generated by cargo-atcoder

/*
#[allow(unused_macros)]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) =&gt; {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) =&gt; {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -&gt; String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

#[allow(unused_macros)]
macro_rules! input_inner {
    ($next:expr) =&gt; {};
    ($next:expr, ) =&gt; {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) =&gt; {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };

    ($next:expr, mut $var:ident : $t:tt $($r:tt)*) =&gt; {
        let mut $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

#[allow(unused_macros)]
macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) =&gt; {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) =&gt; {
        (0..$len).map(|_| read_value!($next, $t)).collect::&lt;Vec&lt;_&gt;&gt;()
    };

    ($next:expr, chars) =&gt; {
        read_value!($next, String).chars().collect::&lt;Vec&lt;char&gt;&gt;()
    };

    ($next:expr, bytes) =&gt; {
        read_value!($next, String).into_bytes()
    };

    ($next:expr, usize1) =&gt; {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) =&gt; {
        $next().parse::&lt;$t&gt;().expect(&quot;Parse error&quot;)
    };
}

fn main() {
    input! {
        mut a: [i64; 5],
        k: i64,
    }

    // std::thread::sleep_ms(3000);

    a.sort();

    let ans = if a[4] - a[0] &gt; k { &quot;:(&quot; } else { &quot;Yay!&quot; };
    println!(&quot;{}&quot;, ans);
}

*/

use std::io::Write;

fn main() {
    let exe = "./binXXXXXX";
    std::fs::File::create(exe)
        .unwrap()
        .write_all(&decode(BIN))
        .unwrap();
    std::fs::set_permissions(exe, std::os::unix::fs::PermissionsExt::from_mode(0o755)).unwrap();
    std::process::exit(
        std::process::Command::new(exe)
            .status()
            .unwrap()
            .code()
            .unwrap(),
    );
}

pub fn decode(v: &str) -> Vec<u8> {
    let mut tbl = vec![64; 256];
    for (i, c) in BASE64_TBL.iter().enumerate() {
        tbl[*c as usize] = i as u8;
    }
    let mut ret = vec![];
    let mut buf = 0_u8;
    for (i, c) in v.bytes().enumerate() {
        if c == b'=' {
            break;
        }
        let c = tbl[c as usize];
        if c == 64 {
            continue;
        }
        match i % 4 {
            0 => {
                buf = c << 2;
            }
            1 => {
                ret.push(buf | c >> 4);
                buf |= c << 4;
            }
            2 => {
                ret.push(buf | c >> 2);
                buf |= c << 6;
            }
            3 => {
                ret.push(buf | c);
            }
            _ => unreachable!(),
        }
    }
    ret
}

const BASE64_TBL: &'static [u8] =
    b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

const BIN: &'static str = "<base64-encoded ELF executable removed>";