#include <bits/stdc++.h>
using ll = long long ;
using namespace std;
ll calculateResult(vector<ll>& arr, ll n, ll k) {
    set<int> st;
    ll ans = 0;
    ll sum = 0;
    sort(arr.begin(), arr.end(), greater<int>());
    for (ll i = 0; i < n; i++) {
        if (st.find(arr[i]) != st.end()) {
            continue;
        }
        if (arr[i] - sum > 0) {
            sum += k;  
            ans++;    
            st.insert(arr[i]);  
        }
    }
    return ans;
}

#include <iostream>
#include <vector>
using namespace std;
vector<int> solve(const vector<int>& arr) {
    int n = arr.size();
    vector<int> result;
        for (int i = 0; i < n - 2; i++) {
        int a = arr[i];
        int b = arr[i + 1];
        int c = arr[i + 2];
                if (a + b > c && a + c > b && b + c > a) {
            result.push_back(1);
        } else {
            result.push_back(0);
        }
    }
    
    return result;
}

#include <bits/stdc++.h>
using ll = long long ;
using namespace std;
bool isPalindrome(int number) {
    string str =to_string(number);
    int left = 0, right = str.size() - 1;
    while (left < right) {
        if (str[left] != str[right]) {
            return false;
        }
        left++;
        right--;
    }
    return true; 
}
vector<int> findPalindromicTransactions(vector<int>& transactions) {
    std::vector<int> palindromicIDs;
    for (int transaction : transactions) {
        if (isPalindrome(transaction)) {
            palindromicIDs.push_back(transaction);
        }
    }

    sort(palindromicIDs.begin(), palindromicIDs.end(),greater<int>());

    return palindromicIDs; 
}

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

long maximize(int x_rows, int x_columns, vector<vector<int>>& x) {
    vector<vector<long>> prefixSum(x_rows + 1, vector<long>(x_columns + 1, 0));
    for (int i = 1; i <= x_rows; ++i) {
        for (int j = 1; j <= x_columns; ++j) {
            prefixSum[i][j] = x[i-1][j-1] + 
                               prefixSum[i-1][j] + 
                               prefixSum[i][j-1] - 
                               prefixSum[i-1][j-1];
        }
    }

    long maxF = 0; 

    for (int h = 1; h < x_rows; ++h) {
        for (int v = 1; v < x_columns; ++v) {
            long sumA = prefixSum[h][v]; 
            long sumB = prefixSum[h][x_columns] - prefixSum[h][v];
            long sumC = prefixSum[x_rows][v] - prefixSum[h][v]; 
            long sumD = prefixSum[x_rows][x_columns] - prefixSum[h][x_columns] - prefixSum[x_rows][v] + prefixSum[h][v]; // Bottom-right
            long fX = abs(sumA) + abs(sumB) + abs(sumC) + abs(sumD);
            maxF = max(maxF, fX);
        }
    }

    return maxF;
}

def ss(firstnum: str, secondnum: str, thirdnum: str) -> bool:
    target_sum = int(thirdnum)
    second_value = int(secondnum)
    if int(firstnum) + second_value == target_sum:
        return True
    for i in range(len(firstnum)):
        new_firstnum = firstnum[:i] + firstnum[i+1:]
        if new_firstnum and (new_firstnum[0] != '0'): 
            if int(new_firstnum) + second_value == target_sum:
                return True
    return False