You are given a marine area map that is a mesh of squares, each representing either a land or sea area. Figure B-1 is an example of a map.

<image>
Figure B-1: A marine area map

You can walk from a square land area to another if they are horizontally, vertically, or diagonally adjacent to each other on the map. Two areas are on the same island if and only if you can walk from one to the other possibly through other land areas. The marine area on the map is surrounded by the sea and therefore you cannot go outside of the area on foot.

You are requested to write a program that reads the map and counts the number of islands on it. For instance, the map in Figure B-1 includes three islands.

Input

The input consists of a series of datasets, each being in the following format.

> w h
>  c1,1 c1,2 ... c1,w
>  c2,1 c2,2 ... c2,w
>  ...
>  ch,1 ch,2 ... ch,w
>

w and h are positive integers no more than 50 that represent the width and the height of the given map, respectively. In other words, the map consists of w×h squares of the same size. w and h are separated by a single space.

ci, j is either 0 or 1 and delimited by a single space. If ci, j = 0, the square that is the i-th from the left and j-th from the top on the map represents a sea area. Otherwise, that is, if ci, j = 1, it represents a land area.

The end of the input is indicated by a line containing two zeros separated by a single space.

Output

For each dataset, output the number of the islands in a line. No extra characters should occur in the output.

Sample Input


1 1
0
2 2
0 1
1 0
3 2
1 1 1
1 1 1
5 4
1 0 1 0 0
1 0 0 0 0
1 0 1 0 1
1 0 0 1 0
5 4
1 1 1 0 1
1 0 1 0 1
1 0 1 0 1
1 0 1 1 1
5 5
1 0 1 0 1
0 0 0 0 0
1 0 1 0 1
0 0 0 0 0
1 0 1 0 1
0 0


Output for the Sample Input


0
1
1
3
1
9






Example

Input

1 1
0
2 2
0 1
1 0
3 2
1 1 1
1 1 1
5 4
1 0 1 0 0
1 0 0 0 0
1 0 1 0 1
1 0 0 1 0
5 4
1 1 1 0 1
1 0 1 0 1
1 0 1 0 1
1 0 1 1 1
5 5
1 0 1 0 1
0 0 0 0 0
1 0 1 0 1
0 0 0 0 0
1 0 1 0 1
0 0


Output

0
1
1
3
1
9
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;

public class Main {
  static InputStream is;
  static PrintWriter out;
  static String INPUT = "";
  static int H;
  static int W;
  static int[][] field;
  static int[] dirx = { -1, 0, 1, 0 };
  static int[] diry = { 0, 1, 0, -1 };

  static void solve() {
    Scanner sc = new Scanner(System.in);

    while (sc.hasNext()) {
      W = sc.nextInt();
      H = sc.nextInt();

      if (W == 0 || H == 0) {
        break;
      }

      field = new int[H][W];
      for (int h = 0; h < H; h++) {
        for (int w = 0; w < W; w++) {
          field[h][w] = sc.nextInt();
        }
      }

      int count = 0;
      for (int h = 0; h < H; h++) {
        for (int w = 0; w < W; w++) {
          if (field[h][w] == 0)
            continue;
          dfs(h, w);
          count++;
        }
      }

      out.println(count);
    }

    sc.close();
  }

  public static void dfs(int h, int w) {
    field[h][w] = 0;

    for (int dh = -1; dh <= 1; dh++) {
      for (int dw = -1; dw <= 1; dw++) {
        int nh = h + dh, nw = w + dw;

        if (nh < 0 || nh >= H || nw < 0 || nw >= W) {
          continue;
        }

        if (field[nh][nw] == 0) continue;

        dfs(nh, nw);
      }
    }
  }

  public static void main(String[] args) throws Exception {
    long S = System.currentTimeMillis();
    is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
    out = new PrintWriter(System.out);

    solve();
    out.flush();
    long G = System.currentTimeMillis();
    tr(G - S + "ms");
  }

  private static boolean eof() {
    if (lenbuf == -1)
      return true;
    int lptr = ptrbuf;
    while (lptr < lenbuf)
      if (!isSpaceChar(inbuf[lptr++]))
        return false;

    try {
      is.mark(1000);
      while (true) {
        int b = is.read();
        if (b == -1) {
          is.reset();
          return true;
        } else if (!isSpaceChar(b)) {
          is.reset();
          return false;
        }
      }
    } catch (IOException e) {
      return true;
    }
  }

  private static byte[] inbuf = new byte[1024];
  static int lenbuf = 0, ptrbuf = 0;

  private static int readByte() {
    if (lenbuf == -1)
      throw new InputMismatchException();
    if (ptrbuf >= lenbuf) {
      ptrbuf = 0;
      try {
        lenbuf = is.read(inbuf);
      } catch (IOException e) {
        throw new InputMismatchException();
      }
      if (lenbuf <= 0)
        return -1;
    }
    return inbuf[ptrbuf++];
  }

  private static boolean isSpaceChar(int c) {
    return !(c >= 33 && c <= 126);
  }

  private static int skip() {
    int b;
    while ((b = readByte()) != -1 && isSpaceChar(b))
      ;
    return b;
  }

  private static double nd() {
    return Double.parseDouble(ns());
  }

  private static char nc() {
    return (char) skip();
  }

  private static String ns() {
    int b = skip();
    StringBuilder sb = new StringBuilder();
    while (!(isSpaceChar(b))) {
      sb.appendCodePoint(b);
      b = readByte();
    }
    return sb.toString();
  }

  private static char[] ns(int n) {
    char[] buf = new char[n];
    int b = skip(), p = 0;
    while (p < n && !(isSpaceChar(b))) {
      buf[p++] = (char) b;
      b = readByte();
    }
    return n == p ? buf : Arrays.copyOf(buf, p);
  }

  private static char[][] nm(int n, int m) {
    char[][] map = new char[n][];
    for (int i = 0; i < n; i++)
      map[i] = ns(m);
    return map;
  }

  private static int[] na(int n) {
    int[] a = new int[n];
    for (int i = 0; i < n; i++)
      a[i] = ni();
    return a;
  }

  private static int ni() {
    int num = 0, b;
    boolean minus = false;
    while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
      ;
    if (b == '-') {
      minus = true;
      b = readByte();
    }

    while (true) {
      if (b >= '0' && b <= '9') {
        num = num * 10 + (b - '0');
      } else {
        return minus ? -num : num;
      }
      b = readByte();
    }
  }

  private static long nl() {
    long num = 0;
    int b;
    boolean minus = false;
    while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
      ;
    if (b == '-') {
      minus = true;
      b = readByte();
    }

    while (true) {
      if (b >= '0' && b <= '9') {
        num = num * 10 + (b - '0');
      } else {
        return minus ? -num : num;
      }
      b = readByte();
    }
  }

  private static void tr(Object... o) {
    if (INPUT.length() != 0)
      System.out.println(Arrays.deepToString(o));
  }

  // Union-Find
  // https://algs4.cs.princeton.edu/15uf/UF.java.html
  public static class UnionFind {
    private int count = 0;
    private int[] parent, rank;

    public UnionFind(int n) {
      count = n;
      parent = new int[n];
      rank = new int[n];
      for (int i = 0; i < n; i++) {
        parent[i] = i;
      }
    }

    public int find(int p) {
      while (p != parent[p]) {
        parent[p] = parent[parent[p]];
        p = parent[p];
      }
      return p;
    }

    public void union(int p, int q) {
      int rootP = find(p);
      int rootQ = find(q);
      if (rootP == rootQ)
        return;
      if (rank[rootQ] > rank[rootP]) {
        parent[rootP] = rootQ;
      } else {
        parent[rootQ] = rootP;
        if (rank[rootP] == rank[rootQ]) {
          rank[rootP]++;
        }
      }
      count--;
    }

    public int count() {
      return count;
    }

    public void print() {
      out.println("Parent:");
      for (int i : parent) {
        out.print(i);
        out.print(" ");
      }
      out.println();
      out.println("Rank:");
      for (int i : rank) {
        out.print(i);
        out.print(" ");
      }
      out.println();
    }
  }

  // Dijkstra
  // Return min distance from start to end O(ElogV) (negative cost is prohibited)
  // edge is int[3] array {from,to,cost}
  // edges is edge list from specific node
  // all_edges is Map<from node number,edges>
  static int dijkstra(Map<Integer, List<int[]>> all_edges, int start, int end, int max_node_number) {
    int[] distance = new int[max_node_number + 1];
    Arrays.fill(distance, -1);
    PriorityQueue<int[]> p_que = new PriorityQueue<>((a, b) -> ((distance[a[0]] + a[2]) - (distance[b[0]] + b[2])));
    distance[start] = 0;
    List<int[]> edges = all_edges.get(start);
    p_que.addAll(edges);
    while (distance[end] < 0) {
      int[] nearest_edge = p_que.poll();
      assert nearest_edge != null;
      if (distance[nearest_edge[1]] < 0) {
        distance[nearest_edge[1]] = distance[nearest_edge[0]] + nearest_edge[2];
        if (all_edges.containsKey(nearest_edge[1])) {
          edges = all_edges.get(nearest_edge[1]);
          for (int[] edge : edges) {
            if (distance[edge[1]] < 0)
              p_que.add(edge);
          }
        }
      }
    }
    return distance[end];
  }

  // Enumerate primes in [2, n] with O(n log log n)
  public static List<Integer> sieveOfEratosthenes(int n) {
    boolean[] isPrime = new boolean[n + 1];
    Arrays.fill(isPrime, true);
    for (int i = 2; i * i <= n; i++) {
      if (isPrime[i]) {
        for (int j = i + i; j <= n; j += i) {
          isPrime[j] = false;
        }
      }
    }
    List<Integer> primes = new ArrayList<>();
    for (int i = 2; i <= n; i++) {
      if (isPrime[i]) {
        primes.add(i);
      }
    }
    return primes;
  }

  // Count divisor
  public static int countDivisor(int n) {
    int[] list = new int[n + 1];
    Arrays.fill(list, 0);
    int num = n;
    for (int i = 2; i <= n; i++) {
      while (num % i == 0) {
        list[i] = list[i] + 1;
        num /= i;
      }
    }
    int ans = 1;
    for (int i : list) {
      ans *= (i + 1);
    }
    return ans;
  }
}

