def findPodCount(n, pods, logs):
    for start, end, x in logs:
        for i in range(start - 1, end):
            pods[i] = max(pods[i], x)
    
    min_pods = min(pods)
    return [max(pod, min_pods) for pod in pods]

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cstring>
using namespace std;
int dfs(int i, bool b1, bool b2, int sum_val, vector<vector<vector<vector<int>>>>& dp, const vector<char>& sv, const vector<char>& bv, int n) {
    if (sum_val < 0 || sum_val > 9 * (n - i))
        return 0;
    if (i == n)
        return sum_val == 0 ? 1 : 0;
    if (dp[i][b1][b2][sum_val] != -1)
        return dp[i][b1][b2][sum_val];
    
    int ans = 0;
    for (int j = 0; j < 10; ++j) {
        char j_char = '0' + j;
        if (!b1 && j_char < sv[i])
            continue;
        if (!b2 && j_char > bv[i])
            continue;
        ans += dfs(i + 1, b1 || (j_char > sv[i]), b2 || (j_char < bv[i]), sum_val - j, dp, sv, bv, n);
    }
    dp[i][b1][b2][sum_val] = ans;
    return ans;
}

// Main function to find the number of ways to choose the sum
vector<long> waysToChooseSum(long lowLimit, long highLimit) {
    string sv = to_string(lowLimit);
    string bv = to_string(highLimit);
    int n = max(sv.size(), bv.size());
    sv = string(n - sv.size(), '0') + sv;
    bv = string(n - bv.size(), '0') + bv;
    
    vector<vector<vector<vector<int>>>> dp(n, vector<vector<vector<int>>>(2, vector<vector<int>>(2, vector<int>(200, -1))));
    
    long fans = 0;
    long fsum = 0;
    
    for (int i = 0; i <= 10 * n; ++i) {
        int ans = dfs(0, false, false, i, dp, vector<char>(sv.begin(), sv.end()), vector<char>(bv.begin(), bv.end()), n);
        if (ans > fans) {
            fans = ans;
            fsum = 1;
        } else if (ans == fans) {
            ++fsum;
        }
    }
    
    return {fsum, fans};
}

WITH student_course_count AS (
    SELECT student_id, COUNT(*) AS course_count
    FROM Enrollments
    GROUP BY student_id
),
max_course_count AS (
    SELECT MAX(course_count) AS max_count
    FROM student_course_count
)
SELECT s.name
FROM Students s
JOIN student_course_count scc ON s.student_id = scc.student_id
JOIN max_course_count mcc ON scc.course_count = mcc.max_count
ORDER BY s.name;

#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;
}