### constant

RESULTS = {
  'A' => "Game Over : Cleared",
  'B' => "Game Over : Death by Hole",
  'C' => "Game Over : Death by Block",
  'D' => "Game Over : Death by Walking Goal",
  'E' => "Game Over : Gave Up" 
}

DIREC = {'LEFT' => -1, 'RIGHT' => 1}

### subroutines

def field(x, y)
  return nil if x < 0 || x >= $m || y >= $n
  return '#' if y < 0
  $flds[y][x]
end

def check()
  floor = field($sx, $sy - 1)
  return 'A' if floor == 'G'
  return 'B' if floor == 'B'
  return 'C' if field($sx, $sy) != '.'
  return 'D' if field($gx, $gy) != 'G'
  nil
end

def moveto(to)
  if $sx != to && field(to, $sy) == '.'
    if $sy > 0
      dx = (to < $sx) ? -1 : 1
      x = $sx + dx
      while x != to
        return nil if field(x, $sy - 1) == '.'
        x += dx
      end
    end

    $sx = to
  end
end

def push(dx)
  bxs = []
  x = $sx + dx
  f = field(x, $sy)
  while ! f.nil? && f != '.'
    return if f == 'C'
    bxs.unshift(x)
    x += dx
    f = field(x, $sy)
  end

  for bx in bxs
    blk = field(bx, $sy)
    $flds[$sy][bx] = '.'
    bx += dx
    next if bx < 0 || bx >= $m

    if blk != 'I'
      while field(bx, $sy - 1) == 'I'
        bx += dx
        f = field(bx, $sy)
        break if f.nil?
        if f != '.'
          bx -= dx
          break
        end
      end
    else
      while field(bx, $sy - 1) != '.'
        bx += dx
        f = field(bx, $sy)
        break if f.nil?
        if f != '.'
          bx -= dx
          break
        end
      end
    end

    $flds[$sy][bx] = blk if bx >= 0 && bx < $m
  end
end

def pull(dx)
  bx = $sx - dx
  x = $sx + dx
  fb = field(bx, $sy)
  fs = field(x, $sy)
  if fb != '.' && fb != 'C' && fs == '.'
    $flds[$sy][bx] = '.'
    $flds[$sy][$sx] = fb
    $sx = x
  end
end

def getdown(dx)
  x = $sx + dx
  y = $sy - 1
  if field(x, $sy) == '.' && field(x, y) == '.'
    $sx = x
    $sy = y
  end
end

def climb(dx)
  x = $sx + dx
  y = $sy + 1
  fn = field(x, $sy)
  if ! fn.nil? && fn != '.' && field($sx, y) == '.' && field(x, y) == '.'
    $sx = x
    $sy = y
  end
end

def exec_cmds(cmds)
  for cmd in cmds
    on_danger = (/[1-3]/ =~ field($sx, $sy - 1)) ? [$sx, $sy - 1] : nil

    case cmd[0]
    when 'MOVETO'
      moveto(cmd[1].to_i - 1)
    when 'PUSH'
      push(DIREC[cmd[1]])
    when 'PULL'
      pull(DIREC[cmd[1]])
    when 'GETDOWN'
      getdown(DIREC[cmd[1]])
    when 'CLIMB'
      climb(DIREC[cmd[1]])
    end

    c = check()
    return c if ! c.nil?

    if ! on_danger.nil?
      ox, oy = on_danger
      if ox != $sx || oy != $sy - 1
        fd = (field(ox, oy).to_i - 1).to_s
        $flds[oy][ox] = (fd == '0') ? '.' : fd
      end
    end

    changed = true
    while changed
      changed = false

      ($n - 1).downto(1) do |y|
        for x in (0...$m)
          if field(x, y - 1) == 'B' && field(x, y) != '.'
            $flds[y][x] = '.'
            changed = true
          end
        end
      end

      while field($sx, $sy - 1) == '.'
        $sy -= 1
        changed = true
      end

      for y in (1...$n)
        for x in (0...$m)
          fb = field(x, y)
          if fb != '.'
            y0 = y
            fbl = field(x - 1, y0 - 1)
            fbc = field(x    , y0 - 1)
            fbr = field(x + 1, y0 - 1)
            while (fbl.nil? || fbl == '.') && fbc == '.' &&
                (fbr.nil? || fbr == '.')
              y0 -= 1
              break if y0 == 0
              fbl = field(x - 1, y0 - 1)
              fbc = field(x    , y0 - 1)
              fbl = field(x + 1, y0 - 1)
            end
            if y != y0
              $flds[y][x] = '.'
              $flds[y0][x] = fb
              changed = true
            end
          end
        end
      end
    end

    c = check()
    return c if ! c.nil?
  end

  'E'
end

### main

loop do
  $m, $n = gets.split.map(&:to_i)
  break if ($m | $n) == 0

  $flds = $n.times.map{gets.strip}.reverse
  #p $flds

  tn = gets.to_i
  cmds = tn.times.map{gets.strip.split}
  #p cmds

  $sx = $sy = $gx = $gy = nil

  for y in (0...$n)
    for x in (0...$m)
      case $flds[y][x]
      when 'S'
        $sx = x
        $sy = y
        $flds[y][x] = '.'
      when 'G'
        $gx = x
        $gy = y
      end
    end
  end

  rcode = exec_cmds(cmds)

  puts RESULTS[rcode]
end