Buggy python submission (verdict: Time Limit Exceeded):
N, A, B, K = [int(_) for _ in input().split()]

def gcd(a, b):
    if a < b:
        a, b = b, a
    while b:
        a, b = b, a % b
    return a

L = 300000+1
M = 998244353

Fm = {}
inverseFm = {}
x = 1
for i in range(L):
    Fm[i] = x
    x = x * (i + 1) % M

def inverseFm(x, cache={}):
    if x in cache:
        return cache[x]
    result = pow(Fm[x], M - 2, M)
    cache[x] = result
    return result

def C(n, r):
    result = Fm[n] * inverseFm(r) * inverseFm(n - r) % M
    return result

def solve(N, A, B, K):
    g = gcd(gcd(A, B), K)
    A, B, K = A//g, B//g, K//g
    if A > B:
        A, B = B, A
    l = A * B // gcd(A, B)
    x = K
    for i in range(min(N + 1, l)):
        if x % B == 0:
            break
        x -= A
    else:
        return 0
    result = 0
    for a in range(i, N + 1, B):
        b = (K - A * a) // B
        for x in range(max(0, a-b), min(N-b+1, a+1)):
            y = a - x
            z = b - y
            d = Fm[N] * inverseFm(x) * inverseFm(y) * inverseFm(z) * inverseFm(N - x - y - z) % M
  #          print("s", x, y, z)
            result = (result + d) % M
    return result 

def solve0(N, A, B, K):
    result = 0
    for x in range(0, N + 1):
        for y in range(0, N + 1 - x):
            for z in range(0, N + 1 - x - y):
                if A * x + (A + B) * y + B * z == K:
 #                   print("s0", x, y, z)
                    d = Fm[N] * inverseFm(x) * inverseFm(y) * inverseFm(z) * inverseFm(N - x - y - z) % M
                    result = (result + d) % M
    return result                   


def check():
    import random
    for i in range(100):
        N = random.randint(1, 20)
        A = random.randint(1, 20)
        B = random.randint(1, 20)
        K = random.randint(1, 20)
        r = solve(N, A, B, K)
        r0 = solve0(N, A, B, K)
        if r != r0:
            print(N, A, B, K, r, r0)

#check()
print(solve(N, A, B, K))
#print(solve0(N, A, B, K))


Fixed submission:
N, A, B, K = [int(_) for _ in input().split()]

L = 300000+1
M = 998244353

Fm = {}
inverseFm = {}
x = 1
for i in range(L):
    Fm[i] = x
    x = x * (i + 1) % M

def inverseFm(x, cache={}):
    if x in cache:
        return cache[x]
    result = pow(Fm[x], M - 2, M)
    cache[x] = result
    return result

def C(n, r):
    result = Fm[n] * inverseFm(r) * inverseFm(n - r) % M
    return result

def solve(N, A, B, K):
    result = 0
    for a in range(0, N+1):
        b, m = divmod(K - A * a, B)
        if m == 0 and 0 <= b <= N:
            result += C(N, a) * C(N, b) % M
    return result % M

print(solve(N, A, B, K))

Buggy python submission (verdict: Runtime Error):

N, A, B, K = [int(_) for _ in input().split()]


def solve0(N, A, B, K):
    result = 0
    for r in range(0, N + 1):
        for g in range(0, N + 1 - r):
            for b in range(0, N + 1 - r - g):
                if A * r + (A + B) * g + B * b == K:
                    result += 0
    return result

def gcd(a, b):
    if a < b:
        a, b = b, a
    while b:
        a, b = b, a % b
    return a

#from collections import defaultdict
#xs = defaultdict(int)

L = 300000

M = 998244353

Fm = {}
inverseFm = {}
x = 1
for i in range(L):
    Fm[i] = x
    x = x * (i + 1) % M

def inverseFm(x, cache={}):
    if x in cache:
        return cache[x]
    result = pow(Fm[x], M - 2, M)
    cache[x] = result
    return result

def C(n, r):
    result = Fm[n] * inverseFm(r) * inverseFm(n - r) % M
    return result

def solve(N, A, B, K):
    for i in range(N + 1):
        x = K - A * i
        if x % B == 0:
            break
    else:
        return 0
    l = A * B // gcd(A, B)
    result = 0
    for a in range(i, N + 1, l):
        b = (K - A * a) // B
        for x in range(0, a + 1):
            y = a - x
            z = b - y
            if z >= 0 and x + y + z <= N:
                result = (result + (C(N, x) * C(N - x, y) * C(N - x - y, z)) % M) % M
    return result 

print(solve(N, A, B, K))



Fixed submission:
N, A, B, K = [int(_) for _ in input().split()]

L = 300000+1
M = 998244353

Fm = {}
inverseFm = {}
x = 1
for i in range(L):
    Fm[i] = x
    x = x * (i + 1) % M

def inverseFm(x, cache={}):
    if x in cache:
        return cache[x]
    result = pow(Fm[x], M - 2, M)
    cache[x] = result
    return result

def C(n, r):
    result = Fm[n] * inverseFm(r) * inverseFm(n - r) % M
    return result

def solve(N, A, B, K):
    result = 0
    for a in range(0, N+1):
        b, m = divmod(K - A * a, B)
        if m == 0 and 0 <= b <= N:
            result += C(N, a) * C(N, b) % M
    return result % M

print(solve(N, A, B, K))