Unknown Error问题

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {
    // 模2^32的掩码，用于截断无符号32位整数
    private static final long MASK_32 = 0xFFFFFFFFL;

    public static void main(String[] args) throws IOException {
        // 快速读入配置：使用StringTokenizer逐词读取，避免大数组拆分异常
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);
        StringTokenizer st = new StringTokenizer(br.readLine());

        // 读取基础参数
        int n = Integer.parseInt(st.nextToken());
        int d = Integer.parseInt(st.nextToken());
        int p = Integer.parseInt(st.nextToken());

        // 读取a数组
        st = new StringTokenizer(br.readLine());
        long[] a = new long[n];
        for (int i = 0; i < n; i++) {
            a[i] = Long.parseLong(st.nextToken());
        }

        // 读取w数组（w_i < 2^32，用long存储避免溢出，保留原数组顺序）
        st = new StringTokenizer(br.readLine());
        long[] w = new long[n];
        for (int i = 0; i < n; i++) {
            w[i] = Long.parseLong(st.nextToken()) & MASK_32;
        }

        // 计算M = p^d，处理d=0的情况（p^0=1），避免溢出
        int M = 1;
        for (int i = 0; i < d; i++) {
            M *= p;
            // 防护：避免极端情况（题目保证d≤12，此处仅为兼容）
            if (M > 1 << 20) break;
        }

        // 读取z数组
        st = new StringTokenizer(br.readLine());
        long[] z = new long[M];
        for (int i = 0; i < M; i++) {
            if (st.hasMoreTokens()) {
                z[i] = Long.parseLong(st.nextToken()) & MASK_32;
            } else {
                z[i] = 0;
            }
        }

        // 读取询问次数q
        int q = Integer.parseInt(br.readLine());

        // 预处理：aDigits[i][k] 表示a[i]的第k位p进制数（低位在前，补前导0）
        int[][] aDigits = new int[n][d];
        for (int i = 0; i < n; i++) {
            long num = a[i];
            for (int k = 0; k < d; k++) {
                aDigits[i][k] = (int) (num % p);
                num = num / p;
            }
        }

        // 预处理：uDigits[u][k] 表示u的第k位p进制数（低位在前，补前导0）
        int[][] uDigits = new int[M][d];
        for (int u = 0; u < M; u++) {
            int num = u;
            for (int k = 0; k < d; k++) {
                uDigits[u][k] = num % p;
                num = num / p;
            }
        }

        // 复用b数组，避免频繁创建ArrayList，减少内存波动
        long[] bArr = new long[n];

        // 处理每个询问
        while (q-- > 0) {
            st = new StringTokenizer(br.readLine());
            long A = Long.parseLong(st.nextToken());
            long B = Long.parseLong(st.nextToken());
            long C = Long.parseLong(st.nextToken());
            int l1 = Integer.parseInt(st.nextToken());
            int r1 = Integer.parseInt(st.nextToken());
            int l2 = Integer.parseInt(st.nextToken()); // 保留1索引
            int r2 = Integer.parseInt(st.nextToken());

            // 步骤1：预计算wTable[aVal][uVal]，存储单步贡献
            long[][] wTable = new long[p][p];
            for (int aVal = 0; aVal < p; aVal++) {
                for (int uVal = 0; uVal < p; uVal++) {
                    int c1 = (Math.min(aVal, uVal) > 0) ? 1 : 0;
                    int c2 = (Math.max(aVal, uVal) > 0) ? 1 : 0;
                    int c3 = ((aVal + uVal) % p > 0) ? 1 : 0;
                    wTable[aVal][uVal] = (A * c1 + B * c2 + C * c3);
                }
            }

            // 步骤2：遍历u∈[l1, r1]，计算总贡献
            long ans = 0;
            for (int u = l1; u <= r1; u++) {
                // 步骤2.1：计算所有b_i(u)，复用全局数组，避免创建新集合
                for (int i = 0; i < n; i++) {
                    long bi = 0;
                    for (int k = 0; k < d; k++) {
                        int aVal = aDigits[i][k];
                        int uVal = uDigits[u][k];
                        bi += wTable[aVal][uVal];
                    }
                    bArr[i] = bi;
                }

                // 步骤2.2：对bArr单独排序，得到F(u)（符合题目定义）
                Arrays.sort(bArr);

                // 步骤2.3：计算j∈[l2, r2]的和：∑(w[j-1] * F(u)[j-1])（转为0索引）
                long intervalSum = 0;
                for (int j = l2; j <= r2; j++) {
                    int idx = j - 1; // 1索引转0索引，避免越界
                    if (idx < 0 || idx >= n) continue; // 边界防护，洛谷评测环境友好
                    long fj = bArr[idx] & MASK_32; // F(u)_j
                    long wj = w[idx]; // 原数组第j位w（不随b排序变化）
                    long product = (fj * wj) & MASK_32;
                    intervalSum = (intervalSum + product) & MASK_32;
                }

                // 步骤2.4：计算当前u的贡献，累加至总答案
                long zu = z[u] & MASK_32;
                long uContribution = (zu * intervalSum) & MASK_32;
                ans = (ans + uContribution) & MASK_32;
            }

            // 步骤3：输出结果，直接println，依赖PrintWriter缓冲区
            pw.println(ans & MASK_32);
        }

        // 强制刷新缓冲区，确保所有输出写入标准输出
        pw.flush();
        pw.close();
        br.close();
    }
}