#include <iostream>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <queue>
#include <stack>
#include <vector>
#include <algorithm>
#include <map>
#include <unordered_map>
#include <set>
#include <deque>
#include <bitset>

long long mod = 1e9+7;
class Mint {
public:
  long long x;
  Mint(){}; // 引数なしでも定義できるように引数なしコンストラクタも用意しておく
  Mint(long long a){
    x = a%mod;
    while(x<0){
      x += mod;
    }
  };
  Mint& operator += (const Mint &a){
    x+=a.x;
    x%=mod;
    return *this;
  }
  Mint& operator -= (const Mint &a){
    x += (mod - a.x);
    x%=mod;
    return *this;
  }
  Mint& operator *= (const Mint &a){
    x*=a.x;
    x%=mod;
    return *this;
  }

  // a^n mod を計算する
  // Useaeg: Mint z = y.pow(y, n);
  Mint pow(Mint a, long long n) const {
    Mint y(1);
    Mint b(a);
    while (n > 0) {
      if (n & 1) y *= b;
      b *= b;
      n >>= 1;
    }
    return y;
  }

  // a^{-1} mod を計算する
  Mint modinv(const Mint &a) const {
    return pow(a, mod-2);
  }

  Mint& operator /= (const Mint &a) {
    x *= modinv(a).x;
    x %= mod;
    return *this;
  }

  Mint operator + (Mint &a) const {
    Mint y(*this);
    y += a;
    return y;
  }

  Mint operator - (Mint &a) const {
    Mint y(*this);
    y -= a;
    return y;
  }

  Mint operator * (Mint &a) const {
    Mint y(*this);
    y *= a;
    return y;
  }

  Mint operator / (Mint &a) const {
    Mint y(*this);
    y/=a;
    return y.x;
  }

  // nCk @mod を計算する
  Mint nCk(Mint &n, const long long k) const {
    Mint y = Mint(1);
    for (Mint i(0); (i.x)<k; i.x++){
      y *= (n-i);
      y /= i;
    }
    return y;
  }

  // nPk @mod を計算する
  Mint nPk(Mint &n, long long k) const {
    Mint y(1);
    for (Mint i(0); (i.x)<k; i.x++){
      y *= (n-i);
    }
    return y;
  }
};

struct node {
  int v;
  int supply;
  int amari;
};

class MyComparison {
public:
  bool operator()(node n1, node n2) {
    return (n1.supply!=n2.supply)?(n1.supply>n2.supply):(n1.amari<n2.amari);
  }
};

long long dp[3004][3004][4];
int value[3004][3004];

int main() {
  int R, C, K;
  std::cin >> R >> C >> K;
  std::vector<long long > r(K), c(K), v(K);
  std::vector<std::pair<int, int> > item[3004];
  for (int i=0; i<K; i++) {
    std::cin >> r[i] >> c[i] >> v[i];
    r[i]--;
    c[i]--;
    value[r[i]][c[i]] = v[i];
  }
  for (int i=0; i<3004; i++) {
    for (int j=0; j<3004; j++) {
      for (int k=0; k<3; k++) {
        dp[i][j][k] = -1;
      }
    }
  }
  dp[0][0][0] = 0;
  //if (value[0][0]>0) dp[0][0][1] = value[0][0];
  for (int i=0; i<R; i++) {
    for (int j=0; j<C; j++) {
      dp[i+1][j][0] = std::max(dp[i+1][j][0], dp[i][j][0]);
      dp[i+1][j][0] = std::max(dp[i+1][j][0], dp[i][j][1]);
      dp[i+1][j][0] = std::max(dp[i+1][j][0], dp[i][j][2]);
      dp[i+1][j][0] = std::max(dp[i+1][j][0], dp[i][j][3]);
      if (value[i][j]!=0) {
        dp[i+1][j][1] = std::max(dp[i+1][j][1], dp[i][j][0]+value[i][j]);
        dp[i+1][j][1] = std::max(dp[i+1][j][1], dp[i][j][1]+value[i][j]);
        dp[i+1][j][1] = std::max(dp[i+1][j][1], dp[i][j][2]+value[i][j]);
        dp[i+1][j][1] = std::max(dp[i+1][j][1], dp[i][j][3]+value[i][j]);
      }
    }
    for (int j=1; j<C; j++) {
      for (int k=0; k<4; k++) {
        dp[i+1][j][k] = std::max(dp[i+1][j][k], dp[i+1][j-1][k]);
      }
      if (value[i][j]>0) {
        for (int k=0; k<3; k++) {
          dp[i+1][j][k+1] = std::max(dp[i+1][j][k+1], dp[i+1][j-1][k]+value[i][j]);
        }
      }
    }
  }

/*for (int i=0; i<=R; i++) {
    for (int j=0; j<C; j++) {
      for (int k=0; k<4; k++) {
        printf("dp[%d][%d][%d]=%lld\n", i, j, k, dp[i][j][k]);
      }
    }
  }*/
  long long ans = 0;
  for (int k=0; k<4; k++) {
    ans = std::max(ans, dp[R][C-1][k]);
  }
  std::cout << ans << std::endl;
  return 0;
}

Measured memory_bytes: 324828