Go: package main

import (
	"fmt"
)

func main() {
	var h, w int
	for {
		fmt.Scan(&w, &h)
		if w == 0 && h == 0 {
			return
		}
		matrix := make([][]int, h)
		Sean := make([][]bool, h)
		for i := 0; i < h; i++ {
			matrix[i] = make([]int, w)
			Sean[i] = make([]bool, w)
			for j := 0; j < w; j++ {
				fmt.Scan(&matrix[i][j])
			}
		}
		var count int
		for i := 0; i < h; i++ {
			for j := 0; j < w; j++ {
				if matrix[i][j] == 1 && Sean[i][j] == false {
					search(i, j, h, w, matrix, Sean)
					count++
				}
			}
		}
		fmt.Println(count)
	}
}
func search(x int, y int, h int, w int, matrix [][]int, Sean [][]bool) {
	if x < 0 || y < 0 || x >= h || y >= w || matrix[x][y] == 0 {
		return
	}
	if Sean[x][y] == true {
		return
	}

	Sean[x][y] = true

	search(x+1, y, h, w, matrix, Sean)
	search(x-1, y, h, w, matrix, Sean)
	search(x, y+1, h, w, matrix, Sean)
	search(x, y-1, h, w, matrix, Sean)
	search(x+1, y-1, h, w, matrix, Sean)
	search(x-1, y+1, h, w, matrix, Sean)
	search(x+1, y+1, h, w, matrix, Sean)
	search(x-1, y-1, h, w, matrix, Sean)
}

C++: #include <bits/stdc++.h>
using namespace std;

struct UnionFind {
    vector<int> data;
    int sz;
    UnionFind(int sz) : data(sz, -1), sz(sz) { }
    bool unionSet(int x, int y) {
        if ((x = root(x)) == (y = root(y))) return false;
        if (data[x] > data[y]) swap(x, y);
        data[x] += data[y]; data[y] = x; sz--;
        return true;
    }
    bool findSet(int x, int y) { return root(x) == root(y); }
    int root(int x) { return data[x] < 0 ? x : data[x] = root(data[x]); }
    int size(int x) { return -data[root(x)]; }
    int size() { return sz; }
};

int X[8] = {1, 1, 0, -1, -1, -1, 0, 1};
int Y[8] = {0, 1, 1, 1, 0, -1, -1, -1};

int main(){
    while(true){
    int H, W;
    cin >> W >> H;
    if(H == 0 && W == 0)break;
    vector<vector<bool>> F(H, vector<bool>(W));
    UnionFind uf(H * W);
    for(int i = 0; i < H; i++){
        for(int j = 0; j < W; j++){
            int a;cin >> a;
            if(a == 0)F[i][j] = false;
            else F[i][j] = true;
        }
    }
    
    for(int i = 0; i < H; i++){
        for(int j = 0; j < W; j++){
            if(F[i][j]){
                for(int X = -1; X <= 1; X++){
                    for(int Y = -1; Y <= 1; Y++){
                    int x = j + X;
                    int y = i + Y;
                    if(x < 0 || W <= x || y < 0 || H <= y)continue;
                    else if(F[y][x])uf.unionSet(i * W + j, y * W + x);
                    }
                }
            }
        }
    }
    /*
    set<int> R;
    for(int i = 0; i < H * W; i++)R.insert(uf.root(i));
    //cout << uf.root(2) << endl;
    int ans = R.size();
    //cout << ans << endl;
    */
    int ans = uf.size();
    for(int i = 0; i < H; i++){
        for(int j = 0; j < W; j++){
            if(F[i][j])continue;
            else ans--;
        }
    }
    
    cout << ans << endl;
    }
    return 0;
}

C++: #include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<cmath>
#include<stack>
#include<queue>
#include<map>
#include<set>

using namespace std;

typedef long long ll;
typedef vector<int> VI;

#define FOR(i,n) for(int (i)=0;(i)<(n);(i)++)
#define FOR1(i,n) for(int (i)=1;(i)<(n);(i)++)
#define eFOR(i,n) for(int (i)=0;(i)<=(n);(i)++)
#define eFOR1(i,n) for(int (i)=1;(i)<=(n);(i)++)
#define SORT(i) sort((i).begin(),(i).end())
constexpr auto INF = 1000000000;
constexpr auto LLINF = 9223372036854775807;
constexpr auto mod = 1000000007;

int w, h, c[50][50];
int dx[8] = { -1,0,1,-1,1,-1,0,1 }, dy[8] = { -1,-1,-1,0,0,1,1,1 };
void search(int x, int y) {
	if (x >= 0 && x < w && y >= 0 && y < h) {
		if (c[y][x] == 1) {
			c[y][x] = 0;
			FOR(k, 8)search(x + dx[k], y + dy[k]);
		}
	}
}

int main() {
	while (1) {
		cin >> w >> h;
		if (w == 0 && h == 0)break;
		FOR(i, h)FOR(j, w)cin >> c[i][j];
		int cnt = 0;
		FOR(i, h)FOR(j, w)if (c[i][j] == 1) {
			search(j, i);
			cnt++;
		}
		cout << cnt << endl;
	}
	

	return 0;
}

C++: #include<iostream>
#include<algorithm>
#include<stack>
#include<queue>
#include<string.h>
#include<string>
#include<functional>
#include<set>
using namespace std;

#define INF 1<<21
#define DIV 1000000007
#define MAX 250000

int table[51][51];
int W, H;

void dfs(int x, int y) {
  table[y][x] = 0;

  for (int dx = -1; dx <= 1; dx++) {
	for (int dy = -1; dy <= 1; dy++) {
	  int nx = x + dx, ny = y + dy;
	  if (0 <= nx&&nx < W && 0 <= ny&&ny < H&&table[ny][nx] == 1)dfs(nx, ny);
	}
  }
  return;
}

int main(){
  while (cin >> W >> H, W || H) {
	int ans = 0;
	memset(table, 0, sizeof(table));
	int t;
	for (int y = 0; y < H; y++) {
	  for (int x = 0; x < W; x++) {
		cin >> table[y][x];
	  }
	}

	for (int y = 0; y < H; y++) {
	  for (int x = 0; x < W; x++) {
		if (table[y][x] == 1) {
		  dfs(x, y);
		  ans++;
		}
	  }
	}
	cout << ans << endl;
  }

}

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

#define REP(i, n) for(int i = 0; i < (int)(n); i++)
#define INF  numeric_limits<int>::max()
#define NINF numeric_limits<int>::min()

using namespace std;
using ll = long long;

int W, H;
bool sea_map[50][50];
bool is_reached[50][50];

void dfs(int s_wi, int s_hi) {
    if(s_wi < 0 || W <= s_wi ||
       s_hi < 0 || H <= s_hi ||
       !sea_map[s_hi][s_wi]  ||
       is_reached[s_hi][s_wi]) {
        return;
    }

    is_reached[s_hi][s_wi] = true;

    dfs(s_wi + 1, s_hi + 1);
    dfs(s_wi + 1, s_hi    );
    dfs(s_wi + 1, s_hi - 1);
    dfs(s_wi    , s_hi - 1);
    dfs(s_wi - 1, s_hi - 1);
    dfs(s_wi - 1, s_hi    );
    dfs(s_wi - 1, s_hi + 1);
    dfs(s_wi    , s_hi + 1);
}

bool search_start_point(int& s_wi, int& s_hi) {
    REP(hi, H) {
        REP(wi, W) {
            if(sea_map[hi][wi] && !is_reached[hi][wi]) {
                s_wi = wi;
                s_hi = hi;
                return true;
            }
        }
    }
    return false;
}

int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);

    while(true) {
        std::cin >> W >> H;
        if(W == 0 && H == 0) {
            break;
        }

        REP(hi, H) {
            REP(wi, W) {
                std::cin >> sea_map[hi][wi];
                is_reached[hi][wi] = false;
            }
        }

        int ans = 0;
        while(true) {
            int s_wi, s_hi;
            if(!search_start_point(s_wi, s_hi)) {
                break;
            }
            else {
                dfs(s_wi, s_hi);
                ans++;
            }
        }

        std::cout << ans << std::endl;
    }

    return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;
#define int long long
#define all(v) (v).begin(), (v).end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define endl '\n'

const int N = 51;
int w,h;
int board[N][N];

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

void dfs(int x, int y){
    board[x][y] = 0;
    for(int i = 0; i < 8; i++){
        int nx = x + dx[i];
        int ny = y + dy[i];
        if(nx >= 0 && nx < h && ny >= 0 && ny < w){
            if(board[nx][ny] == 1) dfs(nx,ny);
        }
    }
}

void solve(){
    rep(i,h){
        rep(j,w) {
            cin >> board[i][j];
        }
    }

    int ans = 0;
    for(int i = 0; i < h; i++){
        for(int j = 0; j < w; j++){
            if(board[i][j] == 1) {
                ans++;
                dfs(i,j);
            }
        }
    }
    cout << ans << endl;
}

signed main() {
    while(true){
        cin >> w >> h;
        if(w == 0 && h == 0) return 0;
        solve();
    }
}