import sys
MOD=998244353

def mult(a, b, K):
    res = [0] * K
    for i in range(K):
        ai = a[i]
        if ai:
            for j in range(K):
                res[(i + j) % K] = (res[(i + j) % K] + ai * b[j]) % MOD
    return res

def power(a, e, K):
    res = [0] * K
    res[0] = 1
    while e:
        if e & 1:
            res = mult(res, a, K)
        a = mult(a, a, K)
        e >>= 1
    return res

def main():
    input = sys.stdin.read
    data = list(map(int, input().split()))
    
    ptr = 0
    N = data[ptr]
    P = data[ptr + 1]
    K = data[ptr + 2]
    ptr += 3
    
    M = data[ptr]
    ptr += 1
    
    L = data[ptr:ptr + M]
    ptr += M
    
    C = [P // K + (1 if j > 0 and j <= P % K else 0) for j in range(K)]
    LC = [0] * K
    
    for x in L:
        LC[x % K] += 1
    
    Cn = [(C[j] - LC[j]) % MOD for j in range(K)]
    
    T = power(C, N, K)[0]
    B = power(Cn, N, K)[0]
    
    print((T - B) % MOD)

main()

Lucky Charm
Rubrik ✅

Company Name: McAfee
Batch eligible: 2025 and 2026 grads

1) Software Engineering Intern
Apply: https://careers.mcafee.com/global/en/job/MCAFGLOBALJR0031354ENGLOBALEXTERNAL/Software-Engineering-Intern

2) Graduate Technical Intern
Apply: https://careers.mcafee.com/global/en/job/JR0031351/Graduate-Technical-Intern

3) Graduate Technical Intern
Apply: https://careers.mcafee.com/global/en/job/JR0031352/Graduate-Technical-Intern

Drona Pay is hiring for Data Engineering - Intern  (Remote)

Experience : 0 - 1 year's
Expected Stipend : 5-6 LPA

Apply here : https://wellfound.com/jobs/3129311-data-engineering-intern

Meesho is hiring Senior Business Associate

MBA grads ( Tier l )
2023/2024 passouts

Apply Here : https://forms.gle/X6XwQ7sUq8eKeeCL8

Mokkup.ai is hiring Product Manager

For 2022, 2023, 2024 grads
Location: Remote
https://www.linkedin.com/jobs/view/4036407648

MindTickle is hiring Front-end Engineer

For 2021, 2022, 2023 grads
Location: Bangalore

https://jobs.lever.co/mindtickle/011afcfc-09da-48f6-8acc-d49a13791327/apply?source=LinkedIn

Check out this job at GrowthX®: https://www.linkedin.com/jobs/view/4042232766

Jobs at Bungee
https://bungeetech-talent.freshteam.com/jobs/_bMAyd64_HRK/data-engineer-intern-remote?ft_source=5000529098&ft_medium=5000472938

Check out this job at HoloHire: https://www.linkedin.com/jobs/view/4051629407

https://docs.google.com/forms/d/e/1FAIpQLSeyLRT0NUVM0isRGZuROAihHGa4BPE9w7BIZx0ANmfiRyhOzQ/viewform?usp=sf_link

NIT olny

nt FUNC(vector<int> &v){
    unordered_set<int> st(v.begin(),v.end());

    for(int i=0;i<31;i++){
        if(st.find(1<<i)==st.end()){
            return 1<<i;
        }
    }

    return -1;

}

Aptiv ✅

def solution(p, q, r):
    factorial_q = math.factorial(q)   
    result = pow(p, factorial_q, r)
    return result

Uber ✅

#define ll long long
#define N 110
#define MOD 1000000007
int solution(string p, string q, string r) {
    int n = p.size();
    int m = q.size();
    int k = r.size();

    // 1-indexing
    p = "*" + p;
    q = "*" + q;
    r = "*" + r;

    ll dp[N][N][N] = {};  // Initialize the dp array to zero
    dp[0][0][0] = 1;      // Base case

    // Fill the dp table
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= m; j++) {
            for (int len = 0; len < k; len++) {
                if (dp[i][j][len]) {
                    // Check the next characters from string p
                    for (int ni = i + 1; ni <= n; ni++) {
                        if (p[ni] == r[len + 1]) {
                            dp[ni][j][len + 1] = (dp[ni][j][len + 1] + dp[i][j][len]) % MOD;
                        }
                    }
                    // Check the next characters from string q
                    for (int nj = j + 1; nj <= m; nj++) {
                        if (q[nj] == r[len + 1]) {
                            dp[i][nj][len + 1] = (dp[i][nj][len + 1] + dp[i][j][len]) % MOD;
                        }
                    }
                }
            }
        }
    }

    // Calculate the final answer
    ll ans = 0;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            ans = (ans + dp[i][j][k]) % MOD;
        }
    }

    return ans;  // Return the calculated result
}

Uber ✅

def ss(wordlist):
    a = [] 
    for word in wordlist:
        if len(word) % 2 == 0:
            a.append(word[::-1])
        else:
            a.append(word.upper())
    return a

Uber ✅

from collections import Counter
def digit_root(n):
    if n == 0:
        return 0
    return 1 + (n - 1) % 9
def ss(readings):
    reduced_readings = [digit_root(num) for num in readings]
    freq = Counter(reduced_readings)
    v = max(freq.keys(), key=lambda x: (freq[x], x))
    return v

Uber ✅