require 'stringio'

class Vector
  attr_accessor :x, :y

  def initialize(x, y)
    @x, @y = x.to_f, y.to_f
  end

  def -(other)
    dx = @x - other.x
    dy = @y - other.y
    Vector.new(dx, dy)
  end

  def magnitude
    Math.sqrt(@x * @x + @y * @y)
  end

  def self.cross(pt1, pt2)
    pt1.x * pt2.y - pt1.y * pt2.x
  end
end

class Command
  attr_accessor :direction, :distance

  def initialize(direction, distance)
    @direction, @distance = direction, distance.to_f
  end
end

class DataSet
  START_POINT = Vector.new(10, 10)
  attr_reader :gem_locations, :commands, :line_segments

  def initialize(gem_locations, commands)
    @gem_locations, @commands = gem_locations, commands
    @line_segments = get_line_segments
  end

  private
  def get_line_segments
    line_segments = []
    current = START_POINT.clone
    @commands.each { |command|
      dx, dy = 0, 0
      case command.direction
      when 'N'
        dy = command.distance
      when 'E'
        dx = command.distance
      when 'S'
        dy = -command.distance
      when 'W'
        dx = -command.distance
      end

      start = current.clone
      current.x += dx
      current.y += dy
      line_segments << [start, current.clone]
    }
    line_segments
  end
end

def read_data(data)
  datasets = []
  StringIO.open(data, 'r') { |f|
    loop {
      # Read number of gems
      n_gems = f.gets.to_i
      break if n_gems.nil? or n_gems.to_i == 0

      # Read gem locations
      gem_locations = []
      n_gems.times {
        x, y = f.gets.split(/\s+/).map(&:to_i)
        gem_locations << Vector.new(x, y)
      }

      # Read number of commands
      n_commnands = f.gets.to_i

      # Read commands
      commands = []
      n_commnands.times {
        direction, distance = f.gets.split(/\s+/)
        commands << Command.new(direction, distance.to_i)
      }
      datasets << DataSet.new(gem_locations, commands)
    }
  }
  datasets
end

def dot(pt1, pt2)
  pt1.x * pt2.x + pt1.y * pt2.y
end

def distance(vec0, vec1)
  Vector.cross(vec0, vec1).abs / vec0.magnitude
end

data = STDIN.read
datasets = read_data(data)

datasets.each { |dataset|
  judge = [false] * dataset.gem_locations.size
  dataset.gem_locations.each_with_index { |location, i|
    dataset.line_segments.each { |line_segment|
      next if dot(line_segment[1] - line_segment[0], location - line_segment[0]) < 0
      next if dot(line_segment[0] - line_segment[1], location - line_segment[1]) < 0

      vec0 = line_segment[1] - line_segment[0]
      vec1 = location - line_segment[0]
      d = distance(vec0, vec1)
      if d < 0.1
        judge[i] = true
        break
      end
    }
  }
  puts judge.all? ? 'Yes' : 'No'
}