/* Codigo de Javier Dottori, je */

/*
analisis:
ver que el problema es el mismo en cada fila, que entre todas las filas. Es decir, si elejimos una fila, no vamos a poder elegir ninguna de las filas adyacentes. En cada fila, si elegimos una celda no podemos elegir cada celda adyacente.

Entonces ahroa mira el main, con una funcion se calcula el maximo valor que puede dar elegir una fila, (sin saber cuales son los q se eligen de esa fila, porque no hace falta)
con estos datos se arma otro arreglo, que tiene los valores maximos de cada fila, luego se ejecuta el mismo procedimiento entre todas las filas.


el procedimienot primero que nada lo plantee como un backtrackin, es el que esta comentado, pero despues vi que es una especie de greedy y programacion dinamica, pq en cada paso se puede agregar algo a la solucion (greedy), pero llevando dos soluciones posibles que interactuan y que son solucion optima del punto anterior (si es solucion optima de un subproblema, y la nueva se calcula como una funcion de ellas es prog dinamica)

lee el backtracking primero, que es mas intuitivo. despues si te armas un poco como se forma ese arbol te das cuenta como hacerlo sin que sea un back

*/



/*
void back(int arr[], int inic, int fin, int sumPar, int &sumMax)
{
    if(inic < fin)
	{
	   back(arr, inic+2, fin, sumPar+arr[inic], sumMax);
	   back(arr, inic+3, fin, sumPar+arr[inic], sumMax);
	}
	else if(sumPar > sumMax)
		sumMax = sumPar;
}


inline void procFila(int arr[], int inic, int fin, int &sumMax)
{
	sumMax = 0;
	back(arr, inic, fin, 0, sumMax);
	back(arr, inic+1, fin, 0, sumMax);
}
*/
#include <iostream>

inline int procFila(int arr[],const int & inic, const int & fin)
{
	int opc_dejo = 0;
	int opc_tomo = 0;
	for(int i = inic; i < fin; i++)
	{
		int opc_tomo_ant = opc_tomo;
		int opc_dejo_ant = opc_dejo;
		
		opc_dejo = (opc_tomo_ant > opc_dejo_ant)? opc_tomo_ant : opc_dejo_ant;
		opc_tomo = opc_dejo_ant+arr[i];		
	}
	return (opc_tomo > opc_dejo)? opc_tomo: opc_dejo;
}


int NFilas,NCols;
int mat[100002]; // [fila][columna]
int filas[100002]; //el mejor de cada fila

inline int posEnMat(const int &f, const int & c)
{
	return f * NCols+ c;
}

using namespace std;

inline void cargar(){
	for (int f=0; f<NFilas; f++)
		for (int c=0; c<NCols; c++)
			cin >> mat[posEnMat(f,c)];
}

int main()
{
	while(	cin >> NFilas >> NCols && NFilas != 0)
	{
		cargar();
		for(int fila = 0; fila < NFilas; fila++)
		{
			int pos = fila * NCols;
			int fin = pos + NCols;
			filas[fila] = procFila(mat, pos, fin);
		}
		cout << procFila(filas, 0, NFilas) << endl;
	}
	return 0;
}