output_description: If A and C can communicate, print `Yes`; if they cannot, print `No`.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      a b c d
attempt: #!usr/bin/env python3
  from collections import defaultdict
  from collections import deque
  from heapq import heappush, heappop
  import sys
  import math
  import bisect
  import random
  import itertools
  
  sys.setrecursionlimit(10**5)
  stdin = sys.stdin
  
  
  def LI():
      return list(map(int, stdin.readline().split()))
  
  
  def LF():
      return list(map(float, stdin.readline().split()))
  
  
  def LI_():
      return list(map(lambda x: int(x) - 1, stdin.readline().split()))
  
  
  def II():
      return int(stdin.readline())
  
  
  def IF():
      return float(stdin.readline())
  
  
  def LS():
      return list(map(list, stdin.readline().split()))
  
  
  def S():
      return list(stdin.readline().rstrip())
  
  
  def IR(n):
      return [II() for _ in range(n)]
  
  
  def LIR(n):
      return [LI() for _ in range(n)]
  
  
  def FR(n):
      return [IF() for _ in range(n)]
  
  
  def LFR(n):
      return [LI() for _ in range(n)]
  
  
  def LIR_(n):
      return [LI_() for _ in range(n)]
  
  
  def SR(n):
      return [S() for _ in range(n)]
  
  
  def LSR(n):
      return [LS() for _ in range(n)]
  
  
  mod = 1000000007
  inf = float("INF")
  
  
  # A
  def A():
      a, b, c, d = LI()
      x = abs(a - b) + abs(b - c)
      y = abs(a - c)
      if x <= d or y <= d:
          print("Yes")
      else:
          print("No")
      return
  
  
  # B
  def B():
      return
  
  
  # C
  def C():
      s = stdin.readline().rstrip()
      K = II() - 1
      ans = []
      for i in range(len(s)):
          for k in range(K + 1):
              b = s[i : i + k + 1]
              ans.append(b)
      ans = list(set(ans))
      ans.sort()
      print(ans[K])
      return
  
  
  # D
  def D():
      n, m = LI()
      p = LI_()
      xy = LIR_(m)
      size = [1 for _ in range(n)]
      height = [1 for _ in range(n)]
      par = [i for i in range(n)]
  
      def find(x):
          if par[x] == x:
              return x
          else:
              par[x] = find(par[x])
              return par[x]
  
      def union(x, y):
          s1 = find(x)
          s2 = find(y)
          if s1 != s2:
              if height[s1] < height[s2]:
                  par[s1] = s2
                  size[s2] += size[s1]
                  size[s1] = 0
              else:
                  par[s2] = s1
                  size[s1] += size[s2]
                  size[s2] = 0
                  if height[s1] == height[s2]:
                      height[s1] += 1
  
      for x, y in xy:
          union(x, y)
      ans = 0
      for i in range(n):
          if find(p[i]) == find(i):
              ans += 1
  
      print(ans)
      return
  
  
  # E
  def E():
      return
  
  
  # F
  def F():
      return
  
  
  # G
  def G():
      return
  
  
  # H
  def H():
      return
  
  
  # Solve
  if __name__ == "__main__":
      A()
  
problem_description: Statement
  
  Three people, A, B and C, are trying to communicate using transceivers. They
  are standing along a number line, and the coordinates of A, B and C are a, b
  and c (in meters), respectively. Two people can directly communicate when the
  distance between them is at most d meters. Determine if A and C can
  communicate, either directly or indirectly. Here, A and C can indirectly
  communicate when A and B can directly communicate and also B and C can
  directly communicate.
samples: [{"input": "4 7 9 3", "output": "Yes\n    \n\nA and B can directly communicate, and also B and C can directly communicate,\nso we should print `Yes`.\n\n* * *"}, {"input": "100 10 1 2", "output": "No\n    \n\nThey cannot communicate in this case.\n\n* * *"}, {"input": "10 10 10 1", "output": "Yes\n    \n\nThere can be multiple people at the same position.\n\n* * *"}, {"input": "1 100 2 10", "output": "Yes"}]