description: You are given four integer values a, b, c and m.
  
  Check if there exists a string that contains: 
  
    * a letters 'A'; 
    * b letters 'B'; 
    * c letters 'C'; 
    * no other letters; 
    * exactly m pairs of adjacent equal letters (exactly m such positions i that the i-th letter is equal to the (i+1)-th one). 
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of testcases.
  
  Each of the next t lines contains the description of the testcase — four integers a, b, c and m (1 ≤ a, b, c ≤ 10^8; 0 ≤ m ≤ 10^8).
  
  Output
  
  For each testcase print "YES" if there exists a string that satisfies all the requirements. Print "NO" if there are no such strings.
  
  You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES will all be recognized as positive answer).
  
  Example
  
  Input
  
  
  3
  2 2 1 0
  1 1 1 1
  1 2 3 2
  
  
  Output
  
  
  YES
  NO
  YES
  
  Note
  
  In the first testcase strings "ABCAB" or "BCABA" satisfy the requirements. There exist other possible strings.
  
  In the second testcase there's no way to put adjacent equal letters if there's no letter that appears at least twice.
  
  In the third testcase string "CABBCC" satisfies the requirements. There exist other possible strings.
solution: #!/usr/bin/env python
  from __future__ import division, print_function
  import heapq
  import os
  import copy 
  import sys
  from io import BytesIO, IOBase
  from typing import Counter, DefaultDict
  
  if sys.version_info[0] < 3:
      from __builtin__ import xrange as range
      from future_builtins import ascii, filter, hex, map, oct, zip
  
  
  def main():
      t = int(input())
      while t:
          a,b,c,m = map(int, input().split())
          arr = [a,b,c]
          arr.sort()
          mx = a+b+c-3
          mn = arr[2] - arr[1] - arr[0] - 1
          if m>=mn and m<=mx:
              print('YES')
          else:
              print('NO')
          t -= 1
  
  
  
  # 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):
          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")
  
  
  def print(*args, **kwargs):
      """Prints the values to a stream, or to sys.stdout by default."""
      sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
      at_start = True
      for x in args:
          if not at_start:
              file.write(sep)
          file.write(str(x))
          at_start = False
      file.write(kwargs.pop("end", "\n"))
      if kwargs.pop("flush", False):
          file.flush()
  
  
  if sys.version_info[0] < 3:
      sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
  else:
      sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  
  # endregion
  
  if __name__ == "__main__":
      main()
  