import java.util.Scanner;
import java.util.ArrayList;

public class pizza_bobk {

  private class Point {
    public double x,y;
  }

  private static final int
    N_CIRCLE = 4000,
    N_SLICE = N_CIRCLE + 8;

  private int
    r,
    dx,dy,
    x,y,
    bdyTop,bdyBottom,
    bdyLeft,bdyRight,
    nSlices,
    nSlicePoints,nHullPoints;

  private double
    p;

  private double[]
    sliceArea;

  ArrayList<Point>
    circlePoints,
    slicePoints,
    hullPoints;

  public ArrayList<Point> quickHull(ArrayList<Point> points) {
    ArrayList<Point> convexHull = new ArrayList<Point>();
    int minPoint = -1, maxPoint = -1;
    double minX = Double.MAX_VALUE;
    double maxX = -minX;

    if (points.size() < 3)
      return convexHull;

    for (int i = 0; i < points.size(); i++) {
      if (points.get(i).x < minX) {
        minX = points.get(i).x;
        minPoint = i;
      }

      if (points.get(i).x > maxX) {
        maxX = points.get(i).x;
        maxPoint = i;
      }
    }

    Point A = points.get(minPoint);
    Point B = points.get(maxPoint);

    convexHull.add(A);
    convexHull.add(B);

    points.remove(A);
    points.remove(B);

    ArrayList<Point> leftSet = new ArrayList<Point>();
    ArrayList<Point> rightSet = new ArrayList<Point>();

    for (int i = 0; i < points.size(); i++) {
      Point p = points.get(i);

      if (pointLocation(A, B, p) == -1)
        leftSet.add(p);
      else if (pointLocation(A, B, p) == 1)
        rightSet.add(p);
    }

    hullSet(A, B, rightSet, convexHull);
    hullSet(B, A, leftSet, convexHull);

    return convexHull;
  }

  public double distance(Point A, Point B, Point C) {
    double ABx = B.x - A.x;
    double ABy = B.y - A.y;
    double num = ABx * (A.y - C.y) - ABy * (A.x - C.x);

    if (num < 0)
      num = -num;

    return num;
  }

  public void hullSet(Point A, Point B, ArrayList<Point> set,
            ArrayList<Point> hull) {
    int insertPosition = hull.indexOf(B);

    if (set.size() == 0)
      return;

    if (set.size() == 1) {
      Point p = set.get(0);

      set.remove(p);

      hull.add(insertPosition, p);

      return;
    }

    double dist = -1;

    int furthestPoint = -1;

    for (int i = 0; i < set.size(); i++) {
      Point p = set.get(i);

      double distance = distance(A, B, p);

      if (distance > dist) {
        dist = distance;

        furthestPoint = i;
      }
    }

    Point P = set.get(furthestPoint);

    set.remove(furthestPoint);

    hull.add(insertPosition, P);

    // Determine who's to the left of AP
    ArrayList<Point> leftSetAP = new ArrayList<Point>();

    for (int i = 0; i < set.size(); i++) {
      Point M = set.get(i);

      if (pointLocation(A, P, M) == 1)
        leftSetAP.add(M);
    }

    // Determine who's to the left of PB
    ArrayList<Point> leftSetPB = new ArrayList<Point>();

    for (int i = 0; i < set.size(); i++) {
      Point M = set.get(i);

      if (pointLocation(P, B, M) == 1)
        leftSetPB.add(M);
    }

    hullSet(A, P, leftSetAP, hull);
    hullSet(P, B, leftSetPB, hull);
  }

  public int pointLocation(Point A, Point B, Point P) {
    double cp1 = (B.x - A.x) * (P.y - A.y) - (B.y - A.y) * (P.x - A.x);

    if (cp1 > 0)
      return 1;
    else if (cp1 == 0)
      return 0;
    else
      return -1;
  }

   private void dumpData() {

    System.out.println("radius: " + r);
    System.out.println("slice size: " + dx + ' ' + dy);
    System.out.println("slice corner: " + x + ',' + y);
    System.out.println("threshold: " + p);
    System.out.println("left-right bdy: " + bdyLeft + ' ' + bdyRight);
    System.out.println("bottom-top bdy: " + bdyBottom + ' ' + bdyTop);
    System.out.println("slices: " + nSlices);
  }

  private double findArea() {
    double
      area = 0;
    Point
      x,y;

    if (hullPoints.size() < 3)
      return 0.0;

    y = hullPoints.get(0);
    for (int i=0;i<hullPoints.size();i++) {
      x = y;
      y = hullPoints.get((i+1)%hullPoints.size());
      area += x.x * y.y - x.y * y.x;
    }

    area /= 2.0;

    if (area < 0)
      area = -area;

    return area;
  }

  private void solve() {
    Scanner in = new Scanner(System.in);
    int
      sl,sr,st,sb,
      nBad = 0;
    double
      s,
      maxArea = 0;

    r = in.nextInt();
    dx = in.nextInt();
    dy = in.nextInt();
    x = in.nextInt();
    y = in.nextInt();
    p = in.nextDouble();

    bdyLeft = -((r + x + dx - 1) / dx) * dx + x;
    bdyRight = ((r - x + dx - 1) / dx) * dx + x;

    bdyBottom = -((r + y + dy - 1) / dy) * dy + y;
    bdyTop = ((r - y + dy - 1) / dy) * dy + y;

    nSlices = ((bdyRight - bdyLeft) / dx) * ((bdyTop - bdyBottom) / dy);

    sliceArea = new double[nSlices];

    nSlices = 0;

    circlePoints = new ArrayList<Point>();
    slicePoints = new ArrayList<Point>();

    for (int i=0;i<N_CIRCLE;i++) {
      Point p = new Point();
      p.x = Math.cos((2.0*Math.PI*i)/N_CIRCLE) * r;
      p.y = Math.sin((2.0*Math.PI*i)/N_CIRCLE) * r;
      circlePoints.add(p);
    }

//        dumpData();

    for (st=bdyBottom;st<bdyTop;) {
      sb = st;
      st += dy;

      for (sr=bdyLeft;sr<bdyRight;) {
        sl = sr;
        sr += dx;

//        System.out.println("slice: l=" + sl + " r=" + sr + " t=" + st + " b=" + sb);

        // add points on the circle that are in the slice rectangle
        slicePoints.clear();

        int nCorners = 0;

        // add corners that are in or on the circle
        if (sl * sl + sb * sb <= r * r) {
          Point p = new Point();
          p.x = sl;
          p.y = sb;
          slicePoints.add(p);
          nCorners++;
        }
        if (sl * sl + st * st <= r * r) {
          Point p = new Point();
          p.x = sl;
          p.y = st;
          slicePoints.add(p);
          nCorners++;
        }
        if (sr * sr + sb * sb <= r * r) {
          Point p = new Point();
          p.x = sr;
          p.y = sb;
          slicePoints.add(p);
          nCorners++;
        }
        if (sr * sr + st * st <= r * r) {
          Point p = new Point();
          p.x = sr;
          p.y = st;
          slicePoints.add(p);
          nCorners++;
        }

        if (nCorners == 0 && sl*sr >= 0 && st*sb >= 0)
          continue;

        if (nCorners == 4) {
          sliceArea[nSlices] = dx * dy;
          if (maxArea < sliceArea[nSlices])
            maxArea = sliceArea[nSlices];
          nSlices++;

          continue;
        }

        for (int i=0;i<N_CIRCLE;i++)
          if (circlePoints.get(i).x >= sl && circlePoints.get(i).x <= sr &&
              circlePoints.get(i).y >= sb && circlePoints.get(i).y <= st)
            slicePoints.add(circlePoints.get(i));

        // add line-circle intersections if they're within the slice
        if (Math.abs(sl) < r) {
          s = Math.sqrt(r * r - sl * sl);
          if (s >= sb && s <= st) {
            Point p = new Point();
            p.x = sl;
            p.y = s;
            slicePoints.add(p);
          }
          if (-s >= sb && -s <= st) {
            Point p = new Point();
            p.x = sl;
            p.y = -s;
            slicePoints.add(p);
          }
        }
        if (Math.abs(sr) < r) {
          s = Math.sqrt(r * r - sr * sr);
          if (s >= sb && s <= st) {
            Point p = new Point();
            p.x = sr;
            p.y = s;
            slicePoints.add(p);
          }
          if (-s >= sb && -s <= st) {
            Point p = new Point();
            p.x = sr;
            p.y = -s;
            slicePoints.add(p);
          }
        }
        if (Math.abs(sb) < r) {
          s = Math.sqrt(r * r - sb * sb);
          if (s >= sl && s <= sr) {
            Point p = new Point();
            p.x = s;
            p.y = sb;
            slicePoints.add(p);
          }
          if (-s >= sl && -s <= sr) {
            Point p = new Point();
            p.x = -s;
            p.y = sb;
            slicePoints.add(p);
          }
        }
        if (Math.abs(st) < r) {
          s = Math.sqrt(r * r - st * st);
          if (s >= sl && s <= sr) {
            Point p = new Point();
            p.x = s;
            p.y = st;
            slicePoints.add(p);
          }
          if (-s >= sl && -s <= sr) {
            Point p = new Point();
            p.x = -s;
            p.y = st;
            slicePoints.add(p);
          }
        }

        hullPoints = quickHull(slicePoints);

//        System.out.println("  slice points: " + slicePoints.size());
//        System.out.println("  hull points: " + hullPoints.size());

        sliceArea[nSlices] = findArea();

        if (maxArea < sliceArea[nSlices])
          maxArea = sliceArea[nSlices];

//        System.out.println("  area: " + sliceArea[nSlices]);

        nSlices++;
      }
    }

    for (int i=0;i<nSlices;i++)
      if (sliceArea[i] > 0.0 && sliceArea[i] < p * maxArea)
        nBad++;

    System.out.println(nBad);
  }

  public static void main(String[] args) {
    pizza_bobk solver = new pizza_bobk();

    solver.solve();
  }
}