//#pragma GCC target("avx2")
//#pragma GCC optimize("O3")
 
#include <x86intrin.h>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <assert.h>
#include <string>
#include <bitset> 
#include <vector>
#include <cmath>                                    
#include <deque>                                    
#include <queue>
#include <iomanip>
#include <stack>
#include <map>
#include <random>
#include <ctime>
#include <unordered_map>
#include <set>
#include <unordered_set>
//#include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
 
//using namespace __gnu_pbds;
using namespace std;

 
//template<typename T> using ordered_set = tree <T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
     
#define F first
#define S second           
#define lb lower_bound               
#define ub upper_bound
#define pb push_back
#define pf push_front    
#define ppb pop_back
#define mp make_pair                                     
#define bpp __builtin_popcountll                                                                                        
#define sqr(x) ((x) * (x)) 
#define sz(x) (int)x.size()
#define all(x) x.begin(), x.end()
#define in insert
#define ppf pop_front
#define endl '\n'
//#define int long long
 
typedef unsigned long long ull;
typedef long long ll;
typedef long double ld;
typedef pair <int, int> pii;
 
const int mod = (int)1e9 + 7;
const int N = (int)3e5 + 123;
const ll inf = (ll)1e18 + 1;
 
const double pi = acos (-1.0);
const double eps = 1e-9;                  
const int dx[] = {0, 0, 1, 0, -1};
const int dy[] = {0, 1, 0, -1, 0};

int n, m, k;
int a[3003][3003];
ll dp[3003][3003][4];

inline void boost () {
   ios_base :: sync_with_stdio (0);
   cin.tie (0), cout.tie (0);
}
 
inline void Solve () {
   cin >> n >> m >> k;
   for (int i = 1; i <= k; i ++) {
      int x, y, c;
      cin >> x >> y >> c;
      a[x][y] = c;
   }
   for (int i = 1; i <= n; i ++)
      for (int j = 1; j <= m; j ++)
         for (int take = 0; take <= 3; take ++)
            dp[i][j][take] = -inf;
   dp[1][1][0] = 0;
   dp[1][1][1] = a[1][1];
   for (int i = 1; i <= n; i ++) {
      for (int j = 1; j <= m; j ++) {
         for (int took = 0; took <= 3; took ++) {
            if (i + 1 <= n) {
               dp[i + 1][j][0] = max (dp[i + 1][j][0], dp[i][j][took]);
               dp[i + 1][j][1] = max (dp[i + 1][j][1], dp[i][j][took] + a[i + 1][j]);
            }
            if (j + 1 <= m) {
               dp[i][j + 1][took] = max (dp[i][j + 1][took], dp[i][j][took]);
               if (took < 3) dp[i][j + 1][took + 1] = max (dp[i][j + 1][took + 1], dp[i][j][took] + a[i][j + 1]);
            }
         }
      }
   }
   cout << max (dp[n][m][0], max (dp[n][m][1], max (dp[n][m][2], dp[n][m][3])));
}               
 
signed main () {                                       
  // #ifdef QWERTY
   //   freopen("input", "r", stdin);
   //#endif
  // freopen (".in", "r", stdin);    
  // freopen (".out", "w", stdout);              
   boost ();
   int tt = 1;
   
   //cin >> tt;   
   while (tt --) {
      Solve ();
   }                                               
   return 0;      
}                   

Measured memory_bytes: 320344