Go: package main

import (
	"bufio"
	"fmt"
	"io"
	"math"
	"os"
	"strconv"
)

var (
	readString func() string
	readBytes  func() []byte
	stdout     *bufio.Writer
)

func init() {
	readString, readBytes = newReadString(os.Stdin)
	stdout = bufio.NewWriter(os.Stdout)
}

func newReadString(ior io.Reader) (func() string, func() []byte) {
	r := bufio.NewScanner(ior)
	r.Buffer(make([]byte, 1024), math.MaxInt32)
	r.Split(bufio.ScanWords)

	f1 := func() string {
		if !r.Scan() {
			panic("Scan failed")
		}
		return r.Text()
	}
	f2 := func() []byte {
		return []byte(f1())
	}
	return f1, f2
}

func readInt() int {
	return int(readInt64())
}

func readInt64() int64 {
	i, err := strconv.ParseInt(readString(), 10, 64)
	if err != nil {
		panic(err.Error())
	}
	return i
}

func readFloat64() float64 {
	f, err := strconv.ParseFloat(readString(), 64)
	if err != nil {
		panic(err.Error())
	}
	return f
}

func printf(f string, args ...interface{}) (int, error) {
	return fmt.Fprintf(stdout, f, args...)
}

func println(args ...interface{}) (int, error) {
	return fmt.Fprintln(stdout, args...)
}

func eprintln(args ...interface{}) (int, error) {
	return fmt.Fprintln(os.Stderr, args...)
}

func eprintf(f string, args ...interface{}) (int, error) {
	return fmt.Fprintf(os.Stderr, f, args...)
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func min64(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

func max(a, b int) int {
	if a < b {
		return b
	}
	return a
}

func max64(a, b int64) int64 {
	if a < b {
		return b
	}
	return a
}

func abs(a int) int {
	if a < 0 {
		return -a
	}
	return a
}

func abs64(a int64) int64 {
	if a < 0 {
		return -a
	}
	return a
}

func gcd(a, b int) int {
	if b == 0 {
		return a
	}
	return gcd(b, a%b)
}

func gcd64(a, b int64) int64 {
	if b == 0 {
		return a
	}
	return gcd64(b, a%b)
}

// readString() string
// readInt() int
// readInt64() int64
// readFloat64() float64

// -----------------------------------------------------------------------------

func main() {
	defer stdout.Flush()

	for {
		ans, ok := solve()
		if !ok {
			break
		}
		println(ans)
	}

}

func solve() (int, bool) {
	w := readInt()
	h := readInt()
	if w == 0 && h == 0 {
		return 0, false
	}

	c := make([][]int, h+2)
	c[0] = make([]int, w+2)
	c[h+1] = make([]int, w+2)
	for i := 1; i-1 < h; i++ {
		c[i] = make([]int, w+2)
		for j := 1; j-1 < w; j++ {
			c[i][j] = readInt()
		}
	}

	var ans int
	for i := 1; i-1 < h; i++ {
		for j := 1; j-1 < w; j++ {
			if 0 < c[i][j] {
				ans++
				dfs(c, i, j)
			}
		}
	}
	return ans, true
}

func dfs(c [][]int, y, x int) {
	c[y][x] = 0
	dx := []int{-1, 0, 1, -1, 1, -1, 0, 1}
	dy := []int{-1, -1, -1, 0, 0, 1, 1, 1}
	for i := range dx {
		nx := x + dx[i]
		ny := y + dy[i]
		if 0 < c[ny][nx] {
			dfs(c, ny, nx)
		}
	}
}

// -----------------------------------------------------------------------------

Python: while(1):
 w,h = map(int,input().split())
 if((w == 0)and(h == 0)): break

 Map = []
 Map.append(['@']*(w+2))
 land = []
 for i in range(h):
  c = list('@'+input().replace(' ', '')+'@')
  Map.append(c)
  for j in range(w+2):
   if(c[j] == '1'): land.append([i+1,j])
 Map.append(['@']*(w+2))
 #print(land)

 #深さ優先探索
 def dfs(start_x,start_y):
  stack = []
  stack.append([start_x,start_y])
  
  while(1):      
   #stackが空になると終了
   if(stack == []): return
  
   #座標の取り出し
   cord = stack.pop()
   x,y = cord[0],cord[1]
  
   #行き止まりor海なら何もしない
   if((Map[x][y] == '0')or(Map[x][y] == '@')): continue
   #訪問済みなら何もしない
   elif(vis[x][y] == 1): continue
   else:
    vis[x][y] = 1 #訪問済みに

   #次行くところ
   vec_x = [0,0,1,-1,1,-1,1,-1]
   vec_y = [1,-1,0,0,1,-1,-1,1]
   for i in range(8):
     if(Map[x+vec_x[i]][y+vec_y[i]] == '1'):
       stack.append([x+vec_x[i],y+vec_y[i]])    
  
 ans = 0
 vis = [[0]*(w+2) for _ in range(h+2)]
 for i in range(len(land)):
  start_x,start_y = land[i][0],land[i][1]
  if(vis[start_x][start_y] == 0):
      dfs(start_x,start_y)
      ans += 1
      #print('aaa')
 print(ans)

Python: from collections import deque
QUE=deque()


while True:
    w,h=map(int,input().split())
    
    if w==h==0:
        break
    
    MAP=[list(map(int,input().split())) for i in range(h)]
    ANSLIST=[[0 for i in range(w)] for j in range(h)]

    NOW=1

    for i in range(h):
        for j in range(w):
            if MAP[i][j]==0:
                continue
            if ANSLIST[i][j]!=0:
                continue
            
            QUE.append((i,j))
            while QUE:
                i,j=QUE.pop()
                for x,y in [(i-1,j-1),(i-1,j),(i-1,j+1),(i,j-1),(i,j),(i,j+1),(i+1,j-1),(i+1,j),(i+1,j+1)]:
                    if 0<=x<h and 0<=y<w and MAP[x][y]==1 and ANSLIST[x][y]==0:
                        ANSLIST[x][y]=NOW
                        QUE.append((x,y))

            NOW+=1

    #for an in ANSLIST:
    #    print(an)

    print(NOW-1)

Python: import math
import copy
import sys
import fractions
# import numpy as np
# import statistics
import decimal
import heapq
import collections
import itertools
import bisect


# from operator import mul

sys.setrecursionlimit(100001)


# input = sys.stdin.readline
# sys.setrecursionlimit(10**6)

# ===FUNCTION===

def getInputIntList():
    outputDataList = []
    inputData = input().split()
    outputDataList = [int(n) for n in inputData]

    return outputDataList


def getSomeInputInt(n):
    outputDataList = []
    for i in range(n):
        inputData = int(input())
        outputDataList.append(inputData)

    return outputDataList


def getSomeInputListInt(n):
    inputDataList = []
    outputDataList = []
    for i in range(n):
        inputData = input().split()
        inputDataList = [int(n) for n in inputData]
        outputDataList.append(inputDataList)

    return outputDataList


# ===CODE===

def dfs(x, y):
    flg = False
    if data[x][y] == 0 or table[x][y] == 1:
        return False
    else:
        table[x][y] = 1
        flg = True


    for i in range(x - 1, x + 2):
        if i < 0 or i > h-1:
            continue
        for j in range(y - 1, y + 2):
            if j < 0 or j > w-1:
                continue
            if not(x == i and y == j):
                tmp = dfs(i, j)

    return flg


while True:
    w, h = map(int, input().split())
    if w == 0 and h == 0:
        break

    data = getSomeInputListInt(h)
    table = [[0 for _ in range(w)] for _ in range(h)]

    ans = 0
    for i in range(h):
        for j in range(w):
            if dfs(i, j):
                ans += 1

    print(ans)

Python: from collections import deque


def dfs(G, start):
    S = deque()
    child = deque()
    VL[start[1]][start[0]] = 1
    S.append(start)
    while len(S) > 0:
        node = S.pop()
        for i in range(len(dx)):
            child.clear()
            nx = node[0] + dx[i]
            ny = node[1] + dy[i]

            if nx < 0 or nx >= W or ny < 0 or ny >= H:
                continue
            if G[ny][nx] == 0:
                continue
            if VL[ny][nx] == 1:
                continue

            child.append((nx, ny))

            if len(child) > 0:
                for c in child:
                    VL[c[1]][c[0]] = 1
                    S.append(c)


ok = True
while ok:
    W, H = map(int, input().split())

    if W == 0 and H == 0:
        break

    G = [list(map(int, input().split())) for _ in range(H)]
    VL = [[0 for _ in range(W)] for _ in range(H)]

    dx = [1, 0, -1, 0, 1, 1, -1, -1]
    dy = [0, 1, 0, -1, 1, -1, 1, -1]

    res = 0
    for i in range(H):
        for j in range(W):
            if G[i][j] == 1 and VL[i][j] == 0:
                dfs(G, (j, i))
                res += 1

    print(res)