继续评价下我的码风

#include <bits/stdc++.h>
#include <cstdlib>
#define int __int128
int INF;
using namespace std;
struct SegmentTree{
    struct STree{
        int left, right;
        int min, max;
        int min_postive, max_negative;
        bool exists;
    }tree[400020]; 
    void build(int* arr, int p, int l, int r, void(*init)(SegmentTree::STree*, int, int*, int), void(*update)(SegmentTree::STree*, int)){
        tree[p].left = l, tree[p].right = r;
        if(l == r){
            tree[p].min = tree[p].max = arr[l];
            init(tree, p, arr, l);
            return;
        }
        int mid = (l + r) / 2;
        build(arr, p * 2, l, mid, init, update);
        build(arr, p * 2 + 1, mid + 1, r, init, update);
        tree[p].min = min(tree[p * 2].min, tree[p * 2 + 1].min);
        tree[p].max = max(tree[p * 2].max, tree[p * 2 + 1].max);
        update(tree, p);
        return;
    }
    int query(int p, int l, int r, int(*init)(SegmentTree::STree*, int), int(*update)(int, int), int pre_value){
        if(l <= tree[p].left and r >= tree[p].right){
            return init(tree, p);
        }
        int mid = (tree[p].left + tree[p].right) / 2, ret = pre_value;
        if(l <= mid) ret = update(ret, query(p * 2, l, r, init, update, pre_value));
        if(r > mid) ret = update(ret, query(p * 2 + 1, l, r, init, update, pre_value));
        return ret;
    }
}TreeA, TreeB;
void init_TreeA(SegmentTree::STree *tree, int p, int *arr, int pos){
    tree[p].min_postive = ((arr[pos] > 0) ? arr[pos] : INF);
    tree[p].max_negative = ((arr[pos] < 0) ? arr[pos] : -INF);
    tree[p].exists = (arr[pos] == 0);
}
void update_TreeA(SegmentTree::STree *tree, int p){
    tree[p].min_postive = min(tree[p * 2].min_postive, tree[p * 2 + 1].min_postive);
    tree[p].max_negative = max(tree[p * 2].max_negative, tree[p * 2 + 1].max_negative);
    tree[p].exists = tree[p * 2].exists || tree[p * 2 + 1].exists;
}
namespace __int128_IO{
    int read(){
        int x = 0, f = 1;
        char ch = getchar();
        while(ch < '0' || ch > '9'){
            if(ch == '-') f = -1;
            ch = getchar();
        }
        while(ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
        return x * f; 
    }
    void write(int x){
        if(x < 0) putchar('-'), x = -x;
        if(x > 9) write(x / 10);
        putchar(x % 10 + '0');
        return; 
    }
}
int A[100005], B[100005];
signed main(){
    memset(&INF, 0x7f, sizeof(INF));
    int n = __int128_IO::read(), m = __int128_IO::read(), q = __int128_IO::read();
    for(int i = 1; i <= n; i++) A[i] = __int128_IO::read();
    for(int i = 1; i <= m; i++) B[i] = __int128_IO::read();
    TreeA.build(A, 1, 1, n, init_TreeA, update_TreeA);
    TreeB.build(B, 1, 1, m, [](SegmentTree::STree *tree, int p, int *arr, int pos){}, [](SegmentTree::STree *tree, int p){});
    auto Max = [](int a, int b)->int{return (a > b) ? a : b;};
    auto Min = [](int a, int b)->int{return (a < b) ? a : b;};
    auto Or = [](int a, int b)->int{return a || b;};
    while(q--){
        int l1 = __int128_IO::read(), r1 = __int128_IO::read(), l2 = __int128_IO::read(), r2 = __int128_IO::read(), ans = 0;
        int max_M = TreeA.query(1, l1, r1, [](SegmentTree::STree *tree, int p)->int{return tree[p].max;}, Max, -INF);
        int min_M = TreeA.query(1, l1, r1, [](SegmentTree::STree *tree, int p)->int{return tree[p].min;}, Min, INF);
        int max_N = TreeB.query(1, l2, r2, [](SegmentTree::STree *tree, int p)->int{return tree[p].max;}, Max, -INF);
        int min_N = TreeB.query(1, l2, r2, [](SegmentTree::STree *tree, int p)->int{return tree[p].min;}, Min, INF);
        int min_postive = TreeA.query(1, l1, r1, [](SegmentTree::STree *tree, int p)->int{return tree[p].min_postive;}, Min, INF);
        int max_negative = TreeA.query(1, l1, r1, [](SegmentTree::STree *tree, int p)->int{return tree[p].max_negative;}, Max, -INF);
        bool exist_zero = TreeA.query(1, l1, r1, [](SegmentTree::STree *tree, int p)->int{return tree[p].exists;}, Or, 0); 
        if(min_M > 0 and min_N > 0) ans = max_M * min_N;
        else if(min_M > 0 and max_N < 0) ans = min_M * min_N;
        else if(max_M < 0 and min_M > 0) ans = max_M * max_N;
        else if(max_M < 0 and max_N < 0) ans = min_M * max_N;
        else if(min_M < 0 && max_M > 0 && min_N > 0) ans = max_M * min_N;
        else if(min_M < 0 && max_M > 0 && max_N < 0) ans = min_M * max_N;
        else if(min_M > 0 && min_N < 0 && max_N > 0) ans = min_M * min_N;
        else if(max_M < 0 && min_N < 0 && max_N > 0) ans = max_M * max_N;
        else if(exist_zero && min_N < 0 && max_N > 0) ans = 0;
        else ans = max(min_postive * min_N, max_negative * max_N);
        __int128_IO::write(ans), putchar('\n');
    }
    return 0;
}