  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)