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)
}

Python: while True:
    w, h = map(int, input().split())
    if w == 0 and h == 0:
        break
    cnt = 0
    maps = [list(map(int, input().split())) for _ in range(h)]
    for x in range(w):
        for y in range(h):
            if maps[y][x] == 0:
                continue
            else:
                cnt += 1
                maps[y][x] = 0
                stack = [(y, x)]
                while stack:
                    f_y, f_x = stack.pop()
                    for dy in range(-1, 2):
                        for dx in range(-1, 2):
                            t_y = f_y + dy
                            t_x = f_x + dx
                            if 0 <= t_y <= h - 1 and 0 <= t_x <= w - 1 and maps[t_y][t_x] == 1:
                                maps[t_y][t_x] = 0
                                stack.append((t_y, t_x))
    print(cnt)

Python: class UnionSet:
        def __init__(self, nmax):
            self.size = [1]*nmax
            self.id = [i for i in range(nmax+1)]
        def root(self, i):
            while i != self.id[i]:
                self.id[i] = self.id[self.id[i]]
                i = self.id[i]
            return i
        def connected(self, p, q): return self.root(p) == self.root(q)
        def unite(self, p, q):
            i, j = self.root(p), self.root(q)
            if i == j: return
            if self.size[i] < self.size[j]:
                self.id[i] = j
                self.size[j] += self.size[i]
            else:
                self.id[j] = i
                self.size[i] += self.size[j]
    # UNION-FIND library
     
def id(r, c):
        global w
        return r*w+c

mv = [[-1,-1],[-1,0],[-1,1],[0,-1],[0,1],[1,-1],[1,0],[1,1]]

while True:
        w, h = map(int, input().split())
        if w == 0: break
        arr = [[] for r in range(h)]
        u = UnionSet(w*h)
        for r in range(h): arr[r] = list(map(int, input().split()))
        for r in range(h):
                for c in range(w):
                        if not arr[r][c]: continue
                        for i in range(8):
                                r2, c2 = r + mv[i][0], c + mv[i][1]
                                if r2 < 0 or r2 >= h or c2 < 0 or c2 >= w or not arr[r2][c2]: continue
                                u.unite(id(r, c), id(r2, c2))
        ans = 0
        for r in range(h):
                for c in range(w):
                        if arr[r][c] and u.root(id(r, c)) == id(r, c): ans += 1
        print(ans)

Python: import sys
import itertools
# import numpy as np
import time
import math
 
sys.setrecursionlimit(10 ** 7)
 
from collections import defaultdict
 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

while True:
    W, H = map(int, input().split())
    if W == 0 and H == 0:
        break
    W = W + 2
    H = H + 2
    A = [0] * H
    for i in range(H):
        if i == 0 or i == H - 1:
            A[i] = ['#'] * W
        else:
            A[i] = ['#'] + list(map(int, input().split())) + ['#']
    checked = [[False] * W for _ in range(H)]

    def dfs(s):
        dirs = [(1,0),(1,1),(0,1),(-1,1),(-1,0),(-1,-1),(0,-1),(1,-1)]
        x, y = s
        if checked[x][y]:
            return False
        if A[x][y] == 0:
            return False

        checked[x][y] = True
        for d in dirs:
            dx, dy = d
            if A[x + dx][y + dy] == '#':
                continue
            if checked[x + dx][y + dy]:
                continue
            if A[x + dx][y + dy] == 1:
                dfs((x + dx, y + dy))
        return True

    ans = 0
    for i in range(1, H - 1):
        for j in range(1, W - 1):
            if dfs((i, j)):
                ans += 1
    print(ans)

Python: def erase(x, y):
    c[y][x] = '0'
    for dx, dy in ((1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1), (0, -1), (1, -1)):
        nx, ny = x + dx, y + dy
        if 0 <= nx <= w -1 and 0 <= ny <= h - 1:
            if c[ny][nx] == '1':
                erase(nx, ny)

while True:
    w, h = map(int, input().split())
    c = [[i for i in input().split()] for _ in range(h)]
    ans = 0
    for y in range(h):
        for x in range(w):
            if c[y][x] == '1':
                ans += 1
                erase(x, y)
    print(ans)

Python: from collections import deque
while True:
    w,h=map(int,input().split())
    if w==0 and h==0:
        exit()
    field=[input().split() for i in range(h)]
    
    option=deque()
    for i in range(h):
        for j in range(w):
            if field[i][j]=="1":
                option.append([i,j])
                break
        else:
            continue
        break
    completed=[[0]*w for i in range(h)]
    cnt=1
    while option:
        y,x=option.pop()
        completed[y][x]=cnt
        for dy,dx in ((-1,0),(1,0),(0,-1),(0,1),(-1,-1),(1,-1),(-1,1),(1,1)):
            if 0<=y+dy<=h-1 and 0<=x+dx<=w-1 and field[y+dy][x+dx]=="1" and completed[y+dy][x+dx]==0:
                ny=y+dy
                nx=x+dx
                option.append([ny,nx])
        if len(option)==0:
            for i in range(h):
                for j in range(w):
                    if field[i][j]=="1" and completed[i][j]==0:
                        option.append([i,j])
                        cnt+=1
                        break
                else:
                    continue
                break
    ans=0
    for i in completed:
        tmp=max(i)
        ans=max(ans,tmp)
    print(ans)

Python: import sys
sys.setrecursionlimit(2500)
def dfs(i, j):
    global visited
    visited[i][j] = True
    for ii in [i - 1, i, i + 1]:
        for jj in [j - 1, j, j + 1]:
            if c[ii][jj] and not visited[ii][jj]:
                dfs(ii, jj)

w_list = []
h_list = []
c_list = []
while True:
    w, h = [int(x) for x in input().split()]
    if w == h == 0: break
    # dfsの条件分岐を減らすために、周りを海で囲む
    c = [[0 for _ in range(w + 2)]] + \
        [[0] + [int(x) for x in input().split()] + [0] for _ in range(h)] + \
        [[0 for _ in range(w + 2)]]
    w_list.append(w)
    h_list.append(h)
    c_list.append(c)

for w, h, c in zip(w_list, h_list, c_list):
    visited = [[False for _ in range(w + 2)] for _ in range(h + 2)]
    ans = 0
    for i in range(1, h + 1):
        for j in range(1, w + 1):
            if c[i][j] == 1 and not visited[i][j]:
                ans += 1
                dfs(i, j)
    print(ans)