// #pragma GCC target ("avx2")
#pragma GCC optimization ("O3")
// #pragma GCC optimization ("unroll-loops") 

#include<bits/stdc++.h>
using namespace std;
#define crap ios::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL) 
 
typedef long long int ll;
typedef unsigned long long ull;
 
#define int ll
 
typedef std::vector<int> vi;
typedef std::vector<ll> vll;
typedef std::vector<vi > vvi;
typedef std::vector<vll > vvll;
typedef std::pair<int,int> ii;
typedef std::pair<int, ii > iii;
typedef std::pair< ll, ll > lp;
typedef std::vector<ii> vii;
typedef std::vector<vii > vvii;
 
#define pb push_back 
#define PB pop_back
#define pf push_front
#define PF pop_front
#define mp make_pair
#define ub(a,b) upper_bound(all(a),b)
#define lb(a,b) lower_bound(all(a),b)
#define bs(a,b) binary_search(all(a),b)
#define mem(a,b) memset(a,b,sizeof(a))
#define in(a,n) F(i,0,n-1)cin>>a[i]
#define in1(a,n) F(i,1,n)cin>>a[i]
#define out(a,n) F(i,0,n-1)cout<<a[i]<<" ";cout<<endl
#define ff first
#define ss second
#define F(i,a,b) for (ll i=a;i<=b;i++)
#define RF(i,a,b) for(ll i=a;i>=b;i--)
#define rep(i,n) F(i,0,n-1)
#define clr(a) (a).clear()
#define rz resize
#define sqr(a) ((a) * (a))
#define sz(a) int((a).size())
#define len(a) int((a).length())
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin() ,(a).rend()
#define endl '\n'
#define flush cout.flush()
 
// int mod;
// #define mod (int)1e9+123
#define mod 1000000007
// #define mod 998244353
 
// ################################## Debugging statements  ##################################
string to_string(string s) {return '"' + s + '"';}
string to_string(const char* s) {return to_string((string) s);}
string to_string(bool b) {return (b ? "true" : "false");}
template <typename A, typename B>
string to_string(pair<A, B> p) {return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";}
template <typename A>
string to_string(A v) {bool first = true;  string res = "{";for (const auto &x : v) {if (!first) { res += ", "; }first = false; res += to_string(x);}res += "}";return res;}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {cerr << " " << to_string(H);debug_out(T...);}
#define TRACE // comment this out for submission
#ifdef TRACE
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif
// ###########################################################################################
 
inline int add(int a, int b){a += b; if(a >= mod)a -= mod; return a;}
inline int sub(int a, int b){a -= b; if(a < 0)a += mod; return a;}
inline int mul(int a, int b){return (int)((long long) a * b %mod);}
inline int poww(int a, int b){int res = 1; while(b > 0){ if(b & 1)res = mul(res, a); a = mul(a, a);b /= 2;} return res;}
inline int inv(int a){return poww(a, mod - 2);}
int gcd(int a, int b, int &x, int &y){if(a == 0){x = 0, y = 1; return b;} int x1, y1;  int d = gcd(b%a, a, x1, y1); x = y1 - (b/a) * x1; y = x1; return d;}
 
// #################################### matrix operations ####################################
inline vvi matmul(vvi A, vvi B) {int p = A.size(), q = A[0].size();int r = B.size(), s = B[0].size();assert(q == r);vvi C(p, vi(s, 0LL));
    rep(i, p){rep(j, s){rep(k, q){
                // C[i][j] += A[i][k] * B[k][j]; 
                C[i][j] = add(C[i][j], mul(A[i][k], B[k][j]));
    }}}return C;}
 
inline vvi matpow(vvi A, int n){int p = A.size(), q = A[0].size();assert(p == q);vvi res(p, vi(p, 0));rep(i, p)res[i][i] = 1;while (n){if (n&1)res = matmul(res, A);A = matmul(A, A);n >>= 1;}return res;}
 
// ###########################################################################################
 
// #################################### Combinatorics template ###############################
struct factorial{
    int N;int *fac;int *ifac; int *der; int MOD;
    factorial(int n, int m = 1000000007){N = n;MOD = m;fac = new int[1+N];ifac = new int[1+N];der= new int[N+1];pre_calc(); calc_derangement();}
    int add(int a, int b){a += b; if(a >= MOD)a -= MOD; return a;}
    int subtract(int a, int b){a -= b; if(a < 0)a += MOD; return a;}
    int multiply(int a, int b){return (int)((long long) a * b %MOD);}
    int binpow(int a, int b){int res = 1; while(b > 0){ if(b & 1)res = multiply(res, a); a = multiply(a, a);b /= 2;} return res;}
    int inverse(int a){return binpow(a, MOD - 2);}
    void pre_calc(){fac[0] = ifac[0] = 1;for (int i = 1 ; i <= N ; i++){fac[i] = multiply(fac[i-1], i);ifac[i] = multiply(ifac[i-1], inverse(i));}}
    int ncr(int n , int r){return multiply(fac[n], multiply(ifac[r], ifac[n-r]));}
    void calc_derangement(){
        der[1] = 0;der[2] = 1;
        for (int i = 3; i <= N; i++){
            der[i] = multiply(i-1, add(der[i-1], der[i-2]));
        }
    }
    int derangement(int n){
        if (n == 1) return 1;
        return der[n];
    }
};
 
vi factors_n(int n){std::vector<int> fac;for (int i = 1; i * i <= n ; i++){if (n % i == 0){fac.push_back(i);if (i * i != n){fac.push_back(n/i);}}}return fac;}
// ###########################################################################################
 
// ##################################### Fenwick Tree template ###############################
struct fenwick_tree{
    int *bit;int n;
    fenwick_tree(){this->n = 1000005;this->bit = new int[1000005+1]; init_bit();}
    fenwick_tree(int n){this->n = n;this->bit = new int[n+1]; init_bit();}
    void init_bit(){for (int i=0; i <= this->n; i++)this->bit[i]=0;}
    void add(int i, int v){for (; i<=this->n; i+= i&-i){this->bit[i] += v; this->bit[i] %= mod; }}
    int get(int i){int s = 0;for (; i; i -= i&-i){s += this->bit[i]; s %= mod; }return s;}
};
// ###########################################################################################
 
// ######################################## Policy-based DS ##################################
// #include<ext/pb_ds/assoc_container.hpp>
// using namespace __gnu_pbds;
 
// template<class key, class value = null_type, class cmp = std::less<key>>
// using ordered_tree = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// order_of_key (val): returns the no. of values less than val
// find_by_order (k): returns the iterator to kth largest element.(0-based)
 
// ###########################################################################################
 
// ######################################## Bit manipulations ##################################
int no_of_ones(int n){return __builtin_popcount(n);}
int setmask(int mask, int i){return mask | (1 << i);}
int unsetmask(int mask, int i){return (mask & !(1 << i));}
// ###########################################################################################
 
// ###################################### Convex Hull Trick  ##################################
// struct Line {
//     mutable ll k, m, p;
//     bool operator<(const Line& o) const { return k < o.k; }
//     bool operator<(ll x) const { return p < x; }
// };
 
// struct LineContainer : multiset<Line, less<>> {
//     // (for doubles, use inf = 1/.0, div(a,b) = a/b)
//     const ll inf = LLONG_MAX;
//     ll div(ll a, ll b) { // floored division
//         return a / b - ((a ^ b) < 0 && a % b); }
//     bool isect(iterator x, iterator y) {
//         if (y == end()) { x->p = inf; return false; }
//         if (x->k == y->k) x->p = x->m > y->m ? inf : -inf;
//         else x->p = div(y->m - x->m, x->k - y->k);
//         return x->p >= y->p;
//     }
//     void add(ll k, ll m) { // y = k * x + m
//         auto z = insert({k, m, 0}), y = z++, x = y;
//         while (isect(y, z)) z = erase(z);
//         if (x != begin() && isect(--x, y)) isect(x, y = erase(y));
//         while ((y = x) != begin() && (--x)->p >= y->p)
//             isect(x, erase(y));
//     }
//     ll query(ll x) {
//         assert(!empty());
//         auto l = *lower_bound(x);
//         return l.k * x + l.m;
//     }
// };
// ###########################################################################################
 
// ######################################## Disjoint Set ##################################
// struct disjoint_sets{
//     int n;
//     vector<int> par;
//     vector<int> ranks;
//     disjoint_sets(int _n):n(_n){
//         for (int i = 0; i <= n; i++){
//             par.emplace_back(i);
//             ranks.emplace_back(1);
//         }
//     }
//     int find_root(int u){// path compression
//         return (par[u] == u) ? u : (par[u] = find_root(par[u]));
//     }
//     void merge_node(int u, int v){
//         u = find_root(u), v = find_root(v);
//         if (u == v)
//             return;
//         if (ranks[u] < ranks[v])
//             swap(u, v);
//         par[v] = u;
//         ranks[u] += ranks[v];
//     }
// };
// ###########################################################################################
 
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
 
// ################################### Template ends here ####################################

const int N = 2e5 + 5;
const int M = 3e3 + 5;
int dp[5][M][M];
int R, C, K;
int a[M][M];

int go(int r, int c, int ch){
    if (r == R && c == C){
        if (a[r][c] == -1)
            return 0;
        if (ch <= 3){
            return a[r][c];
        }
        else{
            return 0;
        }
    }
    else if (r == R){
        if (ch == 4){
            return 0;
        }
        else{
            int &ans = dp[ch][r][c];
            if (ans != -1)
                return ans;
            if (a[r][c] != -1){
                int pos1 = a[r][c] + go(r, c+1, ch+1);
                int pos2 = go(r, c+1, ch);
                ans = max(pos1, pos2);
            }
            else{
                ans = go(r, c+1, ch);
            }
            return ans;
        }
    }
    else if (c == C){
        if (ch == 4){
            int &ans = dp[ch][r][c];
            if (ans != -1)
                return ans;
            ans = go(r+1, c, 1);
            return ans;
        }
        else{
            int &ans = dp[ch][r][c];
            if (ans != -1)
                return ans;
            if (a[r][c] != -1){
                int pos1 = a[r][c] + go(r+1, c, 1);
                int pos2 = go(r+1, c, 1 );
                ans = max(pos1, pos2);
            }
            else{
                ans = go(r+1, c, 1);
            }
            return ans;
        }    
    }
    else{
        if (ch == 4){
            int &ans = dp[ch][r][c];
            if (ans != -1)
                return ans;
            int pos1 = go(r+1, c, 1);
            int pos2 = go(r, c+1, ch);
            ans = max(pos1, pos2);
            return ans;
        }
        else{
            int &ans = dp[ch][r][c];
            if (ans != -1)
                return ans;
            if (a[r][c] != -1){
                int pos1 = a[r][c] + go(r, c+1, ch+1);
                int pos2 = a[r][c] + go(r+1, c, 1);
                int pos3 = go(r, c+1, ch);
                int pos4 = go(r+1, c, 1);
                ans = max(max(pos1, pos4), max(pos2, pos3));
            }
            else{
                ans = max(go(r, c+1, ch), go(r+1, c, 1));
            }
            return ans;
        }
    }
}

void solve(){
    cin >> R >> C >> K;
    mem(a, -1);
    while (K--){
        int r, c, v;
        cin >> r >> c >> v;
        a[r][c] = v;
    }
    mem(dp, -1);
    int ans = go(1, 1, 1);
    cout << ans << endl;
}


signed main(){
    crap;
    int t = 1;
    // cin >> t;
    int t0 = 1;
    while (t--){
        // cout<<"Case #"<< t0++ <<": ";
        solve();
        auto init = [&](){
            // clear glbl var here
            
        };
        init();
    }
}

Measured memory_bytes: 427412