package main

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

// Complete the connectedCell function below.
func connectedCell(matrix [][]int32) int32 {
    var max int32 = 0
    visited := make([][]bool, len(matrix))
    for i:=0; i<len(matrix); i++{
        visited[i] = make([]bool, len(matrix[0]))
    }
    for i:=0; i<len(matrix); i++{
        for j:=0; j<len(matrix[0]); j++{
            if(matrix[i][j]==1 && !visited[i][j]){
                count := DFS(matrix, visited, i, j)
                if count > max{
                    max = count
                }
            }
        }
    }
    return max
}

func DFS(matrix [][]int32, visited [][]bool, i int, j int) int32{
    var count int32 = 1
    visited[i][j] = true
    for m:=-1;m<=1;m+=1{
        for n:=-1;n<=1;n+=1{
            if m==0 && n==0 {
                continue
            }
            DFSVisit(matrix, visited, i+m, j+n, &count)
        }
    }
    return count
}

func DFSVisit(matrix [][]int32, visited [][]bool, i int, j int, count *int32){
    if i<0 || j<0 || i>=len(matrix) || j>=len(matrix[0]) || matrix[i][j] == 0 || visited[i][j]{
        return
    }
    visited[i][j] = true
    *count += 1
    for m:=-1;m<=1;m++{
        for n:=-1;n<=1;n++{
            if m == 0 && n == 0{
                continue
            }
            DFSVisit(matrix, visited, i+m, j+n, count)
        }
    }
}

func main() {
    reader := bufio.NewReaderSize(os.Stdin, 1024 * 1024)

    stdout, err := os.Create(os.Getenv("OUTPUT_PATH"))
    checkError(err)

    defer stdout.Close()

    writer := bufio.NewWriterSize(stdout, 1024 * 1024)

    nTemp, err := strconv.ParseInt(readLine(reader), 10, 64)
    checkError(err)
    n := int32(nTemp)

    mTemp, err := strconv.ParseInt(readLine(reader), 10, 64)
    checkError(err)
    m := int32(mTemp)

    var matrix [][]int32
    for i := 0; i < int(n); i++ {
        matrixRowTemp := strings.Split(readLine(reader), " ")

        var matrixRow []int32
        for _, matrixRowItem := range matrixRowTemp {
            matrixItemTemp, err := strconv.ParseInt(matrixRowItem, 10, 64)
            checkError(err)
            matrixItem := int32(matrixItemTemp)
            matrixRow = append(matrixRow, matrixItem)
        }

        if len(matrixRow) != int(int(m)) {
            panic("Bad input")
        }

        matrix = append(matrix, matrixRow)
    }

    result := connectedCell(matrix)

    fmt.Fprintf(writer, "%d\n", result)

    writer.Flush()
}

func readLine(reader *bufio.Reader) string {
    str, _, err := reader.ReadLine()
    if err == io.EOF {
        return ""
    }

    return strings.TrimRight(string(str), "\r\n")
}

func checkError(err error) {
    if err != nil {
        panic(err)
    }
}