output_description: Print the answer.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      R G B N
attempt: #!/usr/bin/env python
  import os
  import sys
  from io import BytesIO, IOBase
  from typing import List
  
  
  class Solution:
      def numSubarrayProductLessThanK(self, nums: List[int], k: int) -> int:
          left = 0
          ans, prod = 0, 1
          lenght = 0
          for num in nums:
              if prod * num >= k:
                  prod *= num
                  lenght += 1
                  while prod >= k:
                      prod //= nums[left]
                      left += 1
                      lenght -= 1
                  ans += lenght
              else:
                  prod *= num
                  lenght += 1
                  ans += lenght
              # print(ans)
  
          return ans
  
  
  def main() -> None:
      r, g, b, n = map(int, input().split())
  
      cnt = 0
      for i in range(0, n + 1, r):
          for j in range(0, n + 1, g):
              k = n - i - j
              if k % b != 0:
                  continue
              # k //= b
  
              if i + j + k == n and k >= 0:
                  cnt += 1
              # print(i, j, k )
  
      print(cnt)
  
  
  # region fastio
  
  BUFSIZE = 8192
  
  
  class FastIO(IOBase):
      newlines = 0
  
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "x" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
  
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
  
      def readline(self, **kwargs):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
  
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
  
  
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  
  
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  
  # endregion
  
  if __name__ == "__main__":
      main()
  
problem_description: Statement
  
  Snuke has come to a store that sells boxes containing balls. The store sells
  the following three kinds of boxes:
  
    * Red boxes, each containing R red balls
    * Green boxes, each containing G green balls
    * Blue boxes, each containing B blue balls
  
  Snuke wants to get a total of exactly N balls by buying r red boxes, g green
  boxes and b blue boxes. How many triples of non-negative integers (r,g,b)
  achieve this?
samples: [{"input": "1 2 3 4", "output": "4\n    \n\nFour triples achieve the objective, as follows:\n\n  * (4,0,0)\n  * (2,1,0)\n  * (1,0,1)\n  * (0,2,0)\n\n* * *"}, {"input": "13 1 4 3000", "output": "87058"}]