# 导入 math 模块以使用 sqrt 函数
import math

class Vector2d:
    # 初始化二维向量
    def __init__(self, x: int, y: int):
        self.x = x
        self.y = y

    # 重载加法运算符 (+)，实现向量加法
    def __add__(self, other: 'Vector2d') -> 'Vector2d':
        return Vector2d(self.x + other.x, self.y + other.y)

    # 向量加法（成员方法版本）
    def add(self, other: 'Vector2d') -> 'Vector2d':
        return self.__add__(other)

    # 重载减法运算符 (-)，实现向量减法
    def __sub__(self, other: 'Vector2d') -> 'Vector2d':
        return Vector2d(self.x - other.x, self.y - other.y)

    # 向量减法（成员方法版本）
    def sub(self, other: 'Vector2d') -> 'Vector2d':
        return self.__sub__(other)

    # 计算向量的模长（L2范数）
    def norm(self) -> float:
        return math.sqrt(self.x * self.x + self.y * self.y)

    # 计算反向量
    def negate(self) -> 'Vector2d':
        return Vector2d(-self.x, -self.y)

    # 判断两个向量是否垂直（点积为0）
    def is_perpendicular(self, other: 'Vector2d') -> bool:
        return self.x * other.x + self.y * other.y == 0

    # 判断两个向量是否共线（叉积为0）
    def is_collinear(self, other: 'Vector2d') -> bool:
        return self.x * other.y - self.y * other.x == 0

    # 自定义对象的字符串表示形式，用于print()
    def __str__(self):
        return f"({self.x}, {self.y})"

class EBicycle :
    def __init__(self, totalPower, maxSpeed):
        self.totalPower = totalPower
        self.maxSpeed = maxSpeed
        self.power = self.totalPower

    # 判断能否以速度 v 行驶路程 s
    def canIMakeIt(self,v,s) :
        # 最大里程
        maxS = (v * 0.7 * self.power)/(2 + 0.1 * v + 0.02 * v ** 2)
        
        # 目标路程小于等于最大里程
        if s <= maxS :
            consumed_power = s * (2 + 0.1 * v + 0.02 * v ** 2) / (v * 0.7)
            self.power -= consumed_power
            print(f"行驶后剩余电量: {self.power}")
        else :
            print("无法以该速度到达目的地！")

    def charge(self) :
        self.power = self.totalPower

class Layer:
    def __init__(self,n:int):
        """
        n：本层的神经元数量
        """
        self.neurons = [0 for i in range(n)] # 初始化该层所有神经元的值为0
        self.n = n # 记录神经元数量
        pass # pass主要用于占位，但此处是多余的，可以舍弃

    def __str__(self):  # 定义当打印Layer对象时输出的内容
        return str(self.neurons)
    
    def __repr__(self):  # 定义在交互式环境中直接输出Layer对象时显示的内容
        return self.__str__()

class MLP:
    def __init__(self,weights = None):
        """
        weights：权重，一个三维数组，其中weights[a][b][c] = w[a+1,b+1,c+1]
        """
        # 神经网络的层列表
        self.layers:list[Layer] = list() 
        # 权重列表
        self.weights:list[list[list[float]]] = list() if weights is None else weights
        pass

    def calculate(self,*inputs): # ** 使用打包/解包操作 **
        # 将输入值赋给输入层（第0层）的神经元
        self.layers[0].neurons = inputs
        # 遍历隐藏层和输出层，计算每个神经元的值
        # last_layer_index 是当前处理层的前一层的索引
        for last_layer_index,layer in enumerate(self.layers[1:]):
            last_layer = self.layers[last_layer_index]
            # 遍历当前层的每一个神经元
            for neuron_index in range(layer.n):
                res = 0
                # 计算加权和：前一层所有神经元的值与对应权重的乘积之和
                for last_neuron_index,last_neuron in enumerate(last_layer.neurons):
                    res += self.weights[last_layer_index][last_neuron_index][neuron_index] * last_neuron
                # 更新当前神经元的值
                layer.neurons[neuron_index] = res
        # 返回输出层（最后一层）
        return self.layers[-1]
    pass

# 此处同学代码有点小问题，我们帮助他进行了修正
def load_mlp_from_weights(weights:list[list[list[float]]]) -> MLP:
    mlp = MLP(weights)
    # 创建输入层
    num_input_neurons = len(weights[0])
    mlp.layers.append(Layer(num_input_neurons))
    # 隐藏层和输出层
    for weight_group in weights:
        num_dest_neurons = len(weight_group[0])
        mlp.layers.append(Layer(num_dest_neurons))
    return mlp

test_weights = [
    [
        [1,2,3,4],
        [5,6,7,8],
        [1,2,3,4],
    ],
    [
        [1,2],
        [4,3],
        [1,3],
        [2,4],
    ]
]

mlp = load_mlp_from_weights(test_weights)
print(mlp.layers)
print(mlp.calculate(2,3,4))

from math import inf
import sys

def max_pick_sum(grid):
    n = len(grid) - 1              
    neg = -10**12
    steps = 2 * n - 1              
    dp = [[[neg]*(n+1) for _ in range(n+1)] for _ in range(steps)]
    dp[0][1][1] = grid[1][1]

    for k in range(1, steps):
        for x1 in range(1, n+1):
            y1 = k + 1 - (x1 - 1)
            if not (1 <= y1 <= n):
                continue
            for x2 in range(1, n+1):
                y2 = k + 1 - (x2 - 1)
                if not (1 <= y2 <= n):
                    continue
                best_prev = max(
                    dp[k-1][x1][x2],                       
                    dp[k-1][x1-1][x2] if x1 > 1 else neg,    
                    dp[k-1][x1][x2-1] if x2 > 1 else neg,  
                    dp[k-1][x1-1][x2-1] if x1 > 1 and x2 > 1 else neg
                )
                if best_prev == neg:
                    continue
                gain = grid[x1][y1]
                if x1 != x2 or y1 != y2:
                    gain += grid[x2][y2]
                dp[k][x1][x2] = max(dp[k][x1][x2], best_prev + gain)

    return dp[steps-1][n][n]

data = sys.stdin.read().strip().split()
if not data:
    return
it = iter(data)
n = int(next(it))
grid = [[0]*(n+1) for _ in range(n+1)]
for x, y, v in zip(it, it, it):
    x = int(x); y = int(y); v = int(v)
    if x == 0 and y == 0 and v == 0:
        break
    grid[x][y] = v
print(max_pick_sum(grid))

def dfs(x1,y1,x2,y2):

    if x1 >= N or y1 >=N or x2 >= N or y2 >= N:
        return float('-inf')

    if x1 == N-1 and y1 == N-1 and x2 == N-1 and y2 == N-1:
        return grid[N-1][N-1]

    state = (x1,y1,x2,y2)

    if state in dp:
        return dp[state]

    crt_score = grid[x1][y1]
    if (x1,y1) != (x2,y2):
        crt_score += grid[x2][y2]

    max_future = max(
        dfs(x1+1 , y1 , x2+1 , y2),
        dfs(x1+1 , y1 , x2 , y2+1),
        dfs(x1 , y1+1 , x2+1 , y2),
        dfs(x1 , y1+1 , x2 , y2+1)
        )
    dp[state] = crt_score + max_future
    return dp[state]

N = int(input())
grid = [[0 for _ in range(N)] for _ in range(N)]
dp = {}
while True:
    x, y, value = map(int,input().split())
    if x == 0 and y == 0 and value == 0:
        break
    grid[x-1][y-1] = value

print(dfs(0,0,0,0))