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 F[102][102];

void DFS(int Y, int X, int c) {
	//cout << Y << " " << X << endl;
	if (F[Y][X] != c || c != 0)
		return;
	F[Y][X] = 10;
	DFS(Y - 1, X, c);//???
					 //DFS(Y - 1, X+1, A_ito);//??????
	DFS(Y, X + 1, c);//???
					 //DFS(Y + 1, X+1, A_ito);//??????
	DFS(Y + 1, X, c);//???
					 //DFS(Y + 1, X-1, A_ito);//??????
	DFS(Y, X - 1, c);//???
					 //DFS(Y - 1, X-1, A_ito);//??????
}


int main()
{
	int xs, ys, xg, yg, n;
	int c, d, x, y;
	int W = 1, H = 1;

	while ((W != 0) && (H != 0)) {
		cin >> W >> H;
		cin >> xs >> ys >> xg >> yg >> n;
		for (int i = 1;i <= n;i++) {
			cin >> c >> d >> x >> y;
			if (d == 0) {
				F[x][y] = c;
				F[x][y + 1] = c;
				F[x + 1][y] = c;
				F[x + 1][y + 1] = c;
				F[x + 2][y] = c;
				F[x + 2][y + 1] = c;
				F[x + 3][y] = c;
				F[x + 3][y + 1] = c;
			}
			if (d == 1) {
				F[x][y] = c;
				F[x + 1][y] = c;
				F[x][y + 1] = c;
				F[x + 1][y + 1] = c;
				F[x][y + 2] = c;
				F[x + 1][y + 2] = c;
				F[x][y + 3] = c;
				F[x + 1][y + 3] = c;
			}
		}
		if (F[ys][xs] != 0)
			DFS(ys, xs, F[ys][xs]);

		if (F[yg][xg] == F[ys][xs]) {
			cout << "OK" << endl;
		}
		else { cout << "NG" << endl; }
		/*for (int i = 0;i < H;i++) {
			for (int j = 0;j < W;j++) {
				F[i][j] = 0;
			}
		}
		*/
	}

	return 0;
}

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

int n, w, h, sx, sy, gx, gy;
int t[102][102];

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

bool solve(int x, int y, int kind){
  if(x == gx && y == gy){
    return true;
  }
  t[y][x] = -1;

  for(int i = 0; i < 4; i++){
    int nx = x + dx[i];
    int ny = y + dy[i];

    if(0 <= nx && nx < w && 0 <= ny && ny < h && t[ny][nx] == kind){
      if(solve(nx, ny, kind)) return true;
    }
  }

  return false;
}

int main(){
  while(cin >> w >> h, w || h){
    memset(t, 0, sizeof(t));

    cin >> sx >> sy;
    cin >> gx >> gy;
    sx--;
    sy--;
    gx--;
    gy--;

    cin >> n;

    for(int i = 0; i < n; i++){
      int c, d, x, y;
      int ww, hh;
      cin >> c >> d >> x >> y;
      x--;
      y--;

      if(d == 0){
        ww = 4;
        hh = 2;
      }
      else{
        ww = 2;
        hh = 4;
      }

      for(int j = y; j < y + hh; j++){
        for(int k = x; k < x + ww; k++){
          t[j][k] = c;
        }
      }
    }

    /*
    for(int i = 0; i < h; i++){
      for(int j =0; j < w;j ++){
        cout<<t[i][j];
      }
      cout<<endl;
    }
    */

    bool ans = t[sy][sx] == 0 ? false : solve(sx, sy, t[sy][sx]);

    cout << (ans ? "OK" : "NG") << endl;
  }
}

C++: 
//インクルード文
#include <iostream>
#include <stack>
#include <vector>
#include <stdlib.h>
#include <cstdio>
#include <string>
//#include <assert.h>

//:std省略
using namespace std;

//グローバル変数
int f[1000][1000];

//マクロ指定
#define fc f[x + j][y + l] = c

//深さ優先探索( dfs = Depth - First Search )
void dfs(int a, int b, int c) {

	if (f[a][b] == c) {


		f[a][b] = 10;
		dfs(a + 1, b, c);
		dfs(a - 1, b, c);
		dfs(a, b + 1, c);
		dfs(a, b - 1, c);


	}

//	else return;

}

//メイン文
int main(){

	int w, h, n = 0;
	int i, j, l;
	int xs, ys; 
	int xg, yg;

	const int cnt = w + h;

	for(;;) {
		cin >> w >> h;

		
		if ( cnt == 0) break;
		
		for (i = 1; i <= h; ++i) {
			for (j = 1; j <= w; ++j) {
				f[i][j] = -1;
			}
		}

		cin >> xs >> ys;
		cin >> xg >> yg;
		cin >> n;

		for (i = 0; i < n; ++i) {
			int c, d, x, y;

			cin >> c >> d;
			cin >> x >> y;

			if (d == 0) {
				for (j = 0; j < 4; ++j) {
					for (l = 0; l < 2; ++l) {
						fc;
					}
				}
			}

			else {//d==1

				

				for (j = 0; j < 2; ++j) {
					for (l= 0; l < 4; ++l) {
						fc;
					}
				}
			}
		}
/*

			if (d == 0) {
				for (j = 0; j < 2; ++j) {
					for (l = 0; l < 4; ++l) {
						f[x + j][y + l] = c;
					}
				}
			}

			else {
				for (j = 0; j < 4; ++j) {
					for (l= 0; l < 2; ++l) {
						f[x + j][y + l] = c;
					}
				}
			}	
		}

*/


		dfs(xs, ys, f[xs][ys]);


//		char gg = 'OK';
//		char ggwp = 'NG';


		

		if (f[xg][yg] == 10) printf("OK\n");

		else 		         printf("NG\n");



			//			assert(i == 10);
			//			assert(i = 9);
			//			assert(i = 8);
			//			assert(i = 7);
			//			assert(i = 6);
			//			assert(i = 5);
			//			assert(i = 4);
			//			assert(i = 3);
			//			assert(i = 2);
			//			assert(i = 1);

		


	}
}

/*


20 20
1 1
9 9
7
2 0 1 1
5 1 1 3
2 1 3 3
1 1 5 2
5 1 7 3
2 0 2 7
2 0 6 8
20 20
9 9
1 1
6
2 0 1 1
1 0 5 1
2 1 1 3
5 0 1 7
3 1 5 5
4 1 8 5
0 0


*/

C++: #include<bits/stdc++.h>
#define range(i,a,b) for(int i = (a); i < (b); i++)
#define rep(i,b) range(i,0,b)
#define pb(a) push_back(a)
#define all(a) (a).begin(), (a).end()
#define debug(x) cout << "debug " << x << endl;
using namespace std;

bool isMaze;
int blocks[105][105], xg, yg, w,h;

void dfs(int target, int x, int y){
    if(x <= 0 || y <= 0 || x > w || y > h) return;
    if(x == xg && y == yg){
        isMaze = true;
        return;
    }
    if(blocks[y][x] != target || blocks[y][x] == 0){
        return;
    }

    blocks[y][x] = 0;
    
    dfs(target, x + 1, y);
    dfs(target, x - 1, y);
    dfs(target, x, y + 1);
    dfs(target, x, y - 1);
}

int main(){
    int xs, ys, n;
    while(cin >> w >> h, w||h){
        rep(i,105) rep(j,105) blocks[i][j] = 0;
        cin >> xs >> ys >> xg >> yg >> n;
        rep(i,n){
            int c, d, x, y;
            cin >> c >> d >> x >> y;
            if(d == 0){
                rep(j,2) rep(k,4) blocks[y + j][x + k] = c;
            }else{
                rep(j,4) rep(k,2) blocks[y + j][x + k] = c;
            }
        }
        isMaze = false;
        dfs(blocks[ys][xs], xs, ys);

        if(isMaze) cout << "OK" << endl;
        else cout << "NG" << endl;
    }
}