// -*- coding:utf-8-unix -*- // #![feature(map_first_last)] #![allow(dead_code)] #![allow(unused_imports)] #![allow(unused_macros)] use std::collections::*; use std::convert::*; use std::convert::{From, Into}; use std::fmt::Debug; use std::fs::File; use std::io::prelude::*; use std::io::*; use std::marker::Copy; use std::mem::*; use std::ops::Bound::*; use std::ops::{Add, Mul, Neg, Sub}; use std::str; use std::vec; use std::{cmp, process::Output}; use std::{cmp::Ordering, env::consts::DLL_PREFIX}; use std::{cmp::Ordering::*, f32::consts::PI}; const INF: i64 = 1223372036854775807; const UINF: usize = INF as usize; const FINF: f64 = 122337203685.0; const INF128: i128 = 1223372036854775807000000000000; const LINF: i64 = 2147483647; const MOD: i64 = 1000000007; // const MOD: i64 = 998244353; const T: bool = true; const F: bool = false; const MPI: f64 = 3.14159265358979323846264338327950288f64; // const MOD: i64 = INF; const UMOD: usize = MOD as usize; use std::cmp::*; use std::collections::*; use std::io::stdin; use std::io::stdout; use std::io::Write; macro_rules! p { ($x:expr) => { println!("{}", $x); }; } macro_rules! d { ($x:expr) => { println!("{:?}", $x); }; } macro_rules! dd { (x:expr) => { dbg!(x); }; } macro_rules! chmin { ($base:expr, $($cmps:expr),+ $(,)*) => {{ let cmp_min = min!($($cmps),+); if $base > cmp_min { $base = cmp_min; true } else { false } }}; } macro_rules! chmax { ($base:expr, $($cmps:expr),+ $(,)*) => {{ let cmp_max = max!($($cmps),+); if $base < cmp_max { $base = cmp_max; true } else { false } }}; } macro_rules! min { ($a:expr $(,)*) => {{ $a }}; ($a:expr, $b:expr $(,)*) => {{ std::cmp::min($a, $b) }}; ($a:expr, $($rest:expr),+ $(,)*) => {{ std::cmp::min($a, min!($($rest),+)) }}; } macro_rules! max { ($a:expr $(,)*) => {{ $a }}; ($a:expr, $b:expr $(,)*) => {{ std::cmp::max($a, $b) }}; ($a:expr, $($rest:expr),+ $(,)*) => {{ std::cmp::max($a, max!($($rest),+)) }}; } // use str::Chars; // use str::Chars; #[allow(dead_code)] fn read() -> T { let mut s = String::new(); std::io::stdin().read_line(&mut s).ok(); s.trim().parse().ok().unwrap() } #[allow(dead_code)] fn readi() -> (i64) { let mut str = String::new(); let _ = stdin().read_line(&mut str).unwrap(); let mut iter = str.split_whitespace(); iter.next().unwrap().parse::().unwrap() } #[allow(dead_code)] fn read_vec() -> Vec { read::() .split_whitespace() .map(|e| e.parse().ok().unwrap()) .collect() } #[allow(dead_code)] fn read_vec2(n: u32) -> Vec> { (0..n).map(|_| read_vec()).collect() } #[allow(dead_code)] fn readii() -> (i64, i64) { let mut str = String::new(); let _ = stdin().read_line(&mut str).unwrap(); let mut iter = str.split_whitespace(); ( iter.next().unwrap().parse::().unwrap(), iter.next().unwrap().parse::().unwrap(), ) } fn readff() -> (f64, f64) { let mut str = String::new(); let _ = stdin().read_line(&mut str).unwrap(); let mut iter = str.split_whitespace(); ( iter.next().unwrap().parse::().unwrap(), iter.next().unwrap().parse::().unwrap(), ) } #[allow(dead_code)] fn readiii() -> (i64, i64, i64) { let mut str = String::new(); let _ = stdin().read_line(&mut str).unwrap(); let mut iter = str.split_whitespace(); ( iter.next().unwrap().parse::().unwrap(), iter.next().unwrap().parse::().unwrap(), iter.next().unwrap().parse::().unwrap(), ) } #[allow(dead_code)] fn readuu() -> (usize, usize) { let mut str = String::new(); let _ = stdin().read_line(&mut str).unwrap(); let mut iter = str.split_whitespace(); ( iter.next().unwrap().parse::().unwrap(), iter.next().unwrap().parse::().unwrap(), ) } fn readcc() -> (char, char) { let mut str = String::new(); let _ = stdin().read_line(&mut str).unwrap(); let mut iter = str.split_whitespace(); ( iter.next().unwrap().parse::().unwrap(), iter.next().unwrap().parse::().unwrap(), ) } #[allow(dead_code)] fn readuuu() -> (usize, usize, usize) { let mut str = String::new(); let _ = stdin().read_line(&mut str).unwrap(); let mut iter = str.split_whitespace(); ( iter.next().unwrap().parse::().unwrap(), iter.next().unwrap().parse::().unwrap(), iter.next().unwrap().parse::().unwrap(), ) } #[allow(dead_code)] fn readuuuu() -> (usize, usize, usize, usize) { let mut str = String::new(); let _ = stdin().read_line(&mut str).unwrap(); let mut iter = str.split_whitespace(); ( iter.next().unwrap().parse::().unwrap(), iter.next().unwrap().parse::().unwrap(), iter.next().unwrap().parse::().unwrap(), iter.next().unwrap().parse::().unwrap(), ) } fn readiiii() -> (i64, i64, i64, i64) { let mut str = String::new(); let _ = stdin().read_line(&mut str).unwrap(); let mut iter = str.split_whitespace(); ( iter.next().unwrap().parse::().unwrap(), iter.next().unwrap().parse::().unwrap(), iter.next().unwrap().parse::().unwrap(), iter.next().unwrap().parse::().unwrap(), ) } fn djikstra(graph: &Vec>, start: usize) -> Vec { let mut dist = vec![INF as usize; graph.len()]; let mut heap = BinaryHeap::new(); heap.push(Reverse((0 as usize, start))); dist[start] = 0; while let Some(Reverse(x)) = heap.pop() { let cost = x.0; let v = x.1; if cost > dist[v] { continue; } for edge in &graph[v] { let nc = cost + edge.1; let nv = edge.0; if nc < dist[nv] { heap.push(Reverse((nc, nv))); dist[nv] = nc; } } } return dist; } fn solve() { let (h, w) = readuu(); let mut s = String::new(); std::io::stdin().read_line(&mut s).unwrap(); let mut s = s.split_whitespace(); let mut u: usize = s.next().unwrap().parse().unwrap(); let mut d: usize = s.next().unwrap().parse().unwrap(); let mut r: usize = s.next().unwrap().parse().unwrap(); let mut l: usize = s.next().unwrap().parse().unwrap(); let mut k: usize = s.next().unwrap().parse().unwrap(); let mut p: usize = s.next().unwrap().parse().unwrap(); let mut s = String::new(); std::io::stdin().read_line(&mut s).unwrap(); let mut s = s.split_whitespace(); let mut s1: usize = s.next().unwrap().parse().unwrap(); let mut s2: usize = s.next().unwrap().parse().unwrap(); let mut t1: usize = s.next().unwrap().parse().unwrap(); let mut t2: usize = s.next().unwrap().parse().unwrap(); s1 -= 1; s2 -= 1; t1 -= 1; t2 -= 1; let mut graph = vec![vec![(0 as usize, 0 as usize); (0) as usize]; (h * w) as usize]; let mut s = 0; let mut g = h * w - 1; let mut vv: Vec> = vec![vec!['0' as char; (0) as usize]; (h) as usize]; for i in 0..h { let s: String = read(); let vvv = s.chars().collect(); vv[i] = vvv; } for i in 0..h { for j in 0..w { let v = i * w + j; for ii in -1..=1 { for jj in -1..=1 { if (ii * jj as i32).abs() == 1 || (ii == 0 && jj == 0) { continue; } if i == 0 && ii == -1 { continue; } if i == h - 1 && ii == 1 { continue; } if j == 0 && jj == -1 { continue; } if j == w - 1 && jj == 1 { continue; } let nv = ((i as i32 + ii) as usize, (j as i32 + jj) as usize); let mut d = 0; let mut nc = 0; if ii == -1 { nc = u; } else if ii == 1 { nc = d; } else if jj == -1 { nc = l; } else if jj == 1 { nc = r; } if vv[nv.0][nv.1] == '@' { nc += p; } if vv[nv.0][nv.1] == '#' { nc = UINF; } let nv = w * nv.0 + nv.1; graph[v].push((nv, nc)); } } } } // println!("{:?}", graph.clone()); // println!("{:?}", (s, g)); let mut d = djikstra(&graph, s1 * w + s2); // println!("{:?}", d); let mut res = d[t1 * w + t2]; if res <= k { p!("Yes"); return; } else { p!("No"); } return; } fn main() { solve(); }