{
TASK: apple
LANG: Pascal
}
Program Apple;
 Var A: Array[1..100, 1..100] of Integer;
     FromI, FromJ: Array[1..100, 1..100] of Byte;
     Max: Array[1..75, 1..75] of Longint;
     M, N, I, J, Sb, Bigger, WTF: Longint;
     Bl: Boolean;
 Begin
  ReadLn(M, N);
  For I := 1 to M do
   For J := 1 to N do Read(A[I][J]);
  For WTF := 1 to 2 do
  Begin


  For I := 1 to M do
   For J := 1 to N do
    Begin
     If Max[I][J - 1] >= Max[I - 1][J] then Begin
                                             Bigger := Max[I][J - 1];
                                             FromI[I][J] := I;
                                             If FromI[I][J] = 0 then
                                              Begin
                                               Inc(FromI[I][J]);
                                               Dec(FromJ[I][J]);
                                              End;
                                             FromJ[I][J] := J - 1;
                                             If FromJ[I][J] = 0 then
                                              Begin
                                               Inc(FromJ[I][J]);
                                               Dec(FromI[I][J]);
                                              End;
                                            End
                                       else Begin
                                             Bigger := Max[I - 1][J];
                                             FromI[I][J] := I - 1;
                                             If FromI[I][J] = 0 then
                                              Begin
                                               Inc(FromI[I][J]);
                                               Dec(FromJ[I][J])
                                              End;
                                             FromJ[I][J] := J;
                                             If FromJ[I][J] = 0 then
                                              Begin
                                               Inc(FromJ[I][J]);
                                               Dec(FromI[I][J])
                                              End;
                                            End;
     Max[I][J] := Bigger + A[I][J];
    End;
    Sb := Sb + Max[M, N];
   If not(Bl) then
    Repeat
     A[I][J] := 0;
     I := FromI[I][J];
     J := FromJ[I][J];
    Until (I=1) and (J=1);
     A[1][1] := 0;
    Bl := True;

  End;

  WriteLn(Sb);

 End.
