output_description: Print the minimum number of bombs needed to win.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N D A
      X_1 H_1
      :
      X_N H_N
attempt: import sys
  
  input = sys.stdin.readline
  N, D, A = [int(_) for _ in input().split()]
  XH = sorted([[int(_) for _ in input().split()] + [0] for _ in range(N)])
  XH2 = [[xh[0] + 2 * D + 1, i, 1] for i, xh in enumerate(XH)]
  XH3 = sorted(XH + XH2)
  bombs = [-1] * N
  for i, xh in enumerate(XH3):
      if xh[2]:
          bombs[xh[1]] = i - xh[1]
  
  
  class LazySegmentTree:
      def __init__(self, array, f, g, h, ti, ei):
          """
          Parameters
          ----------
          array : list
              to construct segment tree from
          f : func
              binary operation of the monoid
              T x T -> T
              T is dat
          g : func
              binary operation of the monoid
              T x E -> T
              T is dat, E is laz
          h : func
              binary operation of the monoid
              E x E -> T
              E is laz
          ti : T
              identity element of T
          ei : E
              identity element of E
          """
          self.f = f
          self.g = g
          self.h = h
          self.ti = ti
          self.ei = ei
          self.height = height = len(array).bit_length()
          self.n = n = 2**height
          self.dat = dat = [ti] * n + array + [ti] * (n - len(array))
          self.laz = [ei] * (2 * n)
          for i in range(n - 1, 0, -1):  # build
              dat[i] = f(dat[i << 1], dat[i << 1 | 1])
  
      def reflect(self, k):
          dat = self.dat
          ei = self.ei
          laz = self.laz
          g = self.g
          return self.dat[k] if laz[k] is ei else g(dat[k], laz[k])
  
      def evaluate(self, k):
          laz = self.laz
          ei = self.ei
          reflect = self.reflect
          dat = self.dat
          h = self.h
          if laz[k] is ei:
              return
          laz[(k << 1) | 0] = h(laz[(k << 1) | 0], laz[k])
          laz[(k << 1) | 1] = h(laz[(k << 1) | 1], laz[k])
          dat[k] = reflect(k)
          laz[k] = ei
  
      def thrust(self, k):
          height = self.height
          evaluate = self.evaluate
          for i in range(height, 0, -1):
              evaluate(k >> i)
  
      def recalc(self, k):
          dat = self.dat
          reflect = self.reflect
          f = self.f
          while k:
              k >>= 1
              dat[k] = f(reflect((k << 1) | 0), reflect((k << 1) | 1))
  
      def update(self, a, b, x):  # set value at position [a, b) (0-indexed)
          thrust = self.thrust
          n = self.n
          h = self.h
          laz = self.laz
          recalc = self.recalc
          a += n
          b += n - 1
          l = a
          r = b + 1
          thrust(a)
          thrust(b)
          while l < r:
              if l & 1:
                  laz[l] = h(laz[l], x)
                  l += 1
              if r & 1:
                  r -= 1
                  laz[r] = h(laz[r], x)
              l >>= 1
              r >>= 1
          recalc(a)
          recalc(b)
  
      def set_val(self, a, x):
          n = self.n
          thrust = self.thrust
          dat = self.dat
          laz = self.laz
          recalc = self.recalc
          ei = self.ei
          a += n
          thrust(a)
          dat[a] = x
          laz[a] = ei
          recalc(a)
  
      def get_val(self, a):
          a += self.n
          res = self.dat[a]
          while a:
              if self.laz[a] != self.ei:
                  res = self.g(res, self.laz[a])
              a //= 2
          return res
  
      def query(self, a, b):  # result on interval [a, b) (0-indexed)
          f = self.f
          ti = self.ti
          n = self.n
          thrust = self.thrust
          reflect = self.reflect
          a += n
          b += n - 1
          thrust(a)
          thrust(b)
          l = a
          r = b + 1
          vl = vr = ti
          while l < r:
              if l & 1:
                  vl = f(vl, reflect(l))
                  l += 1
              if r & 1:
                  r -= 1
                  vr = f(reflect(r), vr)
              l >>= 1
              r >>= 1
          return f(vl, vr)
  
  
  # RMQ and RAQ
  array = [(xh[1], 1) for xh in XH]
  f = max
  g = lambda a, b: (a[0] + a[1] * b, a[1])
  h = lambda a, b: a + b
  ti = (-float("inf"), 0)
  ei = 0
  
  LST = LazySegmentTree(array=array, ti=ti, ei=ei, f=f, g=g, h=h)
  ans = 0
  for i in range(N):
      this = LST.query(i, i + 1)[0]
      if this > 0:
          c = (this - 1) // A + 1
          ans += c
          LST.update(i, bombs[i], -A * c)
  print(ans)
  
problem_description: Statement
  
  Silver Fox is fighting with N monsters.
  
  The monsters are standing in a row, and we can assume them to be standing on a
  number line. The i-th monster, standing at the coordinate X_i, has the
  _health_ of H_i.
  
  Silver Fox can use bombs to attack the monsters. Using a bomb at the
  coordinate x decreases the healths of all monsters between the coordinates x-D
  and x+D (inclusive) by A. There is no way other than bombs to decrease the
  monster's health.
  
  Silver Fox wins when all the monsters' healths become 0 or below.
  
  Find the minimum number of bombs needed to win.
samples: [{"input": "3 3 2\n    1 2\n    5 4\n    9 2", "output": "2\n    \n\nFirst, let us use a bomb at the coordinate 4 to decrease the first and second\nmonsters' health by 2.\n\nThen, use a bomb at the coordinate 6 to decrease the second and third\nmonsters' health by 2.\n\nNow, all the monsters' healths are 0. We cannot make all the monsters' health\ndrop to 0 or below with just one bomb.\n\n* * *"}, {"input": "9 4 1\n    1 5\n    2 4\n    3 3\n    4 2\n    5 1\n    6 2\n    7 3\n    8 4\n    9 5", "output": "5\n    \n\nWe should use five bombs at the coordinate 5.\n\n* * *"}, {"input": "3 0 1\n    300000000 1000000000\n    100000000 1000000000\n    200000000 1000000000", "output": "3000000000\n    \n\nWatch out for overflow."}]