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 Haskell (GHC 7.10.3) (judge verdict: Wrong Answer)

  import Control.Monad
  import Control.Monad.ST
  import qualified Data.Array as A
  import qualified Data.Array.ST as ST
  import qualified Data.Array.Unboxed as AU
  import Data.Bits
  import qualified Data.ByteString.Char8 as BS
  import Data.Char
  import Data.Int
  import qualified Data.IntMap as IM
  import Data.List
  import qualified Data.Map as M
  import Data.Maybe
  import Data.Ord
  import qualified Data.Set as S
  import Data.Time
  import qualified Data.Vector as V
  import qualified Data.Vector.Mutable as VM
  import qualified Data.Vector.Unboxed as VU
  import qualified Data.Vector.Unboxed.Mutable as VUM
  
  readInt :: IO [Int]
  readInt = map (fst . fromJust . BS.readInt) . BS.words <$> BS.getLine
  
  readInts :: Int -> IO [[Int]]
  readInts n = replicateM n readInt
  
  readInteger :: IO [Integer]
  readInteger = map (fst . fromJust . BS.readInteger) . BS.words <$> BS.getLine
  
  readIntegers :: Int -> IO [[Integer]]
  readIntegers n = replicateM n readInteger
  
  readString :: IO [String]
  readString = map BS.unpack . BS.words <$> BS.getLine
  
  readStrings :: Int -> IO [[String]]
  readStrings n = replicateM n <$> readString
  
  toPair :: [a] -> (a, a)
  toPair [x, y] = (x, y)
  
  main = do
    [n, a, b, c, d] <- readInt
    s <- getLine
    putStrLn $ solve a b c d s
  
  solve a b c d s
    | x && y = "Yes"
    | otherwise = "No"
    where
      x =
        (< 2) $
        maximum $
        map
          (\ss ->
             if head ss == '#'
               then length ss
               else 0) $
        group $ drop (a - 1) $ take (max c d) s
      y =
        c < d ||
        ((> 2) $
         maximum $
         map
           (\ss ->
              if head ss /= '#'
                then length ss
                else 0) $
         group $ drop (b - 1) $ take (min c d + 1) s)