import std.stdio;
import std.regex;

void main(){
	auto io = new IO();
	
	auto S = io.line!string()[0];
	
	if ( S.have("N") ^ S.have("S") || S.have("W") ^ S.have("E") ){
		writeln("No");
	}else{
		writeln("Yes");
	}

	return;
}

import std.stdio,std.conv,std.string;
import std.algorithm,std.array,std.math;

class IO
{
	T[] line( T = size_t , string token = " " )( size_t m = 1 ){
		T[] arr = [];
		foreach( i ; 0..m ){
			arr ~= this.read!T();
		}
		return arr;
	}
	T[][] rect( T = size_t , string token = " " )( size_t m = 1 ){
		T[][] arr = new T[][](m);
		foreach( i ; 0..m ){
			arr[i] = this.read!T(token);
		}
		return arr;
	}
	private T[] read( T = size_t )( string token = " " ){
		T[] arr;
		foreach( elm ; readln().chomp().split(token) ){
			arr ~= elm.to!T();
		}
		return arr;
	}
}

// T -> T[]
pure T[] step( T = size_t )( in T begin , in T end , in T step = 1 ){
	T[] ret;
	for( T i = begin ; i < end ; i += step ){
		ret ~= i;
	}
	return ret;
}
unittest{
	assert( step(0,10,2) == [0,2,4,6,8] );
}

// T[] -> T[]
pure T[] fill( T )( T[] args , in T filling ){
	foreach( ref arg ; args ){
		arg = filling;
	}
	return args;
}
T[] map( T )( T[] args , T function(T) f ){
	foreach( ref arg ; args ){
		arg = f(arg);
	}
	return args;
}
unittest{
	assert( [true,false,true,false].fill(true) == [true,true,true,true] );
	assert( [1,-2,3,-4].map!int(x=>x*2) == [2,-4,6,-8] );
}
// T[] -> number
pure T sum( T )( in T[] args ){
	T ret = 0;
	foreach( i ; 0..args.length ){
		ret += args[i];
	}
	return ret;
}
pure T ave(T)( in T[] args ){
	return args.sum()/args.length;
}
pure real multi( in real[] args ){
	real ret = 1.0;
	foreach( i ; 0..args.length ){
		ret *= args[i];
	}
	return ret;
}

// T[] -> bool
pure bool any( T )( in T[] args , in T target ){
	foreach( arg ; args ){
		if( arg == target ){return true;}
	}
	return false;
}
pure bool all( T )( in T[] args , in T cond ){
	foreach( arg ; args ){
		if( arg != cond ){return false;}
	}
	return true;
}
pure bool have( T )( in T[] args , in T[] target ... ){
	bool[] found = new bool[](target.length);
	foreach( arg ; args ){
		foreach( i,t ; target ){
			if( arg == t ){
				found[i] = true;
			}
		}
	}
	foreach( f ; found ){
		if( f == false ){return false;}
	}
	return true;
}


unittest{
	assert( [1,2,3,4,5].sum() == 15 );
	assert( [1,2,3,4,5].ave() == 3 );
	assert( cmp( [0.3,0.3].multi() , 0.09 ) , "multi() test failed" );
	assert( cmp( [0.3,0.3,0.3].multi() , 0.027 ) , "multi() test failed" );
	
	assert( [1,1,1].all(1) == true );
	assert( [1,1,2].all(1) == false );
	assert( [1,1,2].any(2) == true );
	assert( [1,1,2].any(3) == false );
	
	assert( [1,2,3,4,5].have([1,3,5]) == true );
	assert( [1,2,3,4,5].have([1,3,5,7]) == false );
}
