Go: package main

import (
	"bufio"
	"os"
	"strings"
	"strconv"
	"fmt"
)

var scanner = bufio.NewScanner(os.Stdin)

var (
	dx = []int{0, -1, 0, 1}
	dy = []int{1, 0, -1, 0}
)

func main() {
	for scanner.Scan() {
		buf := strings.Split(scanner.Text(), " ")
		w, _ := strconv.Atoi(buf[0])
		h, _ := strconv.Atoi(buf[1])
		if w == 0 && h == 0 {
			break
		}
		scanner.Scan()
		buf_ := strings.Split(scanner.Text(), " ")
		xs, _ := strconv.Atoi(buf_[0])
		ys, _ := strconv.Atoi(buf_[1])
		scanner.Scan()
		buf__ := strings.Split(scanner.Text(), " ")
		xg, _ := strconv.Atoi(buf__[0])
		yg, _ := strconv.Atoi(buf__[1])
		xs--
		ys--
		xg--
		yg--
		scanner.Scan()
		n, _ := strconv.Atoi(scanner.Text())
		field := make([][]int, 100)
		for i := range  field {
			field[i] = make([]int, 100)
		}
		visited := make([][]bool, 100)
		for i := range visited {
			visited[i] = make([]bool, 100)
		}
		for i := 0; i < n; i++ {
			scanner.Scan()
			buf___ := strings.Split(scanner.Text(), " ")
			c, _ := strconv.Atoi(buf___[0])
			d, _ := strconv.Atoi(buf___[1])
			x, _ := strconv.Atoi(buf___[2])
			y, _ := strconv.Atoi(buf___[3])
			x--
			y--
			switch d {
			case 0:
				for j := 0; j < 4; j++ {
					for k := 0; k < 2; k++ {
						field[x+j][y+k] = c
					}
				}
			case 1:
				for j := 0; j < 2; j++ {
					for k := 0; k < 4; k++ {
						field[x+j][y+k] = c
					}
				}
			}
		}
		if field[xs][ys] != field[xg][yg] || // スタートとゴールの色が等しくないと"NG"
			field[xs][ys] == 0 { // スタートの色が無職
			fmt.Println("NG")
			continue
		}
		Q := make([]Entry, 0)
		visited[xs][ys] = true
		Q = append(Q, Entry{xs, ys})
		for len(Q) > 0 {
			row := Q[0].x
			col := Q[0].y
			Q = Q[1:]
			for i := 0; i < 4; i++ {
				if 0 <= row+dx[i] && row+dx[i] < w &&
					0 <= col+dy[i] && col+dy[i] < h && // 移動可能な範囲内かどうか
					!visited[row + dx[i]][col + dy[i]] && // 訪問済みか
					field[row+dx[i]][col+dy[i]]==field[row][col] { // 色が同じかどうか
						visited[row+dx[i]][col+dy[i]] = true
						Q = append(Q, Entry{row+dx[i],col+dy[i]})
				}
			}
		}
		if visited[xg][yg] {
			fmt.Println("OK")
		} else {
			fmt.Println("NG")
		}
	}
}

type Entry struct {
	x, y int
}

C++: #include <iostream>
using namespace std;

int map[102][102];

void route(int w, int h, int color) {
	if (map[w][h] != color)
		return;
	map[w][h] = 0;
	route(w, h + 1, color);
	route(w + 1, h, color);
	route(w, h - 1, color);
	route(w - 1, h, color);
}


int main() {
	int h, w, xs, ys, xg, yg, n;
	int c, d, x, y,color;

	while (1) {
		cin >> w >> h >> xs >> ys >> xg >> yg >> n;
		if (w == 0 && h == 0)
			break;

		for (int i = 0; i<n; i++) {
			cin >> c >> d >> x >> y;
			if (d == 0) {
				for (int j = 0; j < 4; j++)
					map[j + x][y] = map[j + x][y+1] = c;
			}
			else {
				for (int j = 0; j < 4; j++)
					map[x][y + j] = map[x + 1][y + j] = c;
			}
		}
		color = map[xs][ys];
		route(xs, ys, color);
		if (map[xg][yg]==0)
			cout << "OK" << endl;
		else
			cout << "NG"<<endl;
	}

	return 0;
}

C++: #include <bits/stdc++.h>

using namespace std;

#define all(c) (c).begin(), (c).end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)

int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};

int w, h;
int xs, ys;
int xg, yg;
int maze[102][102];

using P = pair<int, int>;
void solve() {
    int c = maze[ys][xs];
    queue<P> que;
    que.push(P(ys, xs));
    set<P> visited;
    visited.insert(P(ys, xs));
    bool ok = false;
    while (que.size()) {
        auto p = que.front();
        que.pop();
        int y = p.first;
        int x = p.second;
        if (yg == y && xg == x) ok = true;
        rep(k, 4) {
            int ny = y + dy[k];
            int nx = x + dx[k];
            if (ny < 0 || nx < 0) continue;
            if (h <= ny || w <= nx) continue;
            if (maze[ny][nx] != c) continue;
            if (visited.count(P(ny, nx))) continue;
            visited.insert(P(ny, nx));
            que.push(P(ny, nx));
        }
    }
    cout << (ok ? "OK" : "NG") << endl;
}

int main() {
    while (cin >> w >> h, w) {
        rep(i, 102) rep(j, 102) maze[i][j] = -1;
        cin >> xs >> ys;
        cin >> xg >> yg;
        int n;
        cin >> n;
        rep(_, n) {
            int c, d, x, y;
            cin >> c >> d >> x >> y;
            if (d == 0) {
                rep(i, 2) rep(j, 4) maze[y + i][x + j] = c;
            } else {
                rep(i, 4) rep(j, 2) maze[y + i][x + j] = c;
            }
        }
        solve();
    }

    return 0;
}

C++: #include<iostream>
using namespace std;
#define MAX 105

int map[MAX][MAX];
int xs, ys, xg, yg;
int n;
int w, h;
int c, d, x, y;
int count = 0;
int color;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};

void jadge(int x, int y){
	if(count == 0){
		if(0 <= x && x < w && 0 <= y && y < h && map[x][y] == color){
			map[x][y] = 9;
			if(x == xg && y == yg){
				count = 1;
				return;
			}
			for(int i=0; i < 4; i++){
				jadge(x+dx[i], y+dy[i]);
			}
		}
	}
}
int main(){
	while(1){
		count = 0;

		for(int i=0; i < MAX; i++){
			for(int j=0; j< MAX; j++){
				map[i][j] = 0;
			}
		}

		cin >> w >> h;
		if(w == 0 && h == 0) break;

		cin >> ys >> xs;
		cin >> yg >> xg;
		xs--; ys--; xg--; yg--;
		cin >> n;
		for(int i=0; i < n; i++){
			cin >> c >> d >> y >> x;

			for(int i=0;  i < 4; i++){
				for(int j=0; j < 2; j++){
					if(d == 1){
						map[x-1+i][y-1+j] = c;
					}
					else{
						map[x-1+j][y-1+i] = c;
					}
				}
			}
		}
		if(map[xs][ys] != map[xg][yg]){
			cout << "NG" << endl;
			continue;
		}
		else if(map[xs][ys] == 0 || map[xg][yg] == 0){
			cout << "NG" << endl;
			continue;
		}
		color = map[xs][ys];

		jadge(xs, ys);

		if(count == 1) cout << "OK" << endl;
		else cout << "NG" << endl;
	}
}

C++: #include<map>
#include<queue>
#include<cstdio>
#include<cstring>
#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#define SIZE 102
using namespace std;

typedef pair<int,int> P;

void input_data(void);  //データ入力用関数
void make_mass(void);   //マス作成用関数
void solve(void);       //処理

int n;             //ブロックの個数
int w,h;           //ボードの幅、高さ
int goal=0;        //迷路になっているか
int scolor;        //スタート位置の色
int sx,sy,gx,gy;   //スタートの座標、ゴールの座標
int mass[SIZE][SIZE];
int data[SIZE][SIZE];
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
int c[SIZE],d[SIZE],x[SIZE],y[SIZE];       //ブロックの色、向き、左上の座標


int main(){

  int i,j;             //カウンタ変数

  while(1){

    memset(mass,0,sizeof(mass));
    /*情報の入力*/
    cin>>w>>h;

    if(w==h && w==0){break;}
    
    input_data();
    
    make_mass();

    solve();
    if(scolor!=0 && mass[sy][sx]==mass[gy][gx]){
      if(goal==1){
	cout<<"OK"<<endl;
      } else {
	cout<<"NG"<<endl;
      }
    }
    else {
      cout<<"NG"<<endl;
    }
  }
  
  return 0;
}
void input_data(void){
  
  cin>>sx>>sy;
  cin>>gx>>gy;
  
  cin>>n;
  
  for(int i=0;i<n;i++){
    cin>>c[i]>>d[i]>>x[i]>>y[i];

  }
  
  return;
}
void make_mass(void){
  
  int i,j;
  
  /*マスの作成*/
  for(i=0;i<n;i++){
    switch(d[i]){
    case 0:              //横向きなら
      for(j=0;j<4;j++){
	mass[y[i]][x[i]+j]=c[i];
	mass[y[i]+1][x[i]+j]=c[i];
      }
      break;
    case 1:              //縦向きなら
      for(j=0;j<4;j++){
	mass[y[i]+j][x[i]]=c[i];
	mass[y[i]+j][x[i]+1]=c[i];
      }
      break;
    }
  }
  
  scolor=mass[sy][sx];
  
  for(i=0;i<h;i++){
    for(j=0;j<w;j++){
      if(scolor!=mass[i][j]){
	mass[i][j]=0;
      }
    }
  }
  
  return;
}
void solve(void){
  
  int i,j;
  queue<P> que;
  memset(data,-1,sizeof(data));
  que.push(P(sx,sy));     //queにスタート位置の座標を格納
  data[sy][sx]==0;
  
  while(!que.empty()){    //queが空でない間
    P p=que.front();
    que.pop();
    
    if(p.first==gx && p.second==gy){
      goal=1;
      /* cout<<" (^q^)くおえうえーーーるえうおおおwwww"<<endl;*/
      break;
    }
    for(i=0;i<4;i++){
      int nx=p.first+dx[i];
      int ny=p.second+dy[i];
      if(nx>=0 && nx<w && ny>=0 && ny<h && mass[ny][nx]!=0 && data[ny][nx]==-1){
	que.push(P(nx,ny));
	data[ny][nx]=1;
      }
    }
  }
  return;
}