#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <cstring>
#include <cassert>
using namespace std;
using LL = long long;
#define FOR(i, x, y) for (decay<decltype(y)>::type i = (x), _##i = (y); i < _##i; ++i)
#define FORD(i, x, y) for (decay<decltype(x)>::type i = (x), _##i = (y); i > _##i; --i)
#ifdef zerol
#define dbg(x...) do { cout << "\033[32;1m" << #x << " -> "; err(x); } while (0)
void err() { cout << "\033[39;0m" << endl; }
template<template<typename...> class T, typename t, typename... A>
void err(T<t> a, A... x) { for (auto v: a) cout << v << ' '; err(x...); }
template<typename T, typename... A>
void err(T a, A... x) { cout << a << ' '; err(x...); }
#else
#define dbg(...)
#endif


#ifdef L_JUDGE
#pragma warning(disable:4996)
#endif

using namespace std;

template <typename T>
inline bool read(T& ret) {
    T x = 0, f = 1; char ch = getchar();
    while(ch!=EOF && (ch > '9' || ch < '0')) { if(ch == '-') f = -1; ch = getchar();  }
    if(EOF==ch)return false;
    do x = x * 10 + ch - 48, ch = getchar(); while(ch >= '0' && ch <= '9');
    ret = x * f;
    return true;
}


inline char nc() {
    static char buf[100000], *p1 = buf, *p2 = buf;
    return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2) ? EOF : *p1++;
}
template <typename T>
bool rn(T& v) {
    static char ch;
    while (ch != EOF && !isdigit(ch)) ch = nc();
    if (ch == EOF) return false;
    for (v = 0; isdigit(ch); ch = nc())
        v = v * 10 + ch - '0';
    return true;
}

template <typename T>
void o(T p) {
    static int stk[70], tp;
    if (p == 0) { putchar('0'); return; }
    if (p < 0) { p = -p; putchar('-'); }
    while (p) stk[++tp] = p % 10, p /= 10;
    while (tp) putchar(stk[tp--] + '0');
}


LL bin(LL x, LL n, LL MOD) {
    LL ret = MOD != 1;
    for (x %= MOD; n; n >>= 1, x = x * x % MOD)
        if (n & 1) ret = ret * x % MOD;
    return ret;
}
inline LL get_inv(LL x, LL p) { return bin(x, p - 2, p); }


int R,C,K;
long long dp[2][5000][6];

void Solve(){
}


int main(){
#ifdef L_JUDGE
    freopen("in1.txt","r",stdin);
    //		freopen("out.txt","w",stdout);
#endif
    //std::ios::sync_with_stdio(false);
    //std::cin.tie(0);
    while(cin>>R>>C>>K){
        int r,c;
        long long v;
        map<pair<int,int>, long long> mp;
        for(int i=0;i<K;i++){
            cin>>r>>c>>v;
            mp[make_pair(r,c)]=v;
        }
        memset(dp,0,sizeof(dp));
        int si=0,di=1;
        long long ans = 0;
        for(int ri=1;ri<=R;ri++){
            si = 1-si;
            di = 1-di;
            for(int ci=1;ci<=C;ci++){
                dp[di][ci][0]=0;
                for(int i=0;i<=3;i++){
                    dp[di][ci][0]=max(dp[di][ci][0],dp[si][ci][i]);
                    dp[di][ci][i]=max(dp[di][ci][i],dp[di][ci-1][i]);
                }
                if(mp.end()!=mp.find(make_pair(ri,ci))){
                    long long v=mp[make_pair(ri,ci)];
                    for(int i=0;i<=3;i++){
                        dp[di][ci][1]=max(dp[di][ci][1], dp[si][ci][i]+v);
                    }
                    for(int i=1;i<=3;i++){
                        dp[di][ci][i]=max(dp[di][ci][i], dp[di][ci-1][i-1]+v);
                    }
                }
            }
        }
        for(int i=0;i<=3;i++){
            ans = max(ans, dp[di][C][i]);
        }
        cout<<ans<<endl;
    }
    return 0;

#ifdef L_JUDGE
    fclose(stdin);
    fclose(stdout);
    //		system("out.txt");
#endif

	return 0;
}


Measured memory_bytes: 16132