Problem:
Score : 700 points

Problem Statement

Takahashi has a tower which is divided into N layers.
Initially, all the layers are uncolored. Takahashi is going to paint some of the layers in red, green or blue to make a beautiful tower.
He defines the beauty of the tower as follows:

The beauty of the tower is the sum of the scores of the N layers, where the score of a layer is A if the layer is painted red, A+B if the layer is painted green, B if the layer is painted blue, and 0 if the layer is uncolored.

Here, A and B are positive integer constants given beforehand. Also note that a layer may not be painted in two or more colors.

Takahashi is planning to paint the tower so that the beauty of the tower becomes exactly K.
How many such ways are there to paint the tower? Find the count modulo 998244353.
Two ways to paint the tower are considered different when there exists a layer that is painted in different colors, or a layer that is painted in some color in one of the ways and not in the other.

Constraints

1 ≤ N ≤ 3×10^5

1 ≤ A,B ≤ 3×10^5

0 ≤ K ≤ 18×10^{10}

All values in the input are integers.

Input

Input is given from Standard Input in the following format:

N A B K

Output

Print the number of the ways to paint tiles, modulo 998244353.

Sample Input 1

4 1 2 5

Sample Output 1

40

In this case, a red layer worth 1 points, a green layer worth 3 points and the blue layer worth 2 points. The beauty of the tower is 5 when we have one of the following sets of painted layers:

1 green, 1 blue

1 red, 2 blues

2 reds, 1 green

3 reds, 1 blue

The total number of the ways to produce them is 40.

Sample Input 2

2 5 6 0

Sample Output 2

1

The beauty of the tower is 0 only when all the layers are uncolored. Thus, the answer is 1.

Sample Input 3

90081 33447 90629 6391049189

Sample Output 3

577742975

Solution in Ruby (2.3.3) (judge verdict: Runtime Error)

#!/usr/bin/env ruby

# Generated by AtcoderGreedy on 2018-06-03
# AGC025 B

# my lib

module Enumerable
  # work just like String#split,
  # except this method does not use regex match
  # but check whether yield succeeds or not.
  def split
    current = nil
    ret = []
    each do |elem|
      if yield elem
        if current
          ret << current
          current = nil
        end
      elsif current
        current << elem
      else
        current = [elem]
      end
    end
    ret << current if current
    ret
  end
end

class Array
  # truncate tail, opposite of drop
  def clip(amount = 1)
    if amount < 0
      raise ArgumentError, "amount == #{amount}, cannot be negative!"
    end
    take_amount = size - amount
    take_amount < 0 ? [] : take(take_amount)
  end
end

# end of lib

# Your code here

MOD = 998244353

class ModularCalc
  def initialize(p)
    @p = p
  end

  attr_reader :p

  def n_choose_k(n, k)
    return 0 unless (0..n).cover? k
    return 1 if n == k || k == 0

    over = multiply(n - k + 1..n)
    under = multiply(1..k)

    under_inv = power(under, p - 2)
    (over * under_inv) % p
  end

  def multiply(enumerable)
    ret = 1
    enumerable.each do |i|
      ret *= i
      ret = ret % p
    end
    ret
  end

  def power(a, k)
    res = 1
    cur = a

    while k > 0
      if k % 2 != 0
        res = (res * cur) % p
      end
      k /= 2
      cur = (cur * cur) % p
    end
    res
  end

  class Combination
    def initialize(n, p)
      @modular_calc = ModularCalc.new p
      @n = n
      @p = p

      facts = Array.new(n + 1)
      facts[1] = 1
      (2..n).each do |i|
        facts[i] = (facts[i - 1] * i) % p
      end
      @facts = facts

      invs = Array.new(n + 1)
      facts.drop(1).each.with_index(1) do |fact, i|
        # $stderr.puts "#{i}: #{fact}"
        invs[i] = @modular_calc.power fact, p - 2
      end
      @invs = invs
    end

    def n_choose_k(n, k)
      return 0 unless n >= k && k >= 0
      return 1 if k.zero?
      args = [facts[n], invs[k], invs[n - k]]
      if args.any?(&:nil?)
        $stderr.puts({ n: n, k: k }.inspect)
        $stderr.puts invs.inspect
        $stderr.puts args.inspect
        raise 'hoge'
      end
      @modular_calc
        .multiply(args)
    end

    private

    attr_reader :facts, :invs
  end
end

N, A, B, K = gets.chomp.split(' ').map(&:to_i)

# $stderr.puts [N, A, B, K].inspect

class Calc
  def n_choose_k(n, k)
    @comb_calculator ||= ModularCalc::Combination.new N, MOD
    @comb_calculator.n_choose_k(n, k)
  end

  def a0
    @a0 ||=
      begin
        a = 0
        while a * A <= K
          return a if ((K - a * A) % B).zero?
          a += 1
        end
      end
  end

  def gcd
    @gcd ||=
      begin
        A.gcd(B)
      end
  end

  def main
    a = a0
    ret = 0
    while a * A <= K
      b = (K - a * A) / B
      raise 'hoge' unless ((K - a * A) % B).zero?

      n_c_a = n_choose_k(N, a)
      n_c_b = n_choose_k(N, b)
      # $stderr.puts "(a=#{a}, b=#{b}): nCa=#{n_c_a}, nCb=#{n_c_b}"

      comb = n_c_a * n_c_b
      comb = comb % MOD
      ret += comb
      ret = ret % MOD

      a += B / gcd
    end
    ret
  end
end

puts Calc.new.main