import java.io.*;
import java.util.*;

public class Main {
    static PrintWriter pw;
    static Scanner sc;
    static long ceildiv(long x, long y) { return y==0?inf:(x+y-1)/y; }
    static int mod(long x, int m) { return (int)((x%m+m)%m); }
    static void put(TreeMap<Integer, Integer> map, Integer p){if(map.containsKey(p)) map.replace(p, map.get(p)+1); else map.put(p, 1); }
    static void rem(TreeMap<Integer, Integer> map, Integer p){ if(map.get(p)==1) map.remove(p);else map.replace(p, map.get(p)-1); }
    static void printf(double x, int dig){ String s="%."+dig+"f"; pw.printf(s, x); }
    static long gcd(long x, long y) {return y==0?x:gcd(y, x%y);}
    static int Int(boolean x){ return x?1:0; }
    static final int inf=(int)1e9, mod=inf+7;
    static boolean[] visit;
    static long ans;
    static final double r2=Math.sqrt(2), eps=1e-12;
    public static void main(String[] args) throws IOException {
        sc=new Scanner(System.in);
        pw=new PrintWriter(System.out);
        int R=sc.nextInt();
        point cent=new point(sc.nextInt(), sc.nextInt());
        point p=new point(sc.nextInt(), sc.nextInt());
        double dist=cent.dist(p);
        if(Math.abs(dist-R)<eps || dist>R){
            pw.println(cent+" "+R);
            pw.close();
            return;
        }
        if(!p.equal(cent)){
            double d=dist+R;
            segment seg=new segment(p, cent);
            seg.multiply(d/dist);
            pw.println(seg.midpoint()+" "+d/2);
        }else{
            pw.println(cent.x+(R/2)/r2+cent.y+(R/2)/r2);
        }
        pw.close();
    }
    static class point{
        double x, y;
        public point(double a, double b){
            x=a;
            y=b;
        }
        public String toString(){
            return x+" "+y;
        }
        public double dist(point p){
            return Math.sqrt(sq(p.x-this.x)+sq(p.y-this.y));
        }
        double sq(double x){ return x*x; }
        public boolean equal(point p){
            return Math.abs(p.x-x)<eps && Math.abs(p.y-y)<eps;
        }
    }
    static class segment{
        point st, end;
        public segment(point a, point b){
            st=a;
            end=b;
        }
        public void multiply(double x){
            double dx=end.x-st.x, dy=end.y-st.y;
            dx*=x; dy*=x;
            end=new point(st.x+dx, st.y+dy);
        }
        public point midpoint(){
            return new point((st.x+end.x)/2, (st.y+end.y)/2);
        }
    }
    static int cost(Integer x, int i, int n){
        if(x==null)
            return inf;
        int d=Math.abs(x-i);
        d=Math.min(d, n-d);
        return d;
    }
    static void printArr(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++)
            pw.print(arr[i] + " ");
        pw.println(arr[arr.length - 1]);
    }
    static void printArr(long[] arr) {
        for (int i = 0; i < arr.length - 1; i++)
            pw.print(arr[i] + " ");
        pw.println(arr[arr.length - 1]);
    }
    static void printArr(Integer[] arr) {
        for (int i = 0; i < arr.length; i++)
            pw.print(arr[i] + " ");
        pw.println();
    }
    static void printArr(char[] arr) {
        for (int i = 0; i < arr.length; i++)
            pw.print(arr[i]==0? '1': arr[i]);
        pw.println();
    }
    static void printArr(ArrayList<Integer> list) {
        for (int i = 0; i < list.size(); i++)
            pw.print(list.get(i)+" ");
        pw.println();
    }
    static class Scanner {
        StringTokenizer st;
        BufferedReader br;
        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        public Scanner(FileReader r) {
            br = new BufferedReader(r);
        }

        public String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

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

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

        public String nextLine() throws IOException {
            return br.readLine();
        }

        public double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }
        public int[] nextDigits() throws IOException{
            String s=nextLine();
            int[] arr=new int[s.length()];
            for(int i=0; i<arr.length; i++)
                arr[i]=s.charAt(i)-'0';
            return arr;
        }
        public int[] nextArr(int n) throws IOException {
            int[] arr = new int[n];
            for (int i = 0; i < arr.length; i++)
                arr[i] = nextInt();
            return arr;
        }
        public Integer[] nextsort(int n) throws IOException{
            Integer[] arr=new Integer[n];
            for(int i=0; i<n; i++)
                arr[i]=nextInt();
            return arr;
        }
        public Pair nextPair() throws IOException{
            return new Pair(nextInt(), nextInt());
        }
        public Pair[] nextPairArr(int n) throws IOException{
            Pair[] arr=new Pair[n];
            for(int i=0; i<n; i++)
                arr[i]=nextPair();
            return arr;
        }
        public boolean ready() throws IOException {
            return br.ready();
        }
    }
    static class Pair implements Comparable<Pair>{
        int x;
        int y;
        public Pair(int x, int y) {
            this.x=x;
            this.y=y;
        }
        public int hashCode() {
            return (this.x*1000+this.y);
        }
        public int compareTo(Pair p){
            return x-p.x;
        }
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }
            if (this.getClass() != obj.getClass()) {
                return false;
            }
            Pair p = (Pair) obj;
            return this.x==p.x && this.y==p.y;
        }
        public Pair clone(){
            return new Pair(x, y);
        }
        public String toString(){
            return this.x+" "+this.y;
        }
        public void add(Pair p){
            x+=p.x;
            y+=p.y;
        }
    }
    static class Union{
        int[] rep, size;
        int sets;
        public Union(int n){
            rep=new int[n];
            size=new int[n];
            sets=n;
            for(int i=0; i<n; i++){
                rep[i]=i;
                size[i]=1;
            }
        }
        public void join(int x, int y){
            int a=getSet(x), b=getSet(y);
            if(a==b){
                return;
            }
            sets--;
            if(size[a]>size[b]){
                rep[b]=a;
                size[a]+=size[b];
            }else{
                rep[a]=b;
                size[b]+=size[a];
            }
        }
        public int getSet(int x){
            if(rep[x]==x)
                return x;
            return rep[x]=getSet(rep[x]);
        }
    }
}


import java.io.*;
import java.util.*;

public class Main {
    static PrintWriter pw;
    static Scanner sc;
    static long ceildiv(long x, long y) { return y==0?inf:(x+y-1)/y; }
    static int mod(long x, int m) { return (int)((x%m+m)%m); }
    static void put(TreeMap<Integer, Integer> map, Integer p){if(map.containsKey(p)) map.replace(p, map.get(p)+1); else map.put(p, 1); }
    static void rem(TreeMap<Integer, Integer> map, Integer p){ if(map.get(p)==1) map.remove(p);else map.replace(p, map.get(p)-1); }
    static void printf(double x, int dig){ String s="%."+dig+"f"; pw.printf(s, x); }
    static long gcd(long x, long y) {return y==0?x:gcd(y, x%y);}
    static int Int(boolean x){ return x?1:0; }
    static final int inf=(int)1e9, mod=inf+7;
    static boolean[] visit;
    static long ans;
    static final double r2=Math.sqrt(2), eps=1e-12;
    public static void main(String[] args) throws IOException {
        sc=new Scanner(System.in);
        pw=new PrintWriter(System.out);
        int R=sc.nextInt();
        point cent=new point(sc.nextInt(), sc.nextInt());
        point p=new point(sc.nextInt(), sc.nextInt());
        double dist=cent.dist(p);
        if(Math.abs(dist-R)<eps || dist>R){
            pw.println(cent+" "+R);
            pw.close();
            return;
        }
        if(!p.equal(cent)){
            double d=dist+R;
            segment seg=new segment(p, cent);
            seg.multiply(d/dist);
            pw.println(seg.midpoint()+" "+d/2);
        }else{
            pw.println(cent.x+(R/2)/r2+" "+cent.y+(R/2)/r2+" "+R/2);
        }
        pw.close();
    }
    static class point{
        double x, y;
        public point(double a, double b){
            x=a;
            y=b;
        }
        public String toString(){
            return x+" "+y;
        }
        public double dist(point p){
            return Math.sqrt(sq(p.x-this.x)+sq(p.y-this.y));
        }
        double sq(double x){ return x*x; }
        public boolean equal(point p){
            return Math.abs(p.x-x)<eps && Math.abs(p.y-y)<eps;
        }
    }
    static class segment{
        point st, end;
        public segment(point a, point b){
            st=a;
            end=b;
        }
        public void multiply(double x){
            double dx=end.x-st.x, dy=end.y-st.y;
            dx*=x; dy*=x;
            end=new point(st.x+dx, st.y+dy);
        }
        public point midpoint(){
            return new point((st.x+end.x)/2, (st.y+end.y)/2);
        }
    }
    static int cost(Integer x, int i, int n){
        if(x==null)
            return inf;
        int d=Math.abs(x-i);
        d=Math.min(d, n-d);
        return d;
    }
    static void printArr(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++)
            pw.print(arr[i] + " ");
        pw.println(arr[arr.length - 1]);
    }
    static void printArr(long[] arr) {
        for (int i = 0; i < arr.length - 1; i++)
            pw.print(arr[i] + " ");
        pw.println(arr[arr.length - 1]);
    }
    static void printArr(Integer[] arr) {
        for (int i = 0; i < arr.length; i++)
            pw.print(arr[i] + " ");
        pw.println();
    }
    static void printArr(char[] arr) {
        for (int i = 0; i < arr.length; i++)
            pw.print(arr[i]==0? '1': arr[i]);
        pw.println();
    }
    static void printArr(ArrayList<Integer> list) {
        for (int i = 0; i < list.size(); i++)
            pw.print(list.get(i)+" ");
        pw.println();
    }
    static class Scanner {
        StringTokenizer st;
        BufferedReader br;
        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        public Scanner(FileReader r) {
            br = new BufferedReader(r);
        }

        public String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

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

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

        public String nextLine() throws IOException {
            return br.readLine();
        }

        public double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }
        public int[] nextDigits() throws IOException{
            String s=nextLine();
            int[] arr=new int[s.length()];
            for(int i=0; i<arr.length; i++)
                arr[i]=s.charAt(i)-'0';
            return arr;
        }
        public int[] nextArr(int n) throws IOException {
            int[] arr = new int[n];
            for (int i = 0; i < arr.length; i++)
                arr[i] = nextInt();
            return arr;
        }
        public Integer[] nextsort(int n) throws IOException{
            Integer[] arr=new Integer[n];
            for(int i=0; i<n; i++)
                arr[i]=nextInt();
            return arr;
        }
        public Pair nextPair() throws IOException{
            return new Pair(nextInt(), nextInt());
        }
        public Pair[] nextPairArr(int n) throws IOException{
            Pair[] arr=new Pair[n];
            for(int i=0; i<n; i++)
                arr[i]=nextPair();
            return arr;
        }
        public boolean ready() throws IOException {
            return br.ready();
        }
    }
    static class Pair implements Comparable<Pair>{
        int x;
        int y;
        public Pair(int x, int y) {
            this.x=x;
            this.y=y;
        }
        public int hashCode() {
            return (this.x*1000+this.y);
        }
        public int compareTo(Pair p){
            return x-p.x;
        }
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }
            if (this.getClass() != obj.getClass()) {
                return false;
            }
            Pair p = (Pair) obj;
            return this.x==p.x && this.y==p.y;
        }
        public Pair clone(){
            return new Pair(x, y);
        }
        public String toString(){
            return this.x+" "+this.y;
        }
        public void add(Pair p){
            x+=p.x;
            y+=p.y;
        }
    }
    static class Union{
        int[] rep, size;
        int sets;
        public Union(int n){
            rep=new int[n];
            size=new int[n];
            sets=n;
            for(int i=0; i<n; i++){
                rep[i]=i;
                size[i]=1;
            }
        }
        public void join(int x, int y){
            int a=getSet(x), b=getSet(y);
            if(a==b){
                return;
            }
            sets--;
            if(size[a]>size[b]){
                rep[b]=a;
                size[a]+=size[b];
            }else{
                rep[a]=b;
                size[b]+=size[a];
            }
        }
        public int getSet(int x){
            if(rep[x]==x)
                return x;
            return rep[x]=getSet(rep[x]);
        }
    }
}


import java.io.*;
import java.util.*;

public class Main {
    static PrintWriter pw;
    static Scanner sc;
    static long ceildiv(long x, long y) { return y==0?inf:(x+y-1)/y; }
    static int mod(long x, int m) { return (int)((x%m+m)%m); }
    static void put(TreeMap<Integer, Integer> map, Integer p){if(map.containsKey(p)) map.replace(p, map.get(p)+1); else map.put(p, 1); }
    static void rem(TreeMap<Integer, Integer> map, Integer p){ if(map.get(p)==1) map.remove(p);else map.replace(p, map.get(p)-1); }
    static void printf(double x, int dig){ String s="%."+dig+"f"; pw.printf(s, x); }
    static long gcd(long x, long y) {return y==0?x:gcd(y, x%y);}
    static int Int(boolean x){ return x?1:0; }
    static final int inf=(int)1e9, mod=inf+7;
    static boolean[] visit;
    static long ans;
    static final double r2=Math.sqrt(2), eps=1e-12;
    public static void main(String[] args) throws IOException {
        sc=new Scanner(System.in);
        pw=new PrintWriter(System.out);
        int R=sc.nextInt();
        point cent=new point(sc.nextInt(), sc.nextInt());
        point p=new point(sc.nextInt(), sc.nextInt());
        double dist=cent.dist(p);
        if(Math.abs(dist-R)<eps || dist>R){
            pw.println(cent+" "+R);
            pw.close();
            return;
        }
        if(!p.equal(cent)){
            double d=dist+R;
            segment seg=new segment(p, cent);
            seg.multiply(d/dist);
            pw.println(seg.midpoint()+" "+d/2);
        }else{
            double x=cent.x+(R/2d)/r2, y=cent.y+(R/2d)/r2;
            pw.println(x+" "+y+" "+R/2d);
        }
        pw.close();
    }
    static class point{
        double x, y;
        public point(double a, double b){
            x=a;
            y=b;
        }
        public String toString(){
            return x+" "+y;
        }
        public double dist(point p){
            return Math.sqrt(sq(p.x-this.x)+sq(p.y-this.y));
        }
        double sq(double x){ return x*x; }
        public boolean equal(point p){
            return Math.abs(p.x-x)<eps && Math.abs(p.y-y)<eps;
        }
    }
    static class segment{
        point st, end;
        public segment(point a, point b){
            st=a;
            end=b;
        }
        public void multiply(double x){
            double dx=end.x-st.x, dy=end.y-st.y;
            dx*=x; dy*=x;
            end=new point(st.x+dx, st.y+dy);
        }
        public point midpoint(){
            return new point((st.x+end.x)/2, (st.y+end.y)/2);
        }
    }
    static int cost(Integer x, int i, int n){
        if(x==null)
            return inf;
        int d=Math.abs(x-i);
        d=Math.min(d, n-d);
        return d;
    }
    static void printArr(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++)
            pw.print(arr[i] + " ");
        pw.println(arr[arr.length - 1]);
    }
    static void printArr(long[] arr) {
        for (int i = 0; i < arr.length - 1; i++)
            pw.print(arr[i] + " ");
        pw.println(arr[arr.length - 1]);
    }
    static void printArr(Integer[] arr) {
        for (int i = 0; i < arr.length; i++)
            pw.print(arr[i] + " ");
        pw.println();
    }
    static void printArr(char[] arr) {
        for (int i = 0; i < arr.length; i++)
            pw.print(arr[i]==0? '1': arr[i]);
        pw.println();
    }
    static void printArr(ArrayList<Integer> list) {
        for (int i = 0; i < list.size(); i++)
            pw.print(list.get(i)+" ");
        pw.println();
    }
    static class Scanner {
        StringTokenizer st;
        BufferedReader br;
        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        public Scanner(FileReader r) {
            br = new BufferedReader(r);
        }

        public String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

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

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

        public String nextLine() throws IOException {
            return br.readLine();
        }

        public double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }
        public int[] nextDigits() throws IOException{
            String s=nextLine();
            int[] arr=new int[s.length()];
            for(int i=0; i<arr.length; i++)
                arr[i]=s.charAt(i)-'0';
            return arr;
        }
        public int[] nextArr(int n) throws IOException {
            int[] arr = new int[n];
            for (int i = 0; i < arr.length; i++)
                arr[i] = nextInt();
            return arr;
        }
        public Integer[] nextsort(int n) throws IOException{
            Integer[] arr=new Integer[n];
            for(int i=0; i<n; i++)
                arr[i]=nextInt();
            return arr;
        }
        public Pair nextPair() throws IOException{
            return new Pair(nextInt(), nextInt());
        }
        public Pair[] nextPairArr(int n) throws IOException{
            Pair[] arr=new Pair[n];
            for(int i=0; i<n; i++)
                arr[i]=nextPair();
            return arr;
        }
        public boolean ready() throws IOException {
            return br.ready();
        }
    }
    static class Pair implements Comparable<Pair>{
        int x;
        int y;
        public Pair(int x, int y) {
            this.x=x;
            this.y=y;
        }
        public int hashCode() {
            return (this.x*1000+this.y);
        }
        public int compareTo(Pair p){
            return x-p.x;
        }
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }
            if (this.getClass() != obj.getClass()) {
                return false;
            }
            Pair p = (Pair) obj;
            return this.x==p.x && this.y==p.y;
        }
        public Pair clone(){
            return new Pair(x, y);
        }
        public String toString(){
            return this.x+" "+this.y;
        }
        public void add(Pair p){
            x+=p.x;
            y+=p.y;
        }
    }
    static class Union{
        int[] rep, size;
        int sets;
        public Union(int n){
            rep=new int[n];
            size=new int[n];
            sets=n;
            for(int i=0; i<n; i++){
                rep[i]=i;
                size[i]=1;
            }
        }
        public void join(int x, int y){
            int a=getSet(x), b=getSet(y);
            if(a==b){
                return;
            }
            sets--;
            if(size[a]>size[b]){
                rep[b]=a;
                size[a]+=size[b];
            }else{
                rep[a]=b;
                size[b]+=size[a];
            }
        }
        public int getSet(int x){
            if(rep[x]==x)
                return x;
            return rep[x]=getSet(rep[x]);
        }
    }
}


import java.util.*;
import java.io.*;

public class A {

	public static void main(String[] args) {
		// TODO Auto-generated method stub.
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		double R = sc.nextDouble();
		double c1 = sc.nextDouble();
		double c2 = sc.nextDouble();
		double x = sc.nextDouble() - c1;
		double y = sc.nextDouble() - c2;
		double dist = (R + Math.sqrt(x*x+y*y))/2.0;
		//System.out.prdoubleln(dist);
		double uvx = x/Math.sqrt(x*x+y*y);
		double uvy = y/Math.sqrt(x*x+y*y);
		double ansx = c1+(x-(uvx)*dist);
		double ansy = c2+(y-(uvy)*dist);
		if((x*x+y*y)>=(R*R))
			System.out.println((double)c1+" "+(double)c2+" "+(double)R);
		else if(x==0 && y==0)
		{
			System.out.println((dist+c1)+" "+c2+" "+dist);
		}
		else
			System.out.println(ansx+" "+ansy+" "+dist);
		sc.close();
		out.close();
	}

}


import java.util.*;
import java.io.*;

public class A {

	public static void main(String[] args) {
		// TODO Auto-generated method stub.
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		int R = sc.nextInt();
		int c1 = sc.nextInt();
		int c2 = sc.nextInt();
		int x = sc.nextInt() - c1;
		int y = sc.nextInt() - c2;
		double dist = (R + Math.sqrt(x*x+y*y))/2.0;
		//System.out.println(dist);
		double uvx = x/Math.sqrt(x*x+y*y);
		double uvy = y/Math.sqrt(x*x+y*y);
		double ansx = c1+(x-(uvx)*dist);
		double ansy = c2+(y-(uvy)*dist);
		if((x*x+y*y)>=R)
			System.out.println(c1+" "+c2+" "+R);
		else if(x==0 && y==0)
		{
			System.out.println(dist+c1+" "+(dist+c2)+" "+dist);
		}
		else
			System.out.println(ansx+" "+ansy+" "+dist);
		sc.close();
		out.close();
	}

}


import java.util.*;
import java.io.*;

public class A {

	public static void main(String[] args) {
		// TODO Auto-generated method stub.
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		double R = sc.nextDouble();
		double c1 = sc.nextDouble();
		double c2 = sc.nextDouble();
		double x = sc.nextDouble() - c1;
		double y = sc.nextDouble() - c2;
		double dist = (R + Math.sqrt(x*x+y*y))/2.0;
		//System.out.prdoubleln(dist);
		double uvx = x/Math.sqrt(x*x+y*y);
		double uvy = y/Math.sqrt(x*x+y*y);
		double ansx = c1+(x-(uvx)*dist);
		double ansy = c2+(y-(uvy)*dist);
		if((x*x+y*y)>=(R*R))
			System.out.println((double)c1+" "+(double)c2+" "+(double)R);
		else if(x==0 && y==0)
		{
			System.out.println(dist+c1+" "+(dist+c2)+" "+dist);
		}
		else
			System.out.println(ansx+" "+ansy+" "+dist);
		sc.close();
		out.close();
	}

}


import java.util.*;
import java.io.*;

public class A {

	public static void main(String[] args) {
		// TODO Auto-generated method stub.
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		int R = sc.nextInt();
		int c1 = sc.nextInt();
		int c2 = sc.nextInt();
		int x = sc.nextInt() - c1;
		int y = sc.nextInt() - c2;
		double dist = (R + Math.sqrt(x*x+y*y))/2.0;
		//System.out.println(dist);
		double uvx = x/Math.sqrt(x*x+y*y);
		double uvy = y/Math.sqrt(x*x+y*y);
		double ansx = c1+(x-(uvx)*dist);
		double ansy = c2+(y-(uvy)*dist);
		if(x==0 && y==0)
		{
			System.out.println(dist+c1+" "+(dist+c2)+" "+dist);
		}
		else
			System.out.println(ansx+" "+ansy+" "+dist);
		sc.close();
		out.close();
	}

}


import java.util.*;
import java.io.*;

public class A {

	public static void main(String[] args) {
		// TODO Auto-generated method stub.
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		double R = sc.nextDouble();
		double c1 = sc.nextDouble();
		double c2 = sc.nextDouble();
		double x = sc.nextDouble() - c1;
		double y = sc.nextDouble() - c2;
		double dist = (R + Math.sqrt(x*x+y*y))/2.0;
		//System.out.prdoubleln(dist);
		double uvx = x/Math.sqrt(x*x+y*y);
		double uvy = y/Math.sqrt(x*x+y*y);
		double ansx = c1+(x-(uvx)*dist);
		double ansy = c2+(y-(uvy)*dist);
		if((x*x+y*y)>=(R*R))
			System.out.println((double)c1+" "+(double)c2+" "+(double)R);
		else if(x==0 && y==0)
		{
			System.out.println(dist+c1+" 0.0 "+" "+dist);
		}
		else
			System.out.println(ansx+" "+ansy+" "+dist);
		sc.close();
		out.close();
	}

}


import java.util.*;
import java.io.*;

public class A {

	public static void main(String[] args) {
		// TODO Auto-generated method stub.
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		int R = sc.nextInt();
		int c1 = sc.nextInt();
		int c2 = sc.nextInt();
		int x = sc.nextInt() - c1;
		int y = sc.nextInt() - c2;
		double dist = (R + Math.sqrt(x*x+y*y))/2.0;
		//System.out.println(dist);
		double uvx = x/Math.sqrt(x*x+y*y);
		double uvy = y/Math.sqrt(x*x+y*y);
		double ansx = c1+(x-(uvx)*dist);
		double ansy = c2+(y-(uvy)*dist);
		if((x*x+y*y)>=(R*R))
			System.out.println((double)c1+" "+(double)c2+" "+(double)R);
		else if(x==0 && y==0)
		{
			System.out.println(dist+c1+" "+(dist+c2)+" "+dist);
		}
		else
			System.out.println(ansx+" "+ansy+" "+dist);
		sc.close();
		out.close();
	}

}


import java.util.*;
import java.io.*;

public class A {

	public static void main(String[] args) {
		// TODO Auto-generated method stub.
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		int R = sc.nextInt();
		int c1 = sc.nextInt();
		int c2 = sc.nextInt();
		int x = sc.nextInt() - c1;
		int y = sc.nextInt() - c2;
		double dist = (R + Math.sqrt(x*x+y*y))/2.0;
		//System.out.println(dist);
		double uvx = x/Math.sqrt(x*x+y*y);
		double uvy = y/Math.sqrt(x*x+y*y);
		double ansx = c1+(x-(uvx)*dist);
		double ansy = c2+(y-(uvy)*dist);
		System.out.println(ansx+" "+ansy+" "+dist);
		sc.close();
		out.close();
	}

}


import java.util.Scanner;

public class fifa {

	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		double r=sc.nextInt();
		double x1=sc.nextInt();
		double y1=sc.nextInt();
		double x2=sc.nextInt();
		double y2=sc.nextInt();

		double q=Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2)));

		double ro=(q+r)/2;
		double move=Math.abs(r-q)/2;
		double slope=Math.abs(Math.atan(Math.abs((x1-x2)/(y1-y2))));
		double xo=0;
		double yo=0;

		if(x2>=x1&& y2>=y1){

		xo=x1-(move*Math.cos(slope));
		yo=y1-(move*Math.sin(slope));
		}else if(x2<=x1&& y2<=y1){

			xo=x1+(move*Math.cos(slope));
			yo=y1+(move*Math.sin(slope));
			}else if(x2<=x1&& y2>=y1){

				xo=x1+(move*Math.cos(slope));
				yo=y1-(move*Math.sin(slope));
				}
			else if(x2>=x1&& y2<=y1){

				xo=x1-(move*Math.cos(slope));
				yo=y1+(move*Math.sin(slope));
				}

		System.out.println(xo+" "+yo+" "+ro);
	}
}


import java.util.Scanner;

public class fifa {

	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		double r=sc.nextInt();
		double x1=sc.nextInt();
		double y1=sc.nextInt();
		double x2=sc.nextInt();
		double y2=sc.nextInt();

		double q=Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2)));

		double ro=(q+r)/2;
		double move=Math.abs(r-q)/2;
		double slope=Math.atan((x1-x2)/(y1-y2));
		double xo=x1+(move*Math.cos(slope));
		double yo=y1+(move*Math.sin(slope));

		System.out.println(xo+" "+yo+" "+ro);
	}
}


package mm;

import java.util.Scanner;

public class fifa {

	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		double r=sc.nextInt();
		double x1=sc.nextInt();
		double y1=sc.nextInt();
		double x2=sc.nextInt();
		double y2=sc.nextInt();

		double q=Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2)));

		double ro=(q+r)/2;
		double move=Math.abs(r-q)/2;
		double slope=Math.abs(Math.atan((x1-x2)/(y1-y2)));
		double xo=0;
		double yo=0;

		if(x2>=x1&& y2>=y1){

		xo=x1-(move*Math.cos(slope));
		yo=y1-(move*Math.sin(slope));
		}else if(x2<=x1&& y2<=y1){

			xo=x1+(move*Math.cos(slope));
			yo=y1+(move*Math.sin(slope));
			}else if(x2<=x1&& y2>=y1){

				xo=x1+(move*Math.cos(slope));
				yo=y1-(move*Math.sin(slope));
				}
			else if(x2>=x1&& y2<=y1){

				xo=x1-(move*Math.cos(slope));
				yo=y1+(move*Math.sin(slope));
				}

		System.out.println(xo+" "+yo+" "+ro);
	}
}


import java.util.Scanner;

public class fifa {

	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		double r=sc.nextInt();
		double x1=sc.nextInt();
		double y1=sc.nextInt();
		double x2=sc.nextInt();
		double y2=sc.nextInt();

		double q=Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2)));

		double ro=(q+r)/2;
		double move=Math.abs(r-q)/2;
		double slope=Math.abs(Math.atan(Math.abs((x1-x2)/(y1-y2))));
		double xo=0;
		double yo=0;

		if(x2>=x1&& y2>=y1){

		xo=x1-(move*Math.sin(slope));
		yo=y1-(move*Math.cos(slope));
		}else if(x2<=x1&& y2<=y1){

			xo=x1+(move*Math.sin(slope));
			yo=y1+(move*Math.cos(slope));
			}else if(x2<=x1&& y2>=y1){

				xo=x1+(move*Math.sin(slope));
				yo=y1-(move*Math.cos(slope));
				}
			else if(x2>=x1&& y2<=y1){

				xo=x1-(move*Math.sin(slope));
				yo=y1+(move*Math.cos(slope));
				}

		System.out.println(xo+" "+yo+" "+ro);
	}
}


import java.util.Scanner;

public class fifa {

	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		double r=sc.nextInt();
		double x1=sc.nextInt();
		double y1=sc.nextInt();
		double x2=sc.nextInt();
		double y2=sc.nextInt();

		double q=Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2)));

		double ro=(q+r)/2;
		double move=Math.abs(r-q)/2;
		double slope=Math.abs(Math.atan(Math.abs((y2-y1)/(x2-x1))));
		double xo=0;
		double yo=0;

		if(x2>=x1&& y2>=y1){

		xo=x1-(move*Math.cos(slope));
		yo=y1-(move*Math.sin(slope));
		}else if(x2<=x1&& y2<=y1){

			xo=x1+(move*Math.cos(slope));
			yo=y1+(move*Math.sin(slope));
			}else if(x2<=x1&& y2>=y1){

				xo=x1+(move*Math.cos(slope));
				yo=y1-(move*Math.sin(slope));
				}
			else if(x2>=x1&& y2<=y1){

				xo=x1-(move*Math.cos(slope));
				yo=y1+(move*Math.sin(slope));
				}

		System.out.println(xo+" "+yo+" "+ro);
		//System.out.println(slope);
	}
}


import java.util.Scanner;

public class fifa {

	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		double r=sc.nextInt();
		double x1=sc.nextInt();
		double y1=sc.nextInt();
		double x2=sc.nextInt();
		double y2=sc.nextInt();

		double q=Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2)));

		double ro=(q+r)/2;
		double move=Math.abs(r-q)/2;
		double slope=Math.abs(Math.atan(Math.abs((x1-x2)/(y1-y2))));
		double xo=0;
		double yo=0;
		if(ro>r){
			xo=x1;
			yo=y1;
			ro=r;
		}

		else if(x2>=x1&& y2>=y1){

		xo=x1-(move*Math.sin(slope));
		yo=y1-(move*Math.cos(slope));
		}else if(x2<=x1&& y2<=y1){

			xo=x1+(move*Math.sin(slope));
			yo=y1+(move*Math.cos(slope));
			}else if(x2<=x1&& y2>=y1){

				xo=x1+(move*Math.sin(slope));
				yo=y1-(move*Math.cos(slope));
				}
			else if(x2>=x1&& y2<=y1){

				xo=x1-(move*Math.sin(slope));
				yo=y1+(move*Math.cos(slope));
				}

		System.out.println(xo+" "+yo+" "+ro);
	}
}


import java.util.Scanner;

public class fifa {

	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		double r=sc.nextInt();
		double x1=sc.nextInt();
		double y1=sc.nextInt();
		double x2=sc.nextInt();
		double y2=sc.nextInt();

		double q=Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2)));

		double ro=(q+r)/2;
		double move=Math.abs(r-q)/2;
		double slope=Math.abs(Math.atan((x1-x2)/(y1-y2)));
		double xo=0;
		double yo=0;

		if(x2>=x1&& y2>=y1){

		xo=x1-(move*Math.cos(slope));
		yo=y1-(move*Math.sin(slope));
		}else if(x2<=x1&& y2<=y1){

			xo=x1+(move*Math.cos(slope));
			yo=y1+(move*Math.sin(slope));
			}else if(x2<=x1&& y2>=y1){

				xo=x1+(move*Math.cos(slope));
				yo=y1-(move*Math.sin(slope));
				}
			else if(x2>=x1&& y2<=y1){

				xo=x1-(move*Math.cos(slope));
				yo=y1+(move*Math.sin(slope));
				}

		System.out.println(xo+" "+yo+" "+ro);
	}
}


import java.util.Scanner;

public class fifa {

	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		double r=sc.nextInt();
		double x1=sc.nextInt();
		double y1=sc.nextInt();
		double x2=sc.nextInt();
		double y2=sc.nextInt();

		double q=(r+Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2))))/2;

		//double ro=(q+r)/2;
		double move=Math.abs(r-q)/2;
		double slope=Math.atan(Math.abs((x1-x2)/(y1-y2)));
		double xo=0;
		double yo=0;

		if(x2>=x1&& y2>=y1){

		xo=x1-(move*Math.cos(slope));
		yo=y1-(move*Math.sin(slope));
		}else if(x2<=x1&& y2<=y1){

			xo=x1+(move*Math.cos(slope));
			yo=y1+(move*Math.sin(slope));
			}else if(x2<=x1&& y2>=y1){

				xo=x1+(move*Math.cos(slope));
				yo=y1-(move*Math.sin(slope));
				}
			else if(x2>=x1&& y2<=y1){

				xo=x1-(move*Math.cos(slope));
				yo=y1+(move*Math.sin(slope));
				}

		System.out.println(xo+" "+yo+" "+q);
	}
}


import java.util.Scanner;

public class fifa {

	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		double r=sc.nextInt();
		double x1=sc.nextInt();
		double y1=sc.nextInt();
		double x2=sc.nextInt();
		double y2=sc.nextInt();

		double q=Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2)));

		double ro=(q+r)/2;
		double move=Math.abs(r-q)/2;
		double slope=Math.abs(Math.atan(Math.abs((y2-y1)/(x2-x1))));
		double xo=0;
		double yo=0;

		if(x2>=x1&& y2>=y1){

		xo=x1-(move*Math.cos(slope));
		yo=y1-(move*Math.sin(slope));
		}else if(x2<=x1&& y2<=y1){

			xo=x1+(move*Math.cos(slope));
			yo=y1+(move*Math.sin(slope));
			}else if(x2<=x1&& y2>=y1){

				xo=x1+(move*Math.cos(slope));
				yo=y1-(move*Math.sin(slope));
				}
			else if(x2>=x1&& y2<=y1){

				xo=x1-(move*Math.cos(slope));
				yo=y1+(move*Math.sin(slope));
				}

		System.out.println(xo+" "+yo+" "+ro);
		System.out.println(slope);
	}
}


import java.util.Scanner;

public class fifa {

	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		double r=sc.nextInt();
		double x1=sc.nextInt();
		double y1=sc.nextInt();
		double x2=sc.nextInt();
		double y2=sc.nextInt();

		double q=Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2)));

		double ro=(q+r)/2;
		double move=Math.abs(r-q)/2;
		double slope=Math.abs(Math.atan(Math.abs((x1-x2)/(y1-y2))));
		if(x1==x2&&y1==y2){
			slope =0;
		}
		double xo=0;
		double yo=0;
		//System.out.println(slope);
		if(ro>r){
			xo=x1;
			yo=y1;
			ro=r;
		}

		else if(x2>=x1&& y2>=y1){

		xo=x1-(move*Math.sin(slope));
		yo=y1-(move*Math.cos(slope));
		}else if(x2<=x1&& y2<=y1){

			xo=x1+(move*Math.sin(slope));
			yo=y1+(move*Math.cos(slope));
			}else if(x2<=x1&& y2>=y1){

				xo=x1+(move*Math.sin(slope));
				yo=y1-(move*Math.cos(slope));
				}
			else if(x2>=x1&& y2<=y1){

				xo=x1-(move*Math.sin(slope));
				yo=y1+(move*Math.cos(slope));
				}

		System.out.println(xo+" "+yo+" "+ro);
	}
}


import java.util.Scanner;

public class fifa {

	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		double r=sc.nextInt();
		double x1=sc.nextInt();
		double y1=sc.nextInt();
		double x2=sc.nextInt();
		double y2=sc.nextInt();

		double q=Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2)));

		double ro=(q+r)/2;
		double move=Math.abs(r-q)/2;
		double slope=Math.abs(Math.atan(Math.abs((x1-x2)/(y1-y2))));
		if(x1==x2&&y1==y2){
			slope =0;
		}
		double xo=0;
		double yo=0;
		System.out.println(slope);
		if(ro>r){
			xo=x1;
			yo=y1;
			ro=r;
		}

		else if(x2>=x1&& y2>=y1){

		xo=x1-(move*Math.sin(slope));
		yo=y1-(move*Math.cos(slope));
		}else if(x2<=x1&& y2<=y1){

			xo=x1+(move*Math.sin(slope));
			yo=y1+(move*Math.cos(slope));
			}else if(x2<=x1&& y2>=y1){

				xo=x1+(move*Math.sin(slope));
				yo=y1-(move*Math.cos(slope));
				}
			else if(x2>=x1&& y2<=y1){

				xo=x1-(move*Math.sin(slope));
				yo=y1+(move*Math.cos(slope));
				}

		System.out.println(xo+" "+yo+" "+ro);
	}
}


//package info.stochastic;

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class C {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            long r = in.nextLong();
            long x1 = in.nextLong();
            long y1 = in.nextLong();
            long x2 = in.nextLong() - x1;
            long y2 = in.nextLong() - y1;
            double eps = 0.0000000001;

            if (r < Math.sqrt(x2 * x2 + y2 * y2)
                    || Math.abs(r - Math.sqrt(x2 * x2 + y2 * y2)) < eps) {
                out.print(x1 + " " + y1 + " " + r);
                return;
            }

            if (x2 == 0 && y2 == 0) {
                out.print(x1 - (r / 2.0) + " " + y1 + " " + (r / 2.0));
                return;
            }

            double a = -y2;
            double b = x2;
            double c = 0;
            double x0 = -a * c / (a * a + b * b);
            double y0 = -b * c / (a * a + b * b);
            double d = r * r - c * c / (a * a +  b * b);
            double mult = Math.sqrt(d / (a * a + b * b));
            double ax, ay, bx, by;
            ax = x0 + b * mult;
            bx = x0 - b * mult;
            ay = y0 - a * mult;
            by = y0 + a * mult;
            //out.println(ax + " " + ay + " " + bx + " "  + by);

            double distA = Math.sqrt((ax - x2) * (ax - x2) + (ay - y2) * (ay - y2));
            double distB = Math.sqrt((bx - x2) * (bx - x2) + (by - y2) * (by - y2));
            if (distA > distB) {
                double x = (ax + x2) / 2 + x1;
                double y = (ay + y2) / 2 + y1;
                out.print(x + " " + y + " " + distA / 2);
            } else {
                double x = (bx + x2) / 2 + x1;
                double y = (by + y2) / 2 + y1;
                out.print(x + " " + y + " " + distB / 2);
            }

        }
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }

    }
}


//package info.stochastic;

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class C {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int r = in.nextInt();
            int x1 = in.nextInt();
            int y1 = in.nextInt();
            int x2 = in.nextInt() - x1;
            int y2 = in.nextInt() - y1;

            if (r <= Math.sqrt(x2 * x2 + y2 * y2)) {
                out.print(x1 + " " + y1 + " " + r);
                return;
            }

            if (x2 == 0 && y2 == 0) {
                out.print(x1 - (r / 2.0) + " " + y1 + " " + (r / 2.0));
                return;
            }

            double a = -y2;
            double b = x2;
            double c = 0;
            double x0 = -a*c/(a*a+b*b),  y0 = -b*c/(a*a+b*b);
            double d = r*r - c*c/(a*a+b*b);
            double mult = Math.sqrt(d / (a*a+b*b));
            double ax,ay,bx,by;
            ax = x0 + b * mult;
            bx = x0 - b * mult;
            ay = y0 - a * mult;
            by = y0 + a * mult;
            //out.println(ax + " " + ay + " " + bx + " "  + by);

            double distA = Math.sqrt((ax - x2) * (ax - x2) + (ay - y2) * (ay - y2));
            double distB = Math.sqrt((bx - x2) * (bx - x2) + (by - y2) * (by - y2));
            if (distA > distB) {
                double x = (ax + x2) / 2 + x1;
                double y = (ay + y2) / 2 + y1;
                out.print(x + " " + y + " " + distA / 2);
            } else {
                double x = (bx + x2) / 2 + x1;
                double y = (by + y2) / 2 + y1;
                out.print(x + " " + y + " " + distB / 2);
            }

        }
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }

    }
}


//package info.stochastic;

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class C {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int r = in.nextInt();
            int x1 = in.nextInt();
            int y1 = in.nextInt();
            int x2 = in.nextInt() - x1;
            int y2 = in.nextInt() - y1;

            if (r <= Math.sqrt(x2 * x2 + y2 * y2)) {
                out.print(x1 + " " + y1 + " " + r);
                return;
            }

            double a = -y2;
            double b = x2;
            double c = 0;
            double x0 = -a*c/(a*a+b*b),  y0 = -b*c/(a*a+b*b);
            double d = r*r - c*c/(a*a+b*b);
            double mult = Math.sqrt(d / (a*a+b*b));
            double ax,ay,bx,by;
            ax = x0 + b * mult;
            bx = x0 - b * mult;
            ay = y0 - a * mult;
            by = y0 + a * mult;

            double distA = Math.sqrt((ax - x2) * (ax - x2) + (ay - y2) * (ay - y2));
            double distB = Math.sqrt((bx - x2) * (bx - x2) + (by - y2) * (by - y2));
            if (distA > distB) {
                double x = (ax + x2) / 2 + x1;
                double y = (ay + y2) / 2 + y1;
                out.print(x + " " + y + " " + distA / 2);
            } else {
                double x = (bx + x2) / 2 + x1;
                double y = (by + y2) / 2 + y1;
                out.print(x + " " + y + " " + distB / 2);
            }

        }
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }

    }
}


//package info.stochastic;

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class C {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int r = in.nextInt();
            int x1 = in.nextInt();
            int y1 = in.nextInt();
            int x2 = in.nextInt() - x1;
            int y2 = in.nextInt() - y1;
            double eps = 0.0000000001;

            if (r < Math.sqrt(x2 * x2 + y2 * y2)
                    || Math.abs(r - Math.sqrt(x2 * x2 + y2 * y2)) < eps) {
                out.print(x1 + " " + y1 + " " + r);
                return;
            }

            if (x2 == 0 && y2 == 0) {
                out.print(x1 - (r / 2.0) + " " + y1 + " " + (r / 2.0));
                return;
            }

            double a = -y2;
            double b = x2;
            double c = 0;
            double x0 = -a * c / (a * a + b * b);
            double y0 = -b * c / (a * a + b * b);
            double d = r * r - c * c / (a * a +  b * b);
            double mult = Math.sqrt(d / (a * a + b * b));
            double ax, ay, bx, by;
            ax = x0 + b * mult;
            bx = x0 - b * mult;
            ay = y0 - a * mult;
            by = y0 + a * mult;
            //out.println(ax + " " + ay + " " + bx + " "  + by);

            double distA = Math.sqrt((ax - x2) * (ax - x2) + (ay - y2) * (ay - y2));
            double distB = Math.sqrt((bx - x2) * (bx - x2) + (by - y2) * (by - y2));
            if (distA > distB) {
                double x = (ax + x2) / 2 + x1;
                double y = (ay + y2) / 2 + y1;
                out.print(x + " " + y + " " + distA / 2);
            } else {
                double x = (bx + x2) / 2 + x1;
                double y = (by + y2) / 2 + y1;
                out.print(x + " " + y + " " + distB / 2);
            }

        }
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }

    }
}


import java.io.PrintWriter;
import java.util.Scanner;

import static java.lang.Math.*;

public class Task3 {
    void solve(Scanner in, PrintWriter out){
        long R = in.nextLong();
        long x1 = in.nextLong();
        long y1 = in.nextLong();
        long x2 = in.nextLong();
        long y2 = in.nextLong();
        double eps = 10e-6;
        double x,y,r;

        double d = (x2 - x1)*(x2 - x1) + (y2 - y1)*(y2 - y1);
        if( d >= R*R ) {
            x = x1;
            y = y1;
            r = R;
            out.print(x+" "+y+" "+r);
            return;
        }

        d = sqrt(d);
        r = (R + d)/2;

        if(x1 == x2 && y1 == y2){
            x = x2;
            y = y1 + r;
        }else if(x1 == x2){
            y = y2 + r*(y1 - y2)/d;
            x = x2;
        } else if(y1 == y2){
            x = x2 + r*(x1 - x2)/d;
            y = y2;
        }else {

            x = x2 + r * (x1 - x2) / d;
            y = y2 + r * (y1 - y2) / d;
        }
        out.print(x+" "+y+" "+r);
    }

    void run(){
        try(
                Scanner in = new Scanner(System.in);
                PrintWriter out = new PrintWriter(System.out)){

            solve(in,out);
        }
    }

    public static void main(String[] args) {
        new Task3().run();
    }
}


import java.io.PrintWriter;
import java.util.Scanner;

import static java.lang.Math.*;

public class Task3 {
    void solve(Scanner in, PrintWriter out){
        long R = in.nextLong();
        long x1 = in.nextLong();
        long y1 = in.nextLong();
        long x2 = in.nextLong();
        long y2 = in.nextLong();
        double eps = 10e-6;
        double x,y,r;

        double d = (x2 - x1)*(x2 - x1) + (y2 - y1)*(y2 - y1);
        if( d >= R*R ) {
            x = x1;
            y = y1;
            r = R;
            out.print(x+" "+y+" "+r);
            return;
        }

        d = sqrt(d);
        r = (R + d)/2;

        x = x2 + r*(x1 - x2)/d;
        y = y2 + r*(y1 - y2)/d;
        out.print(x+" "+y+" "+r);
    }

    void run(){
        try(
                Scanner in = new Scanner(System.in);
                PrintWriter out = new PrintWriter(System.out)){

            solve(in,out);
        }
    }

    public static void main(String[] args) {
        new Task3().run();
    }
}


import java.io.PrintWriter;
import java.util.Scanner;

import static java.lang.Math.*;

public class Task3 {
    void solve(Scanner in, PrintWriter out){
        long R = in.nextLong();
        long x1 = in.nextLong();
        long y1 = in.nextLong();
        long x2 = in.nextLong();
        long y2 = in.nextLong();
        double eps = 10e-6;
        double x,y,r;

        double d = (x2 - x1)*(x2 - x1) + (y2 - y1)*(y2 - y1);
        if( d >= R*R ) {
            x = x1;
            y = y1;
            r = R;
            out.print(x+" "+y+" "+r);
            return;
        }

        d = sqrt(d);
        r = (R + d)/2;
        x = x2 + r;
        y = y2 + r;
        out.print(x+" "+y+" "+r);
    }

    void run(){
        try(
                Scanner in = new Scanner(System.in);
                PrintWriter out = new PrintWriter(System.out)){

            solve(in,out);
        }
    }

    public static void main(String[] args) {
        new Task3().run();
    }
}


import java.io.PrintWriter;
import java.util.Scanner;

import static java.lang.Math.*;

public class Task3 {
    void solve(Scanner in, PrintWriter out){
        long R = in.nextLong();
        long x1 = in.nextLong();
        long y1 = in.nextLong();
        long x2 = in.nextLong();
        long y2 = in.nextLong();
        double eps = 10e-6;
        double x,y,r;

        double d = (x2 - x1)*(x2 - x1) + (y2 - y1)*(y2 - y1);
        if( d >= R*R ) {
            x = x1;
            y = y1;
            r = R;
            out.print(x+" "+y+" "+r);
            return;
        }

        d = sqrt(d);
        r = (R + d)/2;

        if(x1 == x2){
            y = y2 + r*(y1 - y2)/d;
            x = x2;
        } else if(y1 == y2){
            x = x2 + r*(x1 - x2)/d;
            y = y2;
        }else {

            x = x2 + r * (x1 - x2) / d;
            y = y2 + r * (y1 - y2) / d;
        }
        out.print(x+" "+y+" "+r);
    }

    void run(){
        try(
                Scanner in = new Scanner(System.in);
                PrintWriter out = new PrintWriter(System.out)){

            solve(in,out);
        }
    }

    public static void main(String[] args) {
        new Task3().run();
    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.text.DecimalFormat;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.text.NumberFormat;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author ijxjdjd
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            double R = in.nextInt();
            double x1 = in.nextInt();
            double y1 = in.nextInt();
            double x2 = in.nextInt();
            double y2 = in.nextInt();
            double nextR = (R + (Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)))) / 2;
            double angle = Math.atan2(y1 - y2, x1 - x2);
            x1 = Math.cos(angle) * nextR + x2;
            y1 = Math.sin(angle) * nextR + y2;
            DecimalFormat df = new DecimalFormat(".############");
            out.println(df.format(x1) + " " + df.format(y1) + " " + df.format(nextR));
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

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

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.text.DecimalFormat;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.text.NumberFormat;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author ijxjdjd
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            double R = in.nextInt();
            double x1 = in.nextInt();
            double y1 = in.nextInt();
            double x2 = in.nextInt();
            double y2 = in.nextInt();
            double dist = Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
            double nextR = (R + (dist)) / 2;
            DecimalFormat df = new DecimalFormat("0.0###########");
            if (dist >= R) {
                nextR = R;
            } else {
                double angle = Math.atan2(y1 - y2, x1 - x2);
                x1 = Math.cos(angle) * nextR + x2;
                y1 = Math.sin(angle) * nextR + y2;
            }
            out.println(df.format(x1) + " " + df.format(y1) + " " + df.format(nextR));
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

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

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.text.DecimalFormat;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.text.NumberFormat;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author ijxjdjd
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            double R = in.nextInt();
            double x1 = in.nextInt();
            double y1 = in.nextInt();
            double x2 = in.nextInt();
            double y2 = in.nextInt();
            double nextR = (R + (Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)))) / 2;
            double angle = Math.atan2(y1 - y2, x1 - x2);
            x1 = Math.cos(angle) * nextR + x2;
            y1 = Math.sin(angle) * nextR + y2;
            DecimalFormat df = new DecimalFormat("0.0###########");
            out.println(df.format(x1) + " " + df.format(y1) + " " + df.format(nextR));
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

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

    }
}


import java.util.*;
import java.io.*;
import java.math.*;

public class test {
	public static void main(String[] args) throws IOException {
		Scanner s = new Scanner(System.in);
		StringTokenizer st = new StringTokenizer(s.nextLine());
		int R = Integer.parseInt(st.nextToken());
		int x1 = Integer.parseInt(st.nextToken());
		int y1 = Integer.parseInt(st.nextToken());
		int x2 = Integer.parseInt(st.nextToken());
		int y2 = Integer.parseInt(st.nextToken());
		if ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) >= R * R) {
			System.out.print(x1 + " " + y1 + " " + R);
			s.close();
			return;
		} else if (x1 == x2 && y1 == y2) {
			System.out.println((x1 + (double) (R) / 2) + " " + (y1 + (double) (R) / 2) + " " + (double) (R) / 2);
		} else {
			double dist = Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) + (y1 - y2));
			double actualRadius = (dist + R) / 2;
			double xDist = x1 - x2;
			double yDist = y1 - y2;
			double actualX = xDist * actualRadius / (Math.sqrt(xDist * xDist + yDist * yDist));
			double actualY = yDist * actualRadius / (Math.sqrt(xDist * xDist + yDist * yDist));
			System.out.print((x2 + actualX) + " " + (y2 + actualY) + " " + actualRadius);
		}
		s.close();
	}
}


import java.util.*;
import java.io.*;
import java.math.*;

public class test {
	public static void main(String[] args) throws IOException {
		Scanner s = new Scanner(System.in);
		StringTokenizer st = new StringTokenizer(s.nextLine());
		int R = Integer.parseInt(st.nextToken());
		int x1 = Integer.parseInt(st.nextToken());
		int y1 = Integer.parseInt(st.nextToken());
		int x2 = Integer.parseInt(st.nextToken());
		int y2 = Integer.parseInt(st.nextToken());
		if ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) >= R * R) {
			System.out.print(x1 + " " + x2 + " " + R);
			s.close();
			return;
		} else if (x1 == x2 && y1 == y2) {
			System.out.println((x1 + (double) (R) / 2) + " " + (y1 + (double) (R) / 2) + " " + (double) (R) / 2);
		} else {
			double dist = Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) + (y1 - y2));
			double actualRadius = (dist + R) / 2;
			double xDist = x1 - x2;
			double yDist = y1 - y2;
			double actualX = xDist * actualRadius / (Math.sqrt(xDist * xDist + yDist * yDist));
			double actualY = yDist * actualRadius / (Math.sqrt(xDist * xDist + yDist * yDist));
			System.out.print((x2 + actualX) + " " + (y2 + actualY) + " " + actualRadius);
		}
		s.close();
	}
}


import java.util.*;
import java.io.*;
import java.math.*;

public class test {
	public static void main(String[] args) throws IOException {
		Scanner s = new Scanner(System.in);
		StringTokenizer st = new StringTokenizer(s.nextLine());
		int R = Integer.parseInt(st.nextToken());
		int x1 = Integer.parseInt(st.nextToken());
		int y1 = Integer.parseInt(st.nextToken());
		int x2 = Integer.parseInt(st.nextToken());
		int y2 = Integer.parseInt(st.nextToken());
		if ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) >= R * R) {
			System.out.print(x1 + " " + y1 + " " + R);
			s.close();
			return;
		} else if (x1 == x2 && y1 == y2) {
			System.out.println((x1 + (double) (R) / 2) + " " + (y1 + (double) (R) / 2) + " " + (double) (R) / 2);
		} else {
			double dist = Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
			double actualRadius = (dist + R) / 2;
			double xDist = x1 - x2;
			double yDist = y1 - y2;
			double actualX = xDist * actualRadius / (Math.sqrt(xDist * xDist + yDist * yDist));
			double actualY = yDist * actualRadius / (Math.sqrt(xDist * xDist + yDist * yDist));
			System.out.print((x2 + actualX) + " " + (y2 + actualY) + " " + actualRadius);
		}
		s.close();
	}
}


import java.util.*;
import java.io.*;
import java.math.*;

public class test {
	public static void main(String[] args) throws IOException {
		Scanner s = new Scanner(System.in);
		StringTokenizer st = new StringTokenizer(s.nextLine());
		int R = Integer.parseInt(st.nextToken());
		int x1 = Integer.parseInt(st.nextToken());
		int y1 = Integer.parseInt(st.nextToken());
		int x2 = Integer.parseInt(st.nextToken());
		int y2 = Integer.parseInt(st.nextToken());
		if ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) >= R * R) {
			System.out.print(x1 + " " + y1 + " " + R);
			s.close();
			return;
		} else if (x1 == x2 && y1 == y2) {
			System.out.println((x1 + (double) (R) / 2) + " " + y1 + " " + (double) (R) / 2);
		} else {
			BigDecimal dist = BigDecimal.valueOf(Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)));
			BigDecimal actualRadius = BigDecimal.valueOf(R).add(dist).divide(BigDecimal.valueOf(2));
			BigDecimal xDist = BigDecimal.valueOf(x1 - x2);
			BigDecimal yDist = BigDecimal.valueOf(y1 - y2);
			BigDecimal actualX = xDist.multiply(actualRadius).divide(
					BigDecimal.valueOf(Math.sqrt((xDist.multiply(xDist).add((yDist.multiply(yDist)))).doubleValue())),
					RoundingMode.HALF_UP);
			BigDecimal actualY = yDist.multiply(actualRadius).divide(
					BigDecimal.valueOf(Math.sqrt((xDist.multiply(xDist).add((yDist.multiply(yDist)))).doubleValue())),
					RoundingMode.HALF_UP);
			System.out.print((BigDecimal.valueOf(x2).add(actualX)).doubleValue() + " "
					+ (BigDecimal.valueOf(y2).add(actualY)).doubleValue() + " " + actualRadius);
		}
		s.close();
	}
}


import java.util.*;
import java.io.*;
import java.math.*;

public class test {
	public static void main(String[] args) throws IOException {
		Scanner s = new Scanner(System.in);
		StringTokenizer st = new StringTokenizer(s.nextLine());
		long R = Long.parseLong(st.nextToken());
		long x1 = Long.parseLong(st.nextToken());
		long y1 = Long.parseLong(st.nextToken());
		long x2 = Long.parseLong(st.nextToken());
		long y2 = Long.parseLong(st.nextToken());
		if ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) >= R * R) {
			System.out.print(x1 + " " + y1 + " " + R);
			s.close();
			return;
		} else if (x1 == x2 && y1 == y2) {
			System.out.println((x1 + (double) (R) / 2) + " " + (y1 + (double) (R) / 2) + " " + (double) (R) / 2);
		} else {
			double dist = Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
			double actualRadius = (dist + R) / 2;
			double xDist = x1 - x2;
			double yDist = y1 - y2;
			double actualX = xDist * actualRadius / (Math.sqrt(xDist * xDist + yDist * yDist));
			double actualY = yDist * actualRadius / (Math.sqrt(xDist * xDist + yDist * yDist));
			System.out.print((x2 + actualX) + " " + (y2 + actualY) + " " + actualRadius);
		}
		s.close();
	}
}


import java.util.*;
import java.io.*;
import java.math.*;

public class test {
	public static void main(String[] args) throws IOException {
		Scanner s = new Scanner(System.in);
		StringTokenizer st = new StringTokenizer(s.nextLine());
		long R = Long.parseLong(st.nextToken());
		long x1 = Long.parseLong(st.nextToken());
		long y1 = Long.parseLong(st.nextToken());
		long x2 = Long.parseLong(st.nextToken());
		long y2 = Long.parseLong(st.nextToken());
		if ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) >= R * R) {
			System.out.print(x1 + " " + y1 + " " + R);
			s.close();
			return;
		} else if (x1 == x2 && y1 == y2) {
			System.out.println((x1 + (double) (R) / 2) + " " + y1 + " " + (double) (R) / 2);
		} else {
			double dist = Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
			double actualRadius = (dist + R) / 2;
			double xDist = x1 - x2;
			double yDist = y1 - y2;
			double actualX = xDist * actualRadius / (Math.sqrt(xDist * xDist + yDist * yDist));
			double actualY = yDist * actualRadius / (Math.sqrt(xDist * xDist + yDist * yDist));
			System.out.print((x2 + actualX) + " " + (y2 + actualY) + " " + actualRadius);
		}
		s.close();
	}
}


import java.util.*;
import java.io.*;
import java.math.*;

public class test {
	public static void main(String[] args) throws IOException {
		Scanner s = new Scanner(System.in);
		StringTokenizer st = new StringTokenizer(s.nextLine());
		int R = Integer.parseInt(st.nextToken());
		int x1 = Integer.parseInt(st.nextToken());
		int y1 = Integer.parseInt(st.nextToken());
		int x2 = Integer.parseInt(st.nextToken());
		int y2 = Integer.parseInt(st.nextToken());
		if ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) >= R * R) {
			System.out.print(x1 + " " + y1 + " " + R);
			s.close();
			return;
		} else if (x1 == x2 && y1 == y2) {
			System.out.println((x1 + (double) (R) / 2) + " " + y1 + " " + (double) (R) / 2);
		} else {
			double dist = Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
			double actualRadius = (dist + R) / 2;
			double xDist = x1 - x2;
			double yDist = y1 - y2;
			double actualX = xDist * actualRadius / (Math.sqrt(xDist * xDist + yDist * yDist));
			double actualY = yDist * actualRadius / (Math.sqrt(xDist * xDist + yDist * yDist));
			System.out.print((x2 + actualX) + " " + (y2 + actualY) + " " + actualRadius);
		}
		s.close();
	}
}


									import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.InputMismatchException;
					public class Solution1 implements Runnable
					{
						static final long MAX = 1000000007L;
						static class InputReader
						{
							private InputStream stream;
							private byte[] buf = new byte[1024];
							private int curChar;
							private int numChars;
							private SpaceCharFilter filter;
							private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

							public InputReader(InputStream stream)
							{
								this.stream = stream;
							}

							public int read()
							{
								if (numChars==-1)
									throw new InputMismatchException();

								if (curChar >= numChars)
								{
									curChar = 0;
									try
									{
										numChars = stream.read(buf);
									}
									catch (IOException e)
									{
										throw new InputMismatchException();
									}

									if(numChars <= 0)
										return -1;
								}
								return buf[curChar++];
							}

							public String nextLine()
							{
								String str = "";
					            try
					            {
					                str = br.readLine();
					            }
					            catch (IOException e)
					            {
					                e.printStackTrace();
					            }
					            return str;
							}
							public int nextInt()
							{
								int c = read();

								while(isSpaceChar(c))
									c = read();

								int sgn = 1;

								if (c == '-')
								{
									sgn = -1;
									c = read();
								}

								int res = 0;
								do
								{
									if(c<'0'||c>'9')
										throw new InputMismatchException();
									res *= 10;
									res += c - '0';
									c = read();
								}
								while (!isSpaceChar(c));

								return res * sgn;
							}

							public long nextLong()
							{
								int c = read();
								while (isSpaceChar(c))
									c = read();
								int sgn = 1;
								if (c == '-')
								{
									sgn = -1;
									c = read();
								}
								long res = 0;

								do
								{
									if (c < '0' || c > '9')
										throw new InputMismatchException();
									res *= 10;
									res += c - '0';
									c = read();
								}
								while (!isSpaceChar(c));
									return res * sgn;
							}

							public double nextDouble()
							{
								int c = read();
								while (isSpaceChar(c))
									c = read();
								int sgn = 1;
								if (c == '-')
								{
									sgn = -1;
									c = read();
								}
								double res = 0;
								while (!isSpaceChar(c) && c != '.')
								{
									if (c == 'e' || c == 'E')
										return res * Math.pow(10, nextInt());
									if (c < '0' || c > '9')
										throw new InputMismatchException();
									res *= 10;
									res += c - '0';
									c = read();
								}
								if (c == '.')
								{
									c = read();
									double m = 1;
									while (!isSpaceChar(c))
									{
										if (c == 'e' || c == 'E')
											return res * Math.pow(10, nextInt());
										if (c < '0' || c > '9')
											throw new InputMismatchException();
										m /= 10;
										res += (c - '0') * m;
										c = read();
									}
								}
								return res * sgn;
							}

							public String readString()
							{
								int c = read();
								while (isSpaceChar(c))
									c = read();
								StringBuilder res = new StringBuilder();
								do
								{
									res.appendCodePoint(c);
									c = read();
								}
								while (!isSpaceChar(c));

								return res.toString();
							}

							public boolean isSpaceChar(int c)
							{
								if (filter != null)
									return filter.isSpaceChar(c);
								return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
							}

							public String next()
							{
								return readString();
							}

							public interface SpaceCharFilter
							{
								public boolean isSpaceChar(int ch);
							}
						}

						public static void main(String args[]) throws Exception
						{
							new Thread(null, new Solution1(),"Solution1",1<<26).start();
						}
						ArrayList<Integer> adj[];
						long[] val;
						int[] depth;
						int[][] parent;
						boolean[] visited;
						int level = 20;
						int root = 1;
						class Node implements Comparable<Node>{
							double a;
							int b;
							Node(double a,int b){
								this.a = a;
								this.b = b;
							}
							public int compareTo(Node n){
								return Double.compare(this.a,n.a);
							}
						}
						boolean isInside(double circle_x, double circle_y, double rad, double x, double y)
						{
						    // Compare radius of circle with distance of its center from
						    // given point
						    if ((x - circle_x)*(x - circle_x) +
						        (y - circle_y)*(y - circle_y) <= rad*rad)
						        return true;
						    else
						        return false;
						}
						public void run()
						{
							InputReader sc= new InputReader(System.in);
							PrintWriter w= new PrintWriter(System.out);
							double rad = sc.nextDouble();
							double a = sc.nextDouble();
							double b = sc.nextDouble();
							double x = sc.nextDouble();
							double y = sc.nextDouble();
							if(isInside(a, b, rad, x, y)){
								System.out.printf("%.10f %.10f %.10f",a,b,rad);
								System.exit(0);
							}
							double nrad = dist(a, b, x, y) + rad;
							nrad = nrad/2;
							double slope = ((y - b)*1.0/(x - a));
							double temp = ((rad - nrad) * (rad - nrad)/(1 + slope*slope));
							double sqr = Math.sqrt(temp);
							double x1 = a + sqr;
							double x2 = a - sqr;
							double y1 = b + slope*(x1 - a);
							double y2 = b + slope*(x2 - a);
							if(dist(x1,y1,x,y) < dist(x2,y2,x,y)){
								System.out.printf("%.10f %.10f %.10f",x2,y2,nrad);
							}else{
								System.out.printf("%.10f %.10f %.10f",x1,y1,nrad);
							}
							w.close();
						}
						double squareRoot(double n)
						{
						  /*We are using n itself as initial approximation
						   This can definitely be improved */
						  double x = n;
						  double y = 0.00000001;
						  double e = 0.00000001; /* e decides the accuracy level*/
						  while(x - y > e)
						  {
						    x = (x + y)/2;
						    y = n/x;
						  }
						  return x;
						}
						double dist(double a,double b,double c,double d){
							double temp = ((a - c) * (a - c) + (b - d) * (b - d));
							return squareRoot(temp);
						}
						long[] p2 = new long[1000005];
						void pow2(){
							p2[0] = 1;
							for(int i = 1;i < p2.length;i++){
								p2[i] = (p2[i-1] * 2)%MAX;
							}
						}
						long solve(long n,long m){
							long temp = (fac[(int)n] * fac[(int)m])%MAX;
							long temp2 = fac[(int)(n + m)];
							return ((temp2 * modInverse(temp,MAX))%MAX - 1 + MAX)%MAX;
						}
						static long modInverse(long a, long m)
					    {
					        long m0 = m;
					        long y = 0, x = 1;

					        if (m == 1)
					            return 0;

					        while (a > 1)
					        {
					            // q is quotient
					            long q = a / m;

					            long t = m;

					            // m is remainder now, process
					            // same as Euclid's algo
					            m = a % m;
					            a = t;
					            t = y;

					            // Update x and y
					            y = x - q * y;
					            x = t;
					        }

					        // Make x positive
					        if (x < 0)
					            x += m0;

					        return x;
					    }
						long[] fac = new long[1000005];
						void fact(){
							fac[0] = 1;
							for(int i = 1;i < fac.length;i++){
								fac[i] = (fac[i-1]*i)%MAX;
							}
						}
						boolean isVowel(char c){
							return (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u');
						}
						static class Pair implements Comparable<Pair>{
							long a;
							long b;
							Pair(long a,long b){
								this.a = a;
								this.b = b;
							}
							public int compareTo(Pair p){
								if(this.a == p.a){
									return Long.compare(this.b,p.b);
								}
								return Long.compare(this.a,p.a);
							}
						}
		}


									import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.InputMismatchException;
					public class Solution1 implements Runnable
					{
						static final long MAX = 1000000007L;
						static class InputReader
						{
							private InputStream stream;
							private byte[] buf = new byte[1024];
							private int curChar;
							private int numChars;
							private SpaceCharFilter filter;
							private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

							public InputReader(InputStream stream)
							{
								this.stream = stream;
							}

							public int read()
							{
								if (numChars==-1)
									throw new InputMismatchException();

								if (curChar >= numChars)
								{
									curChar = 0;
									try
									{
										numChars = stream.read(buf);
									}
									catch (IOException e)
									{
										throw new InputMismatchException();
									}

									if(numChars <= 0)
										return -1;
								}
								return buf[curChar++];
							}

							public String nextLine()
							{
								String str = "";
					            try
					            {
					                str = br.readLine();
					            }
					            catch (IOException e)
					            {
					                e.printStackTrace();
					            }
					            return str;
							}
							public int nextInt()
							{
								int c = read();

								while(isSpaceChar(c))
									c = read();

								int sgn = 1;

								if (c == '-')
								{
									sgn = -1;
									c = read();
								}

								int res = 0;
								do
								{
									if(c<'0'||c>'9')
										throw new InputMismatchException();
									res *= 10;
									res += c - '0';
									c = read();
								}
								while (!isSpaceChar(c));

								return res * sgn;
							}

							public long nextLong()
							{
								int c = read();
								while (isSpaceChar(c))
									c = read();
								int sgn = 1;
								if (c == '-')
								{
									sgn = -1;
									c = read();
								}
								long res = 0;

								do
								{
									if (c < '0' || c > '9')
										throw new InputMismatchException();
									res *= 10;
									res += c - '0';
									c = read();
								}
								while (!isSpaceChar(c));
									return res * sgn;
							}

							public double nextDouble()
							{
								int c = read();
								while (isSpaceChar(c))
									c = read();
								int sgn = 1;
								if (c == '-')
								{
									sgn = -1;
									c = read();
								}
								double res = 0;
								while (!isSpaceChar(c) && c != '.')
								{
									if (c == 'e' || c == 'E')
										return res * Math.pow(10, nextInt());
									if (c < '0' || c > '9')
										throw new InputMismatchException();
									res *= 10;
									res += c - '0';
									c = read();
								}
								if (c == '.')
								{
									c = read();
									double m = 1;
									while (!isSpaceChar(c))
									{
										if (c == 'e' || c == 'E')
											return res * Math.pow(10, nextInt());
										if (c < '0' || c > '9')
											throw new InputMismatchException();
										m /= 10;
										res += (c - '0') * m;
										c = read();
									}
								}
								return res * sgn;
							}

							public String readString()
							{
								int c = read();
								while (isSpaceChar(c))
									c = read();
								StringBuilder res = new StringBuilder();
								do
								{
									res.appendCodePoint(c);
									c = read();
								}
								while (!isSpaceChar(c));

								return res.toString();
							}

							public boolean isSpaceChar(int c)
							{
								if (filter != null)
									return filter.isSpaceChar(c);
								return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
							}

							public String next()
							{
								return readString();
							}

							public interface SpaceCharFilter
							{
								public boolean isSpaceChar(int ch);
							}
						}

						public static void main(String args[]) throws Exception
						{
							new Thread(null, new Solution1(),"Solution1",1<<26).start();
						}
						ArrayList<Integer> adj[];
						long[] val;
						int[] depth;
						int[][] parent;
						boolean[] visited;
						int level = 20;
						int root = 1;
						class Node implements Comparable<Node>{
							double a;
							int b;
							Node(double a,int b){
								this.a = a;
								this.b = b;
							}
							public int compareTo(Node n){
								return Double.compare(this.a,n.a);
							}
						}
						boolean isInside(double circle_x, double circle_y, double rad, double x, double y)
						{
						    // Compare radius of circle with distance of its center from
						    // given point
						    if ((x - circle_x)*(x - circle_x) +
						        (y - circle_y)*(y - circle_y) < rad*rad)
						        return true;
						    else
						        return false;
						}
						public void run()
						{
							InputReader sc= new InputReader(System.in);
							PrintWriter w= new PrintWriter(System.out);
							double rad = sc.nextDouble();
							double a = sc.nextDouble();
							double b = sc.nextDouble();
							double x = sc.nextDouble();
							double y = sc.nextDouble();

							if(a == x && b == y){
								rad = 0;
								System.out.printf("%.10f %.10f %.10f",a,b,rad);
								System.exit(0);
							}
							if(!isInside(a, b, rad, x, y)){
								System.out.printf("%.10f %.10f %.10f",a,b,rad);
								System.exit(0);
							}
							double nrad = dist(a, b, x, y) + rad;
							nrad = nrad/2;
							if(x == a){
								if(dist(a,b + (rad -  nrad),x,y) < dist(a,b - (rad - nrad),x,y)){
									System.out.printf("%.10f %.10f %.10f",a,b - (rad - nrad),nrad);
								}else{
									System.out.printf("%.10f %.10f %.10f",a,b + (rad -  nrad),nrad);
								}
								System.exit(0);
							}
							double slope = ((y - b)*1.0/(x - a));
							double temp = ((rad - nrad) * (rad - nrad)/(1 + slope*slope));
							double sqr = Math.sqrt(temp);
							double x1 = a + sqr;
							double x2 = a - sqr;
							double y1 = b + slope*(x1 - a);
							double y2 = b + slope*(x2 - a);
							if(dist(x1,y1,x,y) < dist(x2,y2,x,y)){
								System.out.printf("%.10f %.10f %.10f",x2,y2,nrad);
							}else{
								System.out.printf("%.10f %.10f %.10f",x1,y1,nrad);
							}
							w.close();
						}
						double squareRoot(double n)
						{
						  /*We are using n itself as initial approximation
						   This can definitely be improved */
						  double x = n;
						  double y = 0.00000001;
						  double e = 0.00000001; /* e decides the accuracy level*/
						  while(x - y > e)
						  {
						    x = (x + y)/2;
						    y = n/x;
						  }
						  return x;
						}
						double dist(double a,double b,double c,double d){
							double temp = ((a - c) * (a - c) + (b - d) * (b - d));
							return Math.sqrt(temp);
						}
						long[] p2 = new long[1000005];
						void pow2(){
							p2[0] = 1;
							for(int i = 1;i < p2.length;i++){
								p2[i] = (p2[i-1] * 2)%MAX;
							}
						}
						long solve(long n,long m){
							long temp = (fac[(int)n] * fac[(int)m])%MAX;
							long temp2 = fac[(int)(n + m)];
							return ((temp2 * modInverse(temp,MAX))%MAX - 1 + MAX)%MAX;
						}
						static long modInverse(long a, long m)
					    {
					        long m0 = m;
					        long y = 0, x = 1;

					        if (m == 1)
					            return 0;

					        while (a > 1)
					        {
					            // q is quotient
					            long q = a / m;

					            long t = m;

					            // m is remainder now, process
					            // same as Euclid's algo
					            m = a % m;
					            a = t;
					            t = y;

					            // Update x and y
					            y = x - q * y;
					            x = t;
					        }

					        // Make x positive
					        if (x < 0)
					            x += m0;

					        return x;
					    }
						long[] fac = new long[1000005];
						void fact(){
							fac[0] = 1;
							for(int i = 1;i < fac.length;i++){
								fac[i] = (fac[i-1]*i)%MAX;
							}
						}
						boolean isVowel(char c){
							return (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u');
						}
						static class Pair implements Comparable<Pair>{
							long a;
							long b;
							Pair(long a,long b){
								this.a = a;
								this.b = b;
							}
							public int compareTo(Pair p){
								if(this.a == p.a){
									return Long.compare(this.b,p.b);
								}
								return Long.compare(this.a,p.a);
							}
						}
		}


									import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.InputMismatchException;
					public class Solution1 implements Runnable
					{
						static final long MAX = 1000000007L;
						static class InputReader
						{
							private InputStream stream;
							private byte[] buf = new byte[1024];
							private int curChar;
							private int numChars;
							private SpaceCharFilter filter;
							private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

							public InputReader(InputStream stream)
							{
								this.stream = stream;
							}

							public int read()
							{
								if (numChars==-1)
									throw new InputMismatchException();

								if (curChar >= numChars)
								{
									curChar = 0;
									try
									{
										numChars = stream.read(buf);
									}
									catch (IOException e)
									{
										throw new InputMismatchException();
									}

									if(numChars <= 0)
										return -1;
								}
								return buf[curChar++];
							}

							public String nextLine()
							{
								String str = "";
					            try
					            {
					                str = br.readLine();
					            }
					            catch (IOException e)
					            {
					                e.printStackTrace();
					            }
					            return str;
							}
							public int nextInt()
							{
								int c = read();

								while(isSpaceChar(c))
									c = read();

								int sgn = 1;

								if (c == '-')
								{
									sgn = -1;
									c = read();
								}

								int res = 0;
								do
								{
									if(c<'0'||c>'9')
										throw new InputMismatchException();
									res *= 10;
									res += c - '0';
									c = read();
								}
								while (!isSpaceChar(c));

								return res * sgn;
							}

							public long nextLong()
							{
								int c = read();
								while (isSpaceChar(c))
									c = read();
								int sgn = 1;
								if (c == '-')
								{
									sgn = -1;
									c = read();
								}
								long res = 0;

								do
								{
									if (c < '0' || c > '9')
										throw new InputMismatchException();
									res *= 10;
									res += c - '0';
									c = read();
								}
								while (!isSpaceChar(c));
									return res * sgn;
							}

							public double nextDouble()
							{
								int c = read();
								while (isSpaceChar(c))
									c = read();
								int sgn = 1;
								if (c == '-')
								{
									sgn = -1;
									c = read();
								}
								double res = 0;
								while (!isSpaceChar(c) && c != '.')
								{
									if (c == 'e' || c == 'E')
										return res * Math.pow(10, nextInt());
									if (c < '0' || c > '9')
										throw new InputMismatchException();
									res *= 10;
									res += c - '0';
									c = read();
								}
								if (c == '.')
								{
									c = read();
									double m = 1;
									while (!isSpaceChar(c))
									{
										if (c == 'e' || c == 'E')
											return res * Math.pow(10, nextInt());
										if (c < '0' || c > '9')
											throw new InputMismatchException();
										m /= 10;
										res += (c - '0') * m;
										c = read();
									}
								}
								return res * sgn;
							}

							public String readString()
							{
								int c = read();
								while (isSpaceChar(c))
									c = read();
								StringBuilder res = new StringBuilder();
								do
								{
									res.appendCodePoint(c);
									c = read();
								}
								while (!isSpaceChar(c));

								return res.toString();
							}

							public boolean isSpaceChar(int c)
							{
								if (filter != null)
									return filter.isSpaceChar(c);
								return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
							}

							public String next()
							{
								return readString();
							}

							public interface SpaceCharFilter
							{
								public boolean isSpaceChar(int ch);
							}
						}

						public static void main(String args[]) throws Exception
						{
							new Thread(null, new Solution1(),"Solution1",1<<26).start();
						}
						ArrayList<Integer> adj[];
						long[] val;
						int[] depth;
						int[][] parent;
						boolean[] visited;
						int level = 20;
						int root = 1;
						class Node implements Comparable<Node>{
							double a;
							int b;
							Node(double a,int b){
								this.a = a;
								this.b = b;
							}
							public int compareTo(Node n){
								return Double.compare(this.a,n.a);
							}
						}
						boolean isInside(double circle_x, double circle_y, double rad, double x, double y)
						{
						    // Compare radius of circle with distance of its center from
						    // given point
						    if ((x - circle_x)*(x - circle_x) +
						        (y - circle_y)*(y - circle_y) < rad*rad)
						        return true;
						    else
						        return false;
						}
						public void run()
						{
							InputReader sc= new InputReader(System.in);
							PrintWriter w= new PrintWriter(System.out);
							double rad = sc.nextDouble();
							double a = sc.nextDouble();
							double b = sc.nextDouble();
							double x = sc.nextDouble();
							double y = sc.nextDouble();
							if(!isInside(a, b, rad, x, y)){
								System.out.printf("%.10f %.10f %.10f",a,b,rad);
								System.exit(0);
							}
							double nrad = dist(a, b, x, y) + rad;
							nrad = nrad/2;
							double slope = ((y - b)*1.0/(x - a));
							double temp = ((rad - nrad) * (rad - nrad)/(1 + slope*slope));
							double sqr = Math.sqrt(temp);
							double x1 = a + sqr;
							double x2 = a - sqr;
							double y1 = b + slope*(x1 - a);
							double y2 = b + slope*(x2 - a);
							if(dist(x1,y1,x,y) < dist(x2,y2,x,y)){
								System.out.printf("%.10f %.10f %.10f",x2,y2,nrad);
							}else{
								System.out.printf("%.10f %.10f %.10f",x1,y1,nrad);
							}
							w.close();
						}
						double squareRoot(double n)
						{
						  /*We are using n itself as initial approximation
						   This can definitely be improved */
						  double x = n;
						  double y = 0.00000001;
						  double e = 0.00000001; /* e decides the accuracy level*/
						  while(x - y > e)
						  {
						    x = (x + y)/2;
						    y = n/x;
						  }
						  return x;
						}
						double dist(double a,double b,double c,double d){
							double temp = ((a - c) * (a - c) + (b - d) * (b - d));
							return squareRoot(temp);
						}
						long[] p2 = new long[1000005];
						void pow2(){
							p2[0] = 1;
							for(int i = 1;i < p2.length;i++){
								p2[i] = (p2[i-1] * 2)%MAX;
							}
						}
						long solve(long n,long m){
							long temp = (fac[(int)n] * fac[(int)m])%MAX;
							long temp2 = fac[(int)(n + m)];
							return ((temp2 * modInverse(temp,MAX))%MAX - 1 + MAX)%MAX;
						}
						static long modInverse(long a, long m)
					    {
					        long m0 = m;
					        long y = 0, x = 1;

					        if (m == 1)
					            return 0;

					        while (a > 1)
					        {
					            // q is quotient
					            long q = a / m;

					            long t = m;

					            // m is remainder now, process
					            // same as Euclid's algo
					            m = a % m;
					            a = t;
					            t = y;

					            // Update x and y
					            y = x - q * y;
					            x = t;
					        }

					        // Make x positive
					        if (x < 0)
					            x += m0;

					        return x;
					    }
						long[] fac = new long[1000005];
						void fact(){
							fac[0] = 1;
							for(int i = 1;i < fac.length;i++){
								fac[i] = (fac[i-1]*i)%MAX;
							}
						}
						boolean isVowel(char c){
							return (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u');
						}
						static class Pair implements Comparable<Pair>{
							long a;
							long b;
							Pair(long a,long b){
								this.a = a;
								this.b = b;
							}
							public int compareTo(Pair p){
								if(this.a == p.a){
									return Long.compare(this.b,p.b);
								}
								return Long.compare(this.a,p.a);
							}
						}
		}