Problem:
Score : 400 points

Problem Statement

There are N squares arranged in a row, numbered 1, 2, ..., N from left to right.
You are given a string S of length N consisting of . and #. If the i-th character of S is #, Square i contains a rock; if the i-th character of S is ., Square i is empty.

In the beginning, Snuke stands on Square A, and Fnuke stands on Square B.

You can repeat the following operation any number of times:

Choose Snuke or Fnuke, and make him jump one or two squares to the right. The destination must be one of the squares, and it must not contain a rock or the other person.

You want to repeat this operation so that Snuke will stand on Square C and Fnuke will stand on Square D.

Determine whether this is possible.

Constraints

4 \leq N \leq 200\ 000

S is a string of length N consisting of . and #.

1 \leq A, B, C, D \leq N

Square A, B, C and D do not contain a rock.

A, B, C and D are all different.

A < B

A < C

B < D

Input

Input is given from Standard Input in the following format:

N A B C D
S

Output

Print Yes if the objective is achievable, and No if it is not.

Sample Input 1

7 1 3 6 7
.#..#..

Sample Output 1

Yes

The objective is achievable by, for example, moving the two persons as follows. (A and B represent Snuke and Fnuke, respectively.)

A#B.#..

A#.B#..

.#AB#..

.#A.#B.

.#.A#B.

.#.A#.B

.#..#AB

Sample Input 2

7 1 3 7 6
.#..#..

Sample Output 2

No

Sample Input 3

15 1 3 15 13
...#.#...#.#...

Sample Output 3

Yes

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 prelude {
        pub use self::myvec::*;
        #[macro_use]
        pub mod primitive {
            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
                }
            }
        }
        #[macro_use]
        pub mod myvec {
            use std::fmt;
            use std::iter::FromIterator;
            use std::ops::*;

            pub use super::primitive::ToUsize;

            /// `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()]
                }
            }

            #[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]);
            }
        }
    }
    #[macro_use]
    pub mod io {
        /// Scanner
        ///
        /// # Example
        /// ```
        /// use contest::io::Scanner;
        /// let mut sc = Scanner::new("1 2 \n\n \r\t \n 3".as_bytes());
        /// assert_eq!("1".to_string(), sc.next::<String>());
        /// let v = sc.nexts(2);
        /// assert_eq!(2i32, v[0]);
        /// assert_eq!(3i32, v[1]);
        ///
        /// // To create a scanner from stdin:
        /// Scanner::new(std::io::stdin());
        /// ```
        use std;
        use std::io;
        use std::io::BufRead;

        use super::prelude::MyVec;

        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 nexts<T>(&mut self, n: i32) -> MyVec<T>
            where
                T: std::str::FromStr,
                T::Err: std::fmt::Debug,
            {
                let mut res = v![];
                for _ in 0..n {
                    res.push(self.next());
                }
                res
            }
            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);
        }
    }
}
//////////////////////////////// LIBRARY END ////////////////////////////////

use contest::io::Scanner;
use contest::prelude::MyVec;

fn main() {
    let mut sc = Scanner::new(std::io::stdin());

    let n = sc.next::<i32>();
    let a = sc.next::<i32>() - 1;
    let b = sc.next::<i32>() - 1;
    let c = sc.next::<i32>() - 1;
    let d = sc.next::<i32>() - 1;
    let _s = sc.next::<String>();
    let mut s = v![];
    for k in _s.chars() {
        s.push(k);
    }
    let mut res = true;

    for i in a..c {
        if s[i] == '#' && s[i + 1] == '#' {
            res = false;
        }
    }
    for i in b..d {
        if s[i] == '#' && s[i + 1] == '#' {
            res = false;
        }
    }
    if d < c {
        let mut ok = false;
        for i in b..(d + 1) {
            if s[i - 1] == '.' && s[i] == '.' && s[i + 1] == '.' {
                ok = true;
            }
        }
        if !ok {
            res = false;
        }
    }

    println!("{}", if res { "Yes" } else { "No" });
}