import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Iterator;
import java.util.StringTokenizer;

public class Main {

  public static void main(String[] args) throws IOException {
    IOScanner scanner;
    if (new File("data.in").exists()) {
      scanner = new IOScanner("data.in", null);
    } else {
      scanner = new IOScanner();
    }
    while (scanner.hasNext()) {
      new Solver(scanner).solve();
    }
    scanner.close();
  }
}

class IOScanner {
  private final BufferedReader reader;
  private final PrintWriter writer;
  private StringTokenizer stringTokenizer;

  public IOScanner() {
    this(System.in, System.out);
  }

  public IOScanner(String input, String output) throws FileNotFoundException {
    this(input == null ? null : new File(input), output == null ? null : new File(output));
  }

  public IOScanner(File input, File output) throws FileNotFoundException {
    this(input == null ? System.in : new FileInputStream(input), output == null ? System.out
        : new FileOutputStream(output));
  }

  public IOScanner(InputStream inputStream, OutputStream outputStream) {
    reader = new BufferedReader(new InputStreamReader(inputStream));
    writer = new PrintWriter(outputStream);
  }

  private StringTokenizer read() {
    while (stringTokenizer == null || !stringTokenizer.hasMoreTokens()) {
      try {
        stringTokenizer = new StringTokenizer(reader.readLine());
      } catch (Exception e) {
        return null;
      }
    }
    return stringTokenizer;
  }

  public boolean hasNext() {
    StringTokenizer tokenizer = read();
    return tokenizer != null && tokenizer.hasMoreTokens();
  }

  public int nextInt() {
    return Integer.parseInt(next());
  }

  public long nextLong() {
    return Long.parseLong(next());
  }

  public double nextDouble() {
    return Double.parseDouble(next());
  }

  public int[] nextInts(int n) {
    int[] input = new int[n];
    for (int i = 0; i < n; i++) {
      input[i] = nextInt();
    }
    return input;
  }

  public double[] nextDoubles(int n) {
    double[] input = new double[n];
    for (int i = 0; i < n; i++) {
      input[i] = nextDouble();
    }
    return input;
  }

  public String[] nexts(int n) {
    String[] input = new String[n];
    for (int i = 0; i < n; i++) {
      input[i] = next();
    }
    return input;
  }

  public char[][] nextCharArrays(int n) {
    String[] input = nexts(n);
    char[][] result = new char[n][];
    for (int i = 0; i < n; i++) {
      result[i] = input[i].toCharArray();
    }
    return result;
  }

  public String next() {
    return read().nextToken();
  }

  public void println() {
    writer.println();
  }

  public void println(Iterable<?> iterable) {
    println(iterable.iterator());
  }

  public void println(Iterator<?> iterator) {
    boolean first = true;
    while (iterator.hasNext()) {
      if (first) {
        first = false;
      } else {
        print(' ');
      }
      print(iterator.next());
    }
    println();
  }

  public void println(Object token) {
    writer.println(token);
  }

  public void print(Object token) {
    writer.print(token);
  }

  public void printf(String format, Object... args) {
    writer.printf(format, args);
  }

  public void flush() {
    writer.flush();
  }

  public void close() throws IOException {
    reader.close();
    writer.close();
  }
}

class Solver {

  private final IOScanner scanner;

  public Solver(IOScanner scanner) {
    this.scanner = scanner;
  }

  public void solve() {
    double r = scanner.nextDouble();
    double[] a = scanner.nextDoubles(4);
    scanner.printf("%.0f\n", Math.ceil(
        Math.sqrt((a[0] - a[2]) * (a[0] - a[2]) + (a[1] - a[3]) * (a[1] - a[3])) / (2 * r)));
  }
}