// #![recursion_limit = "1024"]

use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque};
use std::fmt::Display;
use std::io::stdin;
use std::iter::FromIterator;
use std::marker::PhantomData;
use std::ops::{Add, Deref, DerefMut, Div, Mul, Sub};
use std::rc::Rc;
use std::str::FromStr;
use std::time::Instant;

macro_rules! ops_impl {
    ($struct:ty, $other:ty, $trait:ty, $notype:ty, $method:ident)=>{
        impl $trait for $struct{
            type Output = $struct;
            fn $method(self, other:$other)->Self::Output{
                self.$method(<$struct>(other as i64))
            }
        }
    };
}
// modint!(ModInt, 1_000_000_007);

fn solve(cin: &mut ConsoleInput) {
    let r = cin.next();
    let c = cin.next();
    let k = cin.next();

    let mut items: HashMap<(usize, usize), _> = HashMap::new();
    for i in 0..k {
        let r: usize = cin.next();
        let c: usize = cin.next();
        let v: u64 = cin.next();

        items.insert((r - 1, c - 1), v);
    }

    let mut map = vec![vec![[0u64; 4]; c]; r];

    for y in 0..r {
        for x in 0..c {
            for i in 0..4 {
                let mut score = 0;
                if x > 0 {
                    score = score.max(map[y][x - 1][i]);
                    if i > 0 && items.contains_key(&(y, x - 1)) {
                        score = score.max(map[y][x - 1][i - 1] + items[&(y, x - 1)]);
                    }
                }
                if y > 0 {
                    score = score.max(map[y - 1][x].iter().map(|i| *i).max().unwrap());
                    if i == 0 && items.contains_key(&(y - 1, x)) {
                        score = score.max(map[y - 1][x].iter().take(3).map(|i| *i).max().unwrap() + items[&(y - 1, x)]);
                    }
                }
                map[y][x][i] = score;
            }
        }
    }
    // println!("{:#?}", map);
    println!("{}", u64::max(map[r - 1][c - 1].iter().take(3).max().unwrap() + items.get(&(r - 1, c - 1)).unwrap_or(&0u64), map[r - 1][c - 1][3]));
}

fn main() {
    let mut cin = ConsoleInput::new();
    solve(&mut cin);
}

struct ConsoleInput {
    queue: VecDeque<String>
}

impl ConsoleInput {
    fn new() -> Self {
        Self { queue: VecDeque::new() }
    }

    fn read(&mut self) -> String {
        loop {
            if let Some(s) = self.queue.pop_front() {
                return s;
            }
            let mut s = String::new();
            stdin().read_line(&mut s);
            for s in s.split_ascii_whitespace() {
                self.queue.push_back(String::from(s));
            }
        }
    }
    fn next<T: FromStr>(&mut self) -> T {
        match self.read().parse() {
            Ok(value) => value,
            _ => panic!("parse error")
        }
    }
}

macro_rules! modint {
    ($name:ident, $m:expr)=>{
        #[derive(Clone, Copy, Debug)]
        struct $name(i64);

        impl std::ops::Add for $name {
            type Output = $name;

            fn add(self, rhs: Self) -> Self::Output {
                $name((self.0 + rhs.0) % $m)
            }
        }
        // ops_impl!($name, i32, std::ops::Add<i32>, std::ops::Add, add);
        // ops_impl!($name, u32, std::ops::Add<u32>, std::ops::Add, add);
        // ops_impl!($name, i64, std::ops::Add<i64>, std::ops::Add, add);
        // ops_impl!($name, u64, std::ops::Add<u64>, std::ops::Add, add);

        impl std::ops::Sub for $name {
            type Output = $name;

            fn sub(self, rhs: Self) -> Self::Output {
                $name((self.0 - rhs.0 + $m) % $m)
            }
        }

        impl std::ops::Mul for $name {
            type Output = $name;

            fn mul(self, rhs: Self) -> Self::Output {
                $name((self.0 * rhs.0) % $m)
            }
        }

        impl std::ops::Div for $name {
            type Output = $name;

            fn div(self, rhs: Self) -> Self::Output {
                let mut m = $m as u64;
                let mut ans = $name(1);
                let mut a = rhs;
                while m > 0 {
                    if (m & 1) == 1 {
                        ans = ans * a;
                    }
                    a = a * a;
                    m >>= 1;
                }
                self * ans
            }
        }

        impl std::fmt::Display for $name{
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result{
                write!(f, "{}", self.0)
            }
        }
    }
}



Measured memory_bytes: 289744