// #include <bits/stdc++.h>
#include<iostream>
#include<algorithm>
#include<map>
#include <vector>
#include<stack>
#include<cstring>
#include <set>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <climits>
#include <utility>
#include <cmath>
#include <queue>
#include <iomanip>

// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
using namespace std;
#define ll long long
#define ld long double
#define vll vector<ll>
#define vpll vector<pair<ll ,ll > >
#define pb push_back
#define MOD 1000000007
#define inf 100000000000000000
#define ios ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define all(v) v.begin(),v.end()
#define fst first
#define scd second
#define fr(i,n) for(ll (i) = 0 ; (i) < (n) ; ++(i))
#define fr1(i,n) for(ll (i) = 1 ; (i) <= (n) ; ++(i))
#define frr(i,n) for(ll (i) = (n)-1 ; (i)>=0 ; --(i))
#define frab(i,a,b,c) for(ll (i) = a ; (i) < (b) ; (i)+=(c))
#define print(v) for( auto it: v) cout<<it<<" "
#define mst(A) memset( (A) , 0 , sizeof(A) )


//////////////////////////////////////////////////////////////////////////
//------------------TRACE--------------------------------//
template<class T, class U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
    os << "(" << p.first << ", " << p.second << ")";
    return os;
}

template<class T>
ostream& operator <<(ostream& os, const vector<T>& v) {
    os << "{";
    for (int i = 0; i < (int)v.size(); i++) {
        if (i)os << ", ";
        os << v[i];
    }
    os << "}";
    return os;
}

#ifdef LOCAL
#define cerr cout
#else
#endif

#define TRACE

#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
    cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
    const char* comma = strchr(names + 1, ','); cerr.write(names, comma - names) << " : " << arg1 << " | "; __f(comma + 1, args...);
}
#else
#define trace(...)
#endif
//////////////////////////////////////////////////////

bool cmp(const pair<ll, ll> &a, const pair<ll, ll> &b)
{
    if (a.first == b.first)
        return (a.scd >= b.scd);
    return (a.first < b.first);
}
vll primes;
vll seive;
void Seive(ll n) {
    seive.resize(n + 5, 1);
    seive[1] = 0, seive[0] = 0;
    for ( int i = 2; i * i < n + 5; i++) {
        if (seive[i]) {
            for (int j = 2 * i; j < n + 5; j += i) {
                seive[j] = 0;
            }
        }
    }
}
ll power(ll x, ll y , ll m = MOD) {
    long long int res = 1;
    x = x % m;
    while (y > 0) {
        if (y & 1)
            res = (res * x) % m;
        y = y >> 1;
        x = (x * x) % m;
    }
    return res;
}
ll modinv(ll x , ll mod = MOD) {
    return power(x , mod - 2 , mod);
}
ll n, m;
ll dp[3005 + 1][3005 + 1][4];
ll g[3005 + 1][3005 + 1];


// ll cal( ll i , ll j , vll v) {
//     if (i >= n) return 0;
//     if (j >= m) return 0;
//     if (v[i] > 3) return 0;
//     if (dp[i][j] != -1) return dp[i][j];
//     ll x = 0, y = 0;

//     vll v1 = v;
//     v1[i]++;
//     y = g[i][j] + cal(i , j + 1, v1);
//     x = g[i][j] + cal(i + 1, j, v1);


//     ll yx =  cal(i, j + 1, v);
//     ll xx =  cal(i + 1, j, v);

//     dp[i][j] = max({dp[i][j], x, y, xx, yx});
//     return dp[i][j];
// }


ll cal1( ll i , ll j , ll k) {
    if (i >= n) return 0;
    if (j >= m) return 0;

    if (dp[i][j][k] != -1) return dp[i][j][k];
    ll x = 0, y = 0;
    // trace(i, j, c);
    if (k > 0) {
        dp[i][j][k] = max({cal1(i + 1, j, 3) + g[i][j], cal1(i, j + 1, k - 1) + g[i][j],  cal1(i, j + 1, k), cal1(i + 1, j, 3)});
    }
    else
        dp[i][j][k] = max(cal1(i, j + 1, k), cal1(i + 1, j, 3));
    return dp[i][j][k];
}


int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
#ifndef ONLINE_JUDGE
    freopen("/home/aman/Documents/compwtitive_coding/Competitive-coding-codes/in.txt", "r", stdin);
    freopen("/home/aman/Documents/compwtitive_coding/Competitive-coding-codes/output.txt", "w", stdout);
#endif
    ll  k, t, a, b, c, d;
    t = 1;

    while (t--) {

        cin >> n >> m >> k;
        fr(i, n + 1) {
            fr(j, m + 1) fr(k, 4) dp[i][j][k] = -1;
        }
        fr(i, k) {
            cin >> a >> b >> c;
            g[a - 1][b - 1] = c;
        }

        // fr(i, n) {
        //     fr(j, m) {
        //         cout << g[i][j] << " ";
        //     }
        //     cout << endl;
        // }
        vll v(n + 1, 0);
        cout << cal1(0, 0, 3);
        // fr(i, n) {
        //     fr(j, m) {
        //         cout << dp[i][j] << " ";
        //     }
        //     cout << endl;
        // }

    }
}








Measured memory_bytes: 356660