#include <iostream>
#include <vector>
#include <map>
using namespace std;
class DisjointSet {
private:
    vector<int> parent, weight;
public:
    DisjointSet(int n) {
        parent.resize(n + 1);
        weight.resize(n + 1, 1);
        for (int node = 0; node <= n; node++) {
            parent[node] = node;
        }
    }

    int findParent(int node) {
        if (parent[node] != node) {
            parent[node] = findParent(parent[node]); 
        }
        return parent[node];
    }

    int connect(int A, int B) {
        A = findParent(A);
        B = findParent(B);
        if (A == B) return 0;
        if (weight[A] == weight[B]) {
            weight[A] += weight[B];
            parent[B] = A;
        } else if (weight[A] < weight[B]) {
            weight[B] += weight[A];
            parent[A] = B;
        } else {
            weight[A] += weight[B];
            parent[B] = A;
        }
        return 1;
    }

    int count(int n) {
        int ans = 0;
        for (int node = 0; node <= n; node++) {
            if (parent[node] == node) {
                ans += weight[node] - 1;
            }
        }
        return ans;
    }
};

int getMinOperations(vector<int> data) {
    int n = data.size();
    map<int, int> mp;
    for (int i = 0, j = 0; i < n; i++) {
        if (!mp.count(data[i])) {
            mp[data[i]] = j++;
        }
    }
    for (int &num : data) {
        num = mp[num];
    }
    DisjointSet ds(n);
    for (int i = 0; i < n / 2; i++) {
        if (data[i] != data[n - i - 1]) {
            ds.connect(data[i], data[n - i - 1]);
        }
    }
    return ds.count(n);
}

class FenwickTree:
    def __init__(self, n):
        self.n = n
        self.tree = [0] * (n + 1)
    
    def update(self, i, delta):
        while i <= self.n:
            self.tree[i] += delta
            i += i & (-i)
    
    def query(self, i):
        total = 0
        while i > 0:
            total += self.tree[i]
            i -= i & (-i)
        return total

def countSubsequences(arr, l, r):
    MOD = 10**9 + 7
    
    values = sorted(set(arr + [l-1, r]))
    value_map = {v: i+1 for i, v in enumerate(values)}
    
    ft = FenwickTree(len(value_map))
    result = 0
    prefix_mex = 0
    ft.update(value_map[prefix_mex], 1)
    
    for num in arr:
        if num < prefix_mex:
            ft.update(value_map[num], 1)
        else:
            while prefix_mex in value_map and ft.query(value_map[prefix_mex]) > 0:
                prefix_mex += 1
            if prefix_mex in value_map:
                ft.update(value_map[prefix_mex], 1)
        
        left = ft.query(value_map.get(l-1, 0))
        right = ft.query(value_map.get(r, 0))
        result = (result + (right - left)) % MOD
    
    return result

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

void processLogs(int n, vector<int>& pods, int m, const vector<vector<int>>& logs) {
    int globalThreshold = 0; 
    
    for (const auto& log : logs) {
        if (log[0] == 1) {
            int p = log[1] - 1; 
            pods[p] = max(pods[p], x); 
            if (pods[p] < globalThreshold) {
                pods[p] = globalThreshold;
            }
        } else if (log[0] == 2) {
            int x = log[2];
            globalThreshold = max(globalThreshold, x);
            
            for (int i = 0; i < n; ++i) {
                if (pods[i] < globalThreshold) {
                    pods[i] = globalThreshold;
                }
            }
        }
    }
    
    for (int i = 0; i < n; ++i) {
        cout << pods[i] << " ";
    }
    cout << endl;
}

#include <bits/stdc++.h>
using namespace std;

int solve(vector<vector<int>>& mat) {
    int m = mat.size();
    int n = mat[0].size();
    
    vector<vector<int>> dp(m, vector<int>(n, 0));

    dp[m-1][n-1] = 1;
    
    for (int j = n - 2; j >= 0; --j) {
        dp[m-1][j] = max(1, dp[m-1][j+1] - mat[m-1][j]);
    }

    for (int i = m - 2; i >= 0; --i) {
        dp[i][n-1] = max(1, dp[i+1][n-1] - mat[i][n-1]);
    }

    for (int i = m - 2; i >= 0; --i) {
        for (int j = n - 2; j >= 0; --j) {
            int mini = min(dp[i+1][j], dp[i][j+1]);
            dp[i][j] = max(1, mini - mat[i][j]);
        }
    }
    
    return dp[0][0];
}

int main() {
    int m, n;
    cin >> m >> n;
    vector<vector<int>> mat(m, vector<int>(n));
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            cin >> mat[i][j];
        }
    }
    
    cout << solve(mat) << endl;
    
    return 0;
}

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

const int MAXN = 1000;

vector<int> adjA[MAXN + 1];
vector<int> adjB[MAXN + 1];
bool visA[MAXN + 1];
bool visB[MAXN + 1];

void bfs(int s, vector<int> adj[], vector<int>& comp, bool vis[]) {
    queue<int> q;
    q.push(s);
    vis[s] = true;
    comp.push_back(s);
    
    while (!q.empty()) {
        int u = q.front(); q.pop();
        for (int v : adj[u]) {
            if (!vis[v]) {
                vis[v] = true;
                comp.push_back(v);
                q.push(v);
            }
        }
    }
}

void findComp(int n, vector<int> adj[], vector<vector<int>>& comps, bool vis[]) {
    fill(vis, vis + n + 1, false);

    for (int i = 1; i <= n; ++i) {
        if (!vis[i]) {
            vector<int> comp;
            bfs(i, adj, comp, vis);
            comps.push_back(comp);
        }
    }
}

int main() {
    int n, m1, m2;
    cin >> n >> m1 >> m2;

    for (int i = 0; i < m1; ++i) {
        int u, v;
        cin >> u >> v;
        adjA[u].push_back(v);
        adjA[v].push_back(u);
    }

    for (int i = 0; i < m2; ++i) {
        int u, v;
        cin >> u >> v;
        adjB[u].push_back(v);
        adjB[v].push_back(u);
    }

    vector<vector<int>> compsA, compsB;
    findComp(n, adjA, compsA, visA);
    findComp(n, adjB, compsB, visB);

    int numCompA = compsA.size();
    int numCompB = compsB.size();

    int maxEdges = (numCompA - 1) * (numCompB - 1);

    cout << maxEdges << endl;

    return 0;
}