									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;
							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){
								System.out.printf("%.10f %.10f %.10f",a,(b + rad/2),rad/2);
								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(a == x && b == y){
								System.out.printf("%.10f %.10f %.10f",a,b/2,rad/2);
								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.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigDecimal;

public class R465C  {
    public static void main (String[] args) throws java.lang.Exception {
        InputReader in = new InputReader(System.in);
        PrintWriter w = new PrintWriter(System.out);
        int R = in.nextInt(), x1 = in.nextInt(), y1 = in.nextInt(), x2 = in.nextInt(), y2 = in.nextInt();
        if (dist(x1, y1, x2, y2) > R * R)
            w.println(x1 + " " + y1 + " " + R);
        else if (x1 == x2 && y1 == y2) {
            w.println(x1 + R / 2.0 + " " + y1 + " " + R/2);

        } else {
            double mag = Math.sqrt(1.0*dist(x1, x2, y1, y2));
            double r = (mag + R) / 2.0;
            double dx = (x1 - x2) / mag;
            double dy = (y1 - y2) / mag;
            w.print((x1 + (r - mag) * dx) + " " + (y1 + (r - mag) * dy) + " " + r);
        }
        w.close();
    }

    static long dist(int x1, int x2, int y1, int y2) {
        return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
    }
    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

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

        public int read() {
            if (numChars == -1)
                throw new UnknownError();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new UnknownError();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public int peek() {
            if (numChars == -1)
                return -1;
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    return -1;
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar];
        }

        public void skip(int x) {
            while (x-- > 0)
                read();
        }

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

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

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

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

            return res.toString();
        }

        public String nextLine() {
            StringBuffer buf = new StringBuffer();
            int c = read();
            while (c != '\n' && c != -1) {
                if (c != '\r')
                    buf.appendCodePoint(c);
                c = read();
            }
            return buf.toString();
        }

        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 int[] nextIntArray(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }
        public long[] nextLongArray(int n) {
            long[] a = new long[n];
            for (int i = 0; i < n; i++)
                a[i] = nextLong();
            return a;
        }
        public boolean hasNext() {
            int value;
            while (isSpaceChar(value = peek()) && value != -1)
                read();
            return value != -1;
        }

        private boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

    }
}


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

public class R465C  {
    public static void main (String[] args) throws java.lang.Exception {
        InputReader in = new InputReader(System.in);
        PrintWriter w = new PrintWriter(System.out);
        double R = in.nextInt(), x1 = in.nextInt(), y1 = in.nextInt(), x2 = in.nextInt(), y2 = in.nextInt();
        if (dist(x1, y1, x2, y2) > 1L * R * R)
            w.println(x1 + " " + y1 + " " + R);
        else if (x1 == x2 && y1 == y2) {
            System.out.println("hi");
            w.println((x1 + R / 2.0) + " " + y1 + " " + (R / 2));

        } else {

            double mag = Math.sqrt(dist(x1, x2, y1, y2));
            double r = (mag + R) / 2.0;
            double dx = (x1 - x2) / mag;
            double dy = (y1 - y2) / mag;
            //System.out.println(dist(x1, x2, y1, y2));
            //System.out.println("yo");
            w.printf("%.14f %.14f %.14f", (x1 + (r - mag) * dx), (y1 + (r - mag) * dy), r);
        }
        w.close();
    }

    static double dist(double x1, double x2, double y1, double y2) {
        return  (x1 - x2) * (x1 - x2) +  (y1 - y2) * (y1 - y2);
    }
    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

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

        public int read() {
            if (numChars == -1)
                throw new UnknownError();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new UnknownError();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public int peek() {
            if (numChars == -1)
                return -1;
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    return -1;
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar];
        }

        public void skip(int x) {
            while (x-- > 0)
                read();
        }

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

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

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

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

            return res.toString();
        }

        public String nextLine() {
            StringBuffer buf = new StringBuffer();
            int c = read();
            while (c != '\n' && c != -1) {
                if (c != '\r')
                    buf.appendCodePoint(c);
                c = read();
            }
            return buf.toString();
        }

        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 int[] nextIntArray(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }
        public long[] nextLongArray(int n) {
            long[] a = new long[n];
            for (int i = 0; i < n; i++)
                a[i] = nextLong();
            return a;
        }
        public boolean hasNext() {
            int value;
            while (isSpaceChar(value = peek()) && value != -1)
                read();
            return value != -1;
        }

        private boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

    }
}


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

public class R465C  {
    public static void main (String[] args) throws java.lang.Exception {
        InputReader in = new InputReader(System.in);
        PrintWriter w = new PrintWriter(System.out);
        double R = in.nextInt(), x1 = in.nextInt(), y1 = in.nextInt(), x2 = in.nextInt(), y2 = in.nextInt();
        if (dist(x1, y1, x2, y2) > 1L * R * R)
            w.println(x1 + " " + y1 + " " + R);
        else if (x1 == x2 && y1 == y2) {
          //  System.out.println("hi");
            w.println((x1 + R / 2.0) + " " + y1 + " " + (R / 2));

        } else {

            double mag = Math.sqrt(dist(x1, x2, y1, y2));
            double r = (mag + R) / 2.0;
            double dx = (x1 - x2) / mag;
            double dy = (y1 - y2) / mag;
            //System.out.println(dist(x1, x2, y1, y2));
            //System.out.println("yo");
            w.printf("%.14f %.14f %.14f", (x1 + (r - mag) * dx), (y1 + (r - mag) * dy), r);
        }
        w.close();
    }

    static double dist(double x1, double x2, double y1, double y2) {
        return  (x1 - x2) * (x1 - x2) +  (y1 - y2) * (y1 - y2);
    }
    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

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

        public int read() {
            if (numChars == -1)
                throw new UnknownError();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new UnknownError();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public int peek() {
            if (numChars == -1)
                return -1;
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    return -1;
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar];
        }

        public void skip(int x) {
            while (x-- > 0)
                read();
        }

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

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

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

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

            return res.toString();
        }

        public String nextLine() {
            StringBuffer buf = new StringBuffer();
            int c = read();
            while (c != '\n' && c != -1) {
                if (c != '\r')
                    buf.appendCodePoint(c);
                c = read();
            }
            return buf.toString();
        }

        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 int[] nextIntArray(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }
        public long[] nextLongArray(int n) {
            long[] a = new long[n];
            for (int i = 0; i < n; i++)
                a[i] = nextLong();
            return a;
        }
        public boolean hasNext() {
            int value;
            while (isSpaceChar(value = peek()) && value != -1)
                read();
            return value != -1;
        }

        private boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

    }
}


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

public class R465C  {
    public static void main (String[] args) throws java.lang.Exception {
        InputReader in = new InputReader(System.in);
        PrintWriter w = new PrintWriter(System.out);
        int R = in.nextInt(), x1 = in.nextInt(), y1 = in.nextInt(), x2 = in.nextInt(), y2 = in.nextInt();
        if (dist(x1, y1, x2, y2) > R * R)
            w.println(x1 + " " + y1 + " " + R);
        else if (x1 == x2 && y1 == y2) {
            //System.out.println("hi");
            w.println((x1 + R / 2.0) + " " + y1 + " " + (R/2));

        } else {

            double mag = Math.sqrt(dist(x1, x2, y1, y2));
            double r = (mag + R) / 2.0;
            double dx = (x1 - x2) / mag;
            double dy = (y1 - y2) / mag;
            //System.out.println(dist(x1, x2, y1, y2));
            w.printf("%.14f %.14f %.14f",(x1 + (r - mag) * dx), (y1 + (r - mag) * dy), r);
        }
        w.close();
    }

    static long dist(int x1, int x2, int y1, int y2) {
        return 1L*(x1 - x2) * (x1 - x2) + 1L*(y1 - y2) * (y1 - y2);
    }
    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

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

        public int read() {
            if (numChars == -1)
                throw new UnknownError();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new UnknownError();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public int peek() {
            if (numChars == -1)
                return -1;
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    return -1;
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar];
        }

        public void skip(int x) {
            while (x-- > 0)
                read();
        }

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

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

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

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

            return res.toString();
        }

        public String nextLine() {
            StringBuffer buf = new StringBuffer();
            int c = read();
            while (c != '\n' && c != -1) {
                if (c != '\r')
                    buf.appendCodePoint(c);
                c = read();
            }
            return buf.toString();
        }

        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 int[] nextIntArray(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }
        public long[] nextLongArray(int n) {
            long[] a = new long[n];
            for (int i = 0; i < n; i++)
                a[i] = nextLong();
            return a;
        }
        public boolean hasNext() {
            int value;
            while (isSpaceChar(value = peek()) && value != -1)
                read();
            return value != -1;
        }

        private boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

    }
}


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

public class R465C  {
    public static void main (String[] args) throws java.lang.Exception {
        InputReader in = new InputReader(System.in);
        PrintWriter w = new PrintWriter(System.out);
        double R = in.nextInt(), x1 = in.nextInt(), y1 = in.nextInt(), x2 = in.nextInt(), y2 = in.nextInt();
        if ( dist(x1,x2,y1,y2)>  R * R)
            w.println(x1 + " " + y1 + " " + R);
        else if (x1 == x2 && y1 == y2) {
          //  System.out.println("hi");
            w.println((x1 + R / 2.0) + " " + y1 + " " + (R / 2));

        } else {

            double mag = Math.sqrt(dist(x1, x2, y1, y2));
            double r = (mag + R) / 2.0;
            double dx = (x1 - x2) / mag;
            double dy = (y1 - y2) / mag;
            //System.out.println(dist(x1, x2, y1, y2));
            //System.out.println("yo");
            w.printf("%.14f %.14f %.14f", (x1 + (r - mag) * dx), (y1 + (r - mag) * dy), r);
        }
        w.close();
    }

    static double dist(double x1, double x2, double y1, double y2) {
        return  (x1 - x2) * (x1 - x2) +  (y1 - y2) * (y1 - y2);
    }
    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

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

        public int read() {
            if (numChars == -1)
                throw new UnknownError();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new UnknownError();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public int peek() {
            if (numChars == -1)
                return -1;
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    return -1;
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar];
        }

        public void skip(int x) {
            while (x-- > 0)
                read();
        }

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

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

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

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

            return res.toString();
        }

        public String nextLine() {
            StringBuffer buf = new StringBuffer();
            int c = read();
            while (c != '\n' && c != -1) {
                if (c != '\r')
                    buf.appendCodePoint(c);
                c = read();
            }
            return buf.toString();
        }

        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 int[] nextIntArray(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }
        public long[] nextLongArray(int n) {
            long[] a = new long[n];
            for (int i = 0; i < n; i++)
                a[i] = nextLong();
            return a;
        }
        public boolean hasNext() {
            int value;
            while (isSpaceChar(value = peek()) && value != -1)
                read();
            return value != -1;
        }

        private boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

    }
}


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

public class Main {

    public static void main(String[] args) throws NumberFormatException, IOException {

        FastReader in = new FastReader(args);

        int R = in.nextInt();
        int x1 = in.nextInt(); int y1 = in.nextInt();
        int x2 = in.nextInt(); int y2 = in.nextInt();

        double tilt;
        if(y2 == y1)        tilt = 0;
        else if(x2 == x1){
            if(y1 > y2) tilt = Double.MAX_VALUE;
            else        tilt = -Double.MAX_VALUE;
        }
        else                tilt = (y2-y1)/(x2-x1);

//        System.out.println("tilt: " + tilt);

        double r = (R+Math.sqrt(Math.pow(x2-x1, 2)+Math.pow(y2-y1, 2)))/2;
        double theta = Math.atan(tilt);
        double dx, dy;
        if(Double.compare(tilt, 0) == 0) {

            if(x2<x1)   dx = r;
            else        dx = -r;
            dy = 0;
        }
        else if(Double.compare(tilt, Double.MAX_VALUE) == 0) {
            dx = 0;
            dy = r;
        }
        else if(Double.compare(tilt, -Double.MAX_VALUE) == 0) {
            dx = 0;
            dy = -r;
        }
        else {
            dx = r*Math.cos(theta);
            dy = r*Math.sin(theta);
        }

//        System.out.println("r: " + r);
//        System.out.println("theta: " + theta);
//        System.out.println("dx: " + dx);
//        System.out.println("dy: " + dy);

        double xap = x2+dx;
        double yap = y2+dy;

        System.out.print(xap + " " + yap + " " + r);
    }

    private static class FastReader {

        private BufferedReader br;
        private StringTokenizer st;

        public FastReader(String[] args) throws FileNotFoundException {
            br = new BufferedReader(new InputStreamReader(System.in));
//            br = new BufferedReader(new FileReader(args[0]));
        }
        public String next() {
            while(st == null || !st.hasMoreElements()) {
                try                 { st = new StringTokenizer(br.readLine()); }
                catch(IOException e){ e.printStackTrace(); }
            }
            return st.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public double nextDouble() {
            return Double.parseDouble((next()));
        }
        public String nextLine() {
            String str = "";
            try                 { str = br.readLine(); }
            catch(IOException e){ e.printStackTrace(); }
            return str;
        }

    }

}


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

public class Main {

    public static void main(String[] args) throws NumberFormatException, IOException {

        FastReader in = new FastReader(args);

        int R = in.nextInt();
        int x1 = in.nextInt(); int y1 = in.nextInt();
        int x2 = in.nextInt(); int y2 = in.nextInt();

        double tilt;
        if(y2 == y1)        tilt = 0;
        else if(x2 == x1){
            if(y1 > y2) tilt = Double.MAX_VALUE;
            else        tilt = -Double.MAX_VALUE;
        }
        else                tilt = (y2-y1)/(x2-x1);

//        System.out.println("tilt: " + tilt);

        double r = (R+Math.sqrt(Math.pow(x2-x1, 2)+Math.pow(y2-y1, 2)))/2;
        double theta = Math.atan(tilt);
        double dx, dy;
        if(Double.compare(tilt, 0) == 0) {
            dx = r;
            dy = 0;
        }
        else if(Double.compare(tilt, Double.MAX_VALUE) == 0) {
            dx = 0;
            dy = r;
        }
        else if(Double.compare(tilt, -Double.MAX_VALUE) == 0) {
            dx = 0;
            dy = -r;
        }
        else {
            dx = r*Math.cos(theta);
            dy = r*Math.sin(theta);
        }

//        System.out.println("r: " + r);
//        System.out.println("theta: " + theta);
//        System.out.println("dx: " + dx);
//        System.out.println("dy: " + dy);

        double xap = x2+dx;
        double yap = y2+dy;

        System.out.print(xap + " " + yap + " " + r);
    }

    private static class FastReader {

        private BufferedReader br;
        private StringTokenizer st;

        public FastReader(String[] args) throws FileNotFoundException {
            br = new BufferedReader(new InputStreamReader(System.in));
//            br = new BufferedReader(new FileReader(args[0]));
        }
        public String next() {
            while(st == null || !st.hasMoreElements()) {
                try                 { st = new StringTokenizer(br.readLine()); }
                catch(IOException e){ e.printStackTrace(); }
            }
            return st.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public double nextDouble() {
            return Double.parseDouble((next()));
        }
        public String nextLine() {
            String str = "";
            try                 { str = br.readLine(); }
            catch(IOException e){ e.printStackTrace(); }
            return str;
        }

    }

}


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

public class Main {

    public static void main(String[] args) throws NumberFormatException, IOException {

        FastReader in = new FastReader(args);

        int R = in.nextInt();
        int x1 = in.nextInt(); int y1 = in.nextInt();
        int x2 = in.nextInt(); int y2 = in.nextInt();

        double distance = Math.sqrt(Math.pow(x2-x1, 2)+Math.pow(y2-y1, 2));
        if(Double.compare(distance, R) == 1) {
            System.out.print(x1 + " " + y1 + " " + R);
            return;
        }
        if(x1 == x2 && y2 == y1) {
            System.out.print(x1 + " " + y1 + " " + 0);
            return;
        }

        double tilt;
        if(y2 == y1)        tilt = 0;
        else if(x2 == x1){
            if(y1 > y2) tilt = Double.MAX_VALUE;
            else        tilt = -Double.MAX_VALUE;
        }
        else                tilt = (y2-y1)/(x2-x1);

//        System.out.println("tilt: " + tilt);

        double r = (R+Math.sqrt(Math.pow(x2-x1, 2)+Math.pow(y2-y1, 2)))/2;
        double theta = Math.atan(tilt);
        double dx, dy;
        if(Double.compare(tilt, 0) == 0) {

            if(x2<x1)   dx = r;
            else        dx = -r;
            dy = 0;
        }
        else if(Double.compare(tilt, Double.MAX_VALUE) == 0) {
            dx = 0;
            dy = r;
        }
        else if(Double.compare(tilt, -Double.MAX_VALUE) == 0) {
            dx = 0;
            dy = -r;
        }
        else {
            dx = Math.abs(r*Math.cos(theta));
            dy = Math.abs(r*Math.sin(theta));
            if(x1<x2)   dx *= -1;
            if(y1<y2)   dy *= -1;
        }

//        System.out.println("r: " + r);
//        System.out.println("theta: " + theta);
//        System.out.println("dx: " + dx);
//        System.out.println("dy: " + dy);

        double xap = x2+dx;
        double yap = y2+dy;

        System.out.print(xap + " " + yap + " " + r);
    }

    private static class FastReader {

        private BufferedReader br;
        private StringTokenizer st;

        public FastReader(String[] args) throws FileNotFoundException {
            br = new BufferedReader(new InputStreamReader(System.in));
//            br = new BufferedReader(new FileReader(args[0]));
        }
        public String next() {
            while(st == null || !st.hasMoreElements()) {
                try                 { st = new StringTokenizer(br.readLine()); }
                catch(IOException e){ e.printStackTrace(); }
            }
            return st.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public double nextDouble() {
            return Double.parseDouble((next()));
        }
        public String nextLine() {
            String str = "";
            try                 { str = br.readLine(); }
            catch(IOException e){ e.printStackTrace(); }
            return str;
        }

    }

}


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

public class Main {

    private static class Line {

        public double a;
        public double b;
        public double c;

        public Line(double x1, double y1, double x2, double y2) {

            a = y2-y1;
            b = -(x2-x1);
            c = -(y2-y1)*x1+(x2-x1)*y1;
        }
        public Line(double a, double b, double c) {
            this.a = a;
            this.b = b;
            this.c = c;
        }
    }

    public static void main(String[] args) throws NumberFormatException, IOException {

        FastReader in = new FastReader(args);

        int R = in.nextInt();
        int x1 = in.nextInt(); int y1 = in.nextInt();
        int x2 = in.nextInt(); int y2 = in.nextInt();

        double tilt;
        if(x2 == x1)    tilt = 0;
        else            tilt = (y2-y1)/(x2-x1);

        double r = (R+Math.sqrt(Math.pow(x2-x1, 2)+Math.pow(y2-y1, 2)))/2;
        double theta = Math.atan(tilt);
        double dx = r*Math.cos(theta);
        double dy = r*Math.sin(theta);

        double xap = x2+dx;
        double yap = y2+dy;

        System.out.print(xap + " " + yap + " " + r);
    }

    private static class FastReader {

        private BufferedReader br;
        private StringTokenizer st;

        public FastReader(String[] args) throws FileNotFoundException {
            br = new BufferedReader(new InputStreamReader(System.in));
//            br = new BufferedReader(new FileReader(args[0]));
        }
        public String next() {
            while(st == null || !st.hasMoreElements()) {
                try                 { st = new StringTokenizer(br.readLine()); }
                catch(IOException e){ e.printStackTrace(); }
            }
            return st.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public double nextDouble() {
            return Double.parseDouble((next()));
        }
        public String nextLine() {
            String str = "";
            try                 { str = br.readLine(); }
            catch(IOException e){ e.printStackTrace(); }
            return str;
        }

    }

}


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

public class Main {

    public static void main(String[] args) throws NumberFormatException, IOException {

        FastReader in = new FastReader(args);

        int R = in.nextInt();
        int x1 = in.nextInt(); int y1 = in.nextInt();
        int x2 = in.nextInt(); int y2 = in.nextInt();

        double distance = Math.sqrt(Math.pow(x2-x1, 2)+Math.pow(y2-y1, 2));
        if(Double.compare(distance, R) == 1) {
            System.out.println(x1 + " " + y1 + " " + R);
            return;
        }

        double tilt;
        if(y2 == y1)        tilt = 0;
        else if(x2 == x1){
            if(y1 > y2) tilt = Double.MAX_VALUE;
            else        tilt = -Double.MAX_VALUE;
        }
        else                tilt = (y2-y1)/(x2-x1);

//        System.out.println("tilt: " + tilt);

        double r = (R+Math.sqrt(Math.pow(x2-x1, 2)+Math.pow(y2-y1, 2)))/2;
        double theta = Math.atan(tilt);
        double dx, dy;
        if(Double.compare(tilt, 0) == 0) {

            if(x2<x1)   dx = r;
            else        dx = -r;
            dy = 0;
        }
        else if(Double.compare(tilt, Double.MAX_VALUE) == 0) {
            dx = 0;
            dy = r;
        }
        else if(Double.compare(tilt, -Double.MAX_VALUE) == 0) {
            dx = 0;
            dy = -r;
        }
        else {
            dx = Math.abs(r*Math.cos(theta));
            dy = Math.abs(r*Math.sin(theta));
            if(x1<x2)   dx *= -1;
            if(y1<y2)   dy *= -1;
        }

//        System.out.println("r: " + r);
//        System.out.println("theta: " + theta);
//        System.out.println("dx: " + dx);
//        System.out.println("dy: " + dy);

        double xap = x2+dx;
        double yap = y2+dy;

        System.out.print(xap + " " + yap + " " + r);
    }

    private static class FastReader {

        private BufferedReader br;
        private StringTokenizer st;

        public FastReader(String[] args) throws FileNotFoundException {
            br = new BufferedReader(new InputStreamReader(System.in));
//            br = new BufferedReader(new FileReader(args[0]));
        }
        public String next() {
            while(st == null || !st.hasMoreElements()) {
                try                 { st = new StringTokenizer(br.readLine()); }
                catch(IOException e){ e.printStackTrace(); }
            }
            return st.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public double nextDouble() {
            return Double.parseDouble((next()));
        }
        public String nextLine() {
            String str = "";
            try                 { str = br.readLine(); }
            catch(IOException e){ e.printStackTrace(); }
            return str;
        }

    }

}


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

public class Main {

    public static void main(String[] args) throws NumberFormatException, IOException {

        FastReader in = new FastReader(args);

        double R = (double)in.nextInt();
        double x1 = (double)in.nextInt(); double y1 = (double)in.nextInt();
        double x2 = (double)in.nextInt(); double y2 = (double)in.nextInt();

        double distance = Math.sqrt(Math.pow(x2-x1, 2)+Math.pow(y2-y1, 2));
        if(Double.compare(distance, R) == 1) {
            System.out.print(x1 + " " + y1 + " " + R);
            return;
        }

        double tilt;
        if(y2 == y1)        tilt = 0;
        else if(x2 == x1){
            if(y1 > y2) tilt = Double.MAX_VALUE;
            else        tilt = -Double.MAX_VALUE;
        }
        else                tilt = (y2-y1)/(x2-x1);

//        System.out.println("tilt: " + tilt);

        double r = (R+Math.sqrt(Math.pow(x2-x1, 2)+Math.pow(y2-y1, 2)))/2;
        double theta = Math.atan(tilt);
        double dx, dy;
        if(Double.compare(tilt, 0) == 0) {

            if(x2<x1)   dx = r;
            else        dx = -r;
            dy = 0;
        }
        else if(Double.compare(tilt, Double.MAX_VALUE) == 0) {
            dx = 0;
            dy = r;
        }
        else if(Double.compare(tilt, -Double.MAX_VALUE) == 0) {
            dx = 0;
            dy = -r;
        }
        else {
            dx = Math.abs(r*Math.cos(theta));
            dy = Math.abs(r*Math.sin(theta));
            if(x1<x2)   dx *= -1;
            if(y1<y2)   dy *= -1;
        }

//        System.out.println("r: " + r);
//        System.out.println("theta: " + theta);
//        System.out.println("dx: " + dx);
//        System.out.println("dy: " + dy);

        double xap = x2+dx;
        double yap = y2+dy;

        System.out.print(xap + " " + yap + " " + r);
    }

    private static class FastReader {

        private BufferedReader br;
        private StringTokenizer st;

        public FastReader(String[] args) throws FileNotFoundException {
            br = new BufferedReader(new InputStreamReader(System.in));
//            br = new BufferedReader(new FileReader(args[0]));
        }
        public String next() {
            while(st == null || !st.hasMoreElements()) {
                try                 { st = new StringTokenizer(br.readLine()); }
                catch(IOException e){ e.printStackTrace(); }
            }
            return st.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public double nextDouble() {
            return Double.parseDouble((next()));
        }
        public String nextLine() {
            String str = "";
            try                 { str = br.readLine(); }
            catch(IOException e){ e.printStackTrace(); }
            return str;
        }

    }

}


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

public class Main {

    public static void main(String[] args) throws NumberFormatException, IOException {

        FastReader in = new FastReader(args);

        int R = in.nextInt();
        int x1 = in.nextInt(); int y1 = in.nextInt();
        int x2 = in.nextInt(); int y2 = in.nextInt();

        double distance = Math.sqrt(Math.pow(x2-x1, 2)+Math.pow(y2-y1, 2));
        if(Double.compare(distance, R) == 1) {
            System.out.println(x1 + " " + y1 + " " + R);
            return;
        }

        double tilt;
        if(y2 == y1)        tilt = 0;
        else if(x2 == x1){
            if(y1 > y2) tilt = Double.MAX_VALUE;
            else        tilt = -Double.MAX_VALUE;
        }
        else                tilt = (y2-y1)/(x2-x1);

//        System.out.println("tilt: " + tilt);

        double r = (R+Math.sqrt(Math.pow(x2-x1, 2)+Math.pow(y2-y1, 2)))/2;
        double theta = Math.atan(tilt);
        double dx, dy;
        if(Double.compare(tilt, 0) == 0) {

            if(x2<x1)   dx = r;
            else        dx = -r;
            dy = 0;
        }
        else if(Double.compare(tilt, Double.MAX_VALUE) == 0) {
            dx = 0;
            dy = r;
        }
        else if(Double.compare(tilt, -Double.MAX_VALUE) == 0) {
            dx = 0;
            dy = -r;
        }
        else {
            dx = r*Math.cos(theta);
            dy = r*Math.sin(theta);
        }

//        System.out.println("r: " + r);
//        System.out.println("theta: " + theta);
//        System.out.println("dx: " + dx);
//        System.out.println("dy: " + dy);

        double xap = x2+dx;
        double yap = y2+dy;

        System.out.print(xap + " " + yap + " " + r);
    }

    private static class FastReader {

        private BufferedReader br;
        private StringTokenizer st;

        public FastReader(String[] args) throws FileNotFoundException {
            br = new BufferedReader(new InputStreamReader(System.in));
//            br = new BufferedReader(new FileReader(args[0]));
        }
        public String next() {
            while(st == null || !st.hasMoreElements()) {
                try                 { st = new StringTokenizer(br.readLine()); }
                catch(IOException e){ e.printStackTrace(); }
            }
            return st.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public double nextDouble() {
            return Double.parseDouble((next()));
        }
        public String nextLine() {
            String str = "";
            try                 { str = br.readLine(); }
            catch(IOException e){ e.printStackTrace(); }
            return str;
        }

    }

}


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

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author rizhiy
 */
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 x = in.nextInt();
            double y = in.nextInt();
            double x1 = in.nextInt();
            double y1 = in.nextInt();
            if ((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y) >= r * r) {
                out.format("%.8f %.8f %.8f", (double) x, (double) y, (double) r);
                return;
            }
            double mz = Math.sqrt((x - x1) * (x - x1) + (y1 - y) * (y1 - y));
            double ra = (r + mz) / 2;
            if (Math.abs(mz - 0) < 0.00000001) {
                out.format("%.8f %.8f %.8f", x, y + ra, ra);
                return;
            }

            double ya = (ra * (y - y1)) / mz + y1;
            double xa = (ra * (x - x1)) / mz + x1;
            out.format("%.8f %.8f %.8f", xa, ya, ra);
        }

    }

    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.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author rizhiy
 */
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 x = in.nextInt();
            double y = in.nextInt();
            double x1 = in.nextInt();
            double y1 = in.nextInt();
            if ((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y) >= r * r) {
                out.format("%.8f %.8f %.8f", (double) x, (double) y, (double) r);
                return;
            }
            double mz = Math.sqrt((x - x1) * (x - x1) + (y1 - y) * (y1 - y));
            double ra = (r + mz) / 2;
            if (Math.abs(mz - 0) < 0.00000001) {
                out.format("%.8f %.8f %.8f", 0.000000000000000, y + ra, ra);
                return;
            }

            double ya = (ra * (y - y1)) / mz + y1;
            double xa = (ra * (x - x1)) / mz + x1;
            out.format("%.8f %.8f %.8f", xa, ya, ra);
        }

    }

    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.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author rizhiy
 */
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 x = in.nextInt();
            double y = in.nextInt();
            double x1 = in.nextInt();
            double y1 = in.nextInt();
            if ((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y) >= r * r) {
                out.format("%.8f %.8f %.8f", (double) x, (double) y, (double) r);
                return;
            }
            double mz = Math.sqrt((x - x1) * (x - x1) + (y1 - y) * (y1 - y));
            double ra = (r + mz) / 2;
            double ya = (ra * (y - y1)) / mz + y1;
            double xa = (ra * (x - x1)) / mz + x1;
            out.format("%.8f %.8f %.8f", xa, ya, ra);
        }

    }

    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.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author rizhiy
 */
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 x = in.nextInt();
            double y = in.nextInt();
            double x1 = in.nextInt();
            double y1 = in.nextInt();
            if ((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y) > r * r) {
                out.format("%.8f %.8f %.8f", (double) x, (double) y, (double) r);
                return;
            }
            double mz = Math.sqrt((x - x1) * (x - x1) + (y1 - y) * (y1 - y));
            double ra = (r + mz) / 2;
            if (Math.abs(mz - 0) < 0.00000001) {
                out.format("%.8f %.8f %.8f", 0.000000000000000, y + ra, ra);
                return;
            }

            double ya = (ra * (y - y1)) / mz + y1;
            double xa = (ra * (x - x1)) / mz + x1;
            out.format("%.8f %.8f %.8f", xa, ya, ra);
        }

    }

    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.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author rizhiy
 */
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 x = in.nextInt();
            double y = in.nextInt();
            double x1 = in.nextInt();
            double y1 = in.nextInt();
            if ((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y) >= r * r) {
                out.format("%.8f %.8f %.8f", (double) x, (double) y, (double) r);
                return;
            }
            double mz = Math.sqrt((x - x1) * (x - x1) + (y1 - y) * (y1 - y));
            double ra = (r + mz) / 2;
            if (Math.abs(mz - 0) == 0) {
                out.format("%.8f %.8f %.8f", 0.000000000000000, y + ra, ra);
                return;
            }

            double ya = (ra * (y - y1)) / mz + y1;
            double xa = (ra * (x - x1)) / mz + x1;
            out.format("%.8f %.8f %.8f", xa, ya, ra);
        }

    }

    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.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.io.*;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.StringJoiner;
import java.util.StringTokenizer;

public class Main {

    static int R, CX, CY, PX, PY;

    public static void main(String[] args) {
        FastScanner sc = new FastScanner(System.in);
        R = sc.nextInt();
        CX = sc.nextInt();
        CY = sc.nextInt();
        PX = sc.nextInt();
        PY = sc.nextInt();

        double[] ans = solve();
        System.out.print(BigDecimal.valueOf(ans[0]).toPlainString());
        System.out.print(" ");
        System.out.print(BigDecimal.valueOf(ans[1]).toPlainString());
        System.out.print(" ");
        System.out.print(BigDecimal.valueOf(ans[2]).toPlainString());
        System.out.println();
    }

    static double[] solve() {
        Point2D.Double c = new Point2D.Double(CX, CY);
        Point2D.Double p = new Point2D.Double(PX, PY);

        if( CX == PX && CX == PY ) {
            double s = (double)R / 2;
            return new double[]{CX + s, CY, s};
        }

        double d = c.distance(p);
        if( d > R ) {
            return new double[]{CX, CY, R};

        } else {
            double r = (R + d) / 2;

            double dx = c.x - p.x;
            double dy = c.y - p.y;

            double dx1 = -dx / d * r;
            double dy1 = -dy / d * r;

            return new double[]{CX + dx1, CY + dy1, r};
        }
    }

    @SuppressWarnings("unused")
    static class FastScanner {
        private BufferedReader reader;
        private StringTokenizer tokenizer;

        FastScanner(InputStream in) {
            reader = new BufferedReader(new InputStreamReader(in));
            tokenizer = null;
        }

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

        String nextLine() {
            if (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    return reader.readLine();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken("\n");
        }

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

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

        int[] nextIntArray(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++) a[i] = nextInt();
            return a;
        }

        int[] nextIntArray(int n, int delta) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++) a[i] = nextInt() + delta;
            return a;
        }

        long[] nextLongArray(int n) {
            long[] a = new long[n];
            for (int i = 0; i < n; i++) a[i] = nextLong();
            return a;
        }
    }

    static void writeLines(int[] as) {
        PrintWriter pw = new PrintWriter(System.out);
        for (int a : as) pw.println(a);
        pw.flush();
    }

    static void writeLines(long[] as) {
        PrintWriter pw = new PrintWriter(System.out);
        for (long a : as) pw.println(a);
        pw.flush();
    }

    static void writeSingleLine(int[] as) {
        PrintWriter pw = new PrintWriter(System.out);
        for (int i = 0; i < as.length; i++) {
            if (i != 0) pw.print(" ");
            pw.print(i);
        }
        pw.println();
        pw.flush();
    }

    static int max(int... as) {
        int max = Integer.MIN_VALUE;
        for (int a : as) max = Math.max(a, max);
        return max;
    }

    static int min(int... as) {
        int min = Integer.MAX_VALUE;
        for (int a : as) min = Math.min(a, min);
        return min;
    }

    static void debug(Object... args) {
        StringJoiner j = new StringJoiner(" ");
        for (Object arg : args) {
            if (arg instanceof int[]) j.add(Arrays.toString((int[]) arg));
            else if (arg instanceof long[]) j.add(Arrays.toString((long[]) arg));
            else if (arg instanceof double[]) j.add(Arrays.toString((double[]) arg));
            else if (arg instanceof Object[]) j.add(Arrays.toString((Object[]) arg));
            else j.add(arg == null ? "null" : arg.toString());
        }
        System.err.println(j.toString());
    }

    static void printSingleLine(int[] array) {
        for (int i = 0; i < array.length; i++) {
            if (i != 0) System.out.print(" ");
            System.out.print(array[i]);
        }
        System.out.println();
    }

    static int lowerBound(int[] array, int value) {
        int low = 0, high = array.length, mid;
        while (low < high) {
            mid = ((high - low) >>> 1) + low;
            if (array[mid] < value) low = mid + 1;
            else high = mid;
        }
        return low;
    }

    static int upperBound(int[] array, int value) {
        int low = 0, high = array.length, mid;
        while (low < high) {
            mid = ((high - low) >>> 1) + low;
            if (array[mid] <= value) low = mid + 1;
            else high = mid;
        }
        return low;
    }
}


import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.io.*;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.StringJoiner;
import java.util.StringTokenizer;

public class Main {

    static int R, CX, CY, PX, PY;

    public static void main(String[] args) {
        FastScanner sc = new FastScanner(System.in);
        R = sc.nextInt();
        CX = sc.nextInt();
        CY = sc.nextInt();
        PX = sc.nextInt();
        PY = sc.nextInt();

        double[] ans = solve();
        System.out.print(BigDecimal.valueOf(ans[0]).toPlainString());
        System.out.print(" ");
        System.out.print(BigDecimal.valueOf(ans[1]).toPlainString());
        System.out.print(" ");
        System.out.print(BigDecimal.valueOf(ans[2]).toPlainString());
        System.out.println();
    }

    static double[] solve() {
        if( CX == PX && CY == PY ) {
            double s = (double)R / 2;
            return new double[]{CX + s, CY, s};
        }

        Point2D.Double c = new Point2D.Double(CX, CY);
        Point2D.Double p = new Point2D.Double(PX, PY);
        double d = c.distance(p);
        if( d > R ) {
            return new double[]{CX, CY, R};

        } else {
            double r = (R + d) / 2;

            double cpx = p.x - c.x;
            double cpy = p.y - c.y;

            double pc2x = -cpx / d * r;
            double pc2y = -cpy / d * r;

            Point2D.Double c2 = new Point2D.Double(PX + pc2x, PY + pc2y);
            debug( d, c2.distance(p) );
            return new double[]{c2.x, c2.y, r};
        }
    }

    @SuppressWarnings("unused")
    static class FastScanner {
        private BufferedReader reader;
        private StringTokenizer tokenizer;

        FastScanner(InputStream in) {
            reader = new BufferedReader(new InputStreamReader(in));
            tokenizer = null;
        }

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

        String nextLine() {
            if (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    return reader.readLine();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken("\n");
        }

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

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

        int[] nextIntArray(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++) a[i] = nextInt();
            return a;
        }

        int[] nextIntArray(int n, int delta) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++) a[i] = nextInt() + delta;
            return a;
        }

        long[] nextLongArray(int n) {
            long[] a = new long[n];
            for (int i = 0; i < n; i++) a[i] = nextLong();
            return a;
        }
    }

    static void writeLines(int[] as) {
        PrintWriter pw = new PrintWriter(System.out);
        for (int a : as) pw.println(a);
        pw.flush();
    }

    static void writeLines(long[] as) {
        PrintWriter pw = new PrintWriter(System.out);
        for (long a : as) pw.println(a);
        pw.flush();
    }

    static void writeSingleLine(int[] as) {
        PrintWriter pw = new PrintWriter(System.out);
        for (int i = 0; i < as.length; i++) {
            if (i != 0) pw.print(" ");
            pw.print(i);
        }
        pw.println();
        pw.flush();
    }

    static int max(int... as) {
        int max = Integer.MIN_VALUE;
        for (int a : as) max = Math.max(a, max);
        return max;
    }

    static int min(int... as) {
        int min = Integer.MAX_VALUE;
        for (int a : as) min = Math.min(a, min);
        return min;
    }

    static void debug(Object... args) {
        StringJoiner j = new StringJoiner(" ");
        for (Object arg : args) {
            if (arg instanceof int[]) j.add(Arrays.toString((int[]) arg));
            else if (arg instanceof long[]) j.add(Arrays.toString((long[]) arg));
            else if (arg instanceof double[]) j.add(Arrays.toString((double[]) arg));
            else if (arg instanceof Object[]) j.add(Arrays.toString((Object[]) arg));
            else j.add(arg == null ? "null" : arg.toString());
        }
        System.err.println(j.toString());
    }

    static void printSingleLine(int[] array) {
        for (int i = 0; i < array.length; i++) {
            if (i != 0) System.out.print(" ");
            System.out.print(array[i]);
        }
        System.out.println();
    }

    static int lowerBound(int[] array, int value) {
        int low = 0, high = array.length, mid;
        while (low < high) {
            mid = ((high - low) >>> 1) + low;
            if (array[mid] < value) low = mid + 1;
            else high = mid;
        }
        return low;
    }

    static int upperBound(int[] array, int value) {
        int low = 0, high = array.length, mid;
        while (low < high) {
            mid = ((high - low) >>> 1) + low;
            if (array[mid] <= value) low = mid + 1;
            else high = mid;
        }
        return low;
    }
}


import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.io.*;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.StringJoiner;
import java.util.StringTokenizer;

public class Main {

    static int R, CX, CY, PX, PY;

    public static void main(String[] args) {
        FastScanner sc = new FastScanner(System.in);
        R = sc.nextInt();
        CX = sc.nextInt();
        CY = sc.nextInt();
        PX = sc.nextInt();
        PY = sc.nextInt();

        double[] ans = solve();
        System.out.print(BigDecimal.valueOf(ans[0]).toPlainString());
        System.out.print(" ");
        System.out.print(BigDecimal.valueOf(ans[1]).toPlainString());
        System.out.print(" ");
        System.out.print(BigDecimal.valueOf(ans[2]).toPlainString());
        System.out.println();
    }

    static double[] solve() {
        Point2D.Double c = new Point2D.Double(CX, CY);
        Point2D.Double p = new Point2D.Double(PX, PY);

        if( CX == PX && CX == PY ) {
            double s = (double)R / 2;
            return new double[]{CX + s, CY, s};
        }

        double d = c.distance(p);
        if( d > R ) {
            return new double[]{CX, CY, R};

        } else {
            double r = (R + d) / 2;

            double cpx = p.x - c.x;
            double cpy = p.y - c.y;

            double pc2x = -cpx / d * r;
            double pc2y = -cpy / d * r;

            Point2D.Double c2 = new Point2D.Double(PX + pc2x, PY + pc2y);
            debug( d, c2.distance(p) );
            return new double[]{c2.x, c2.y, r};
        }
    }

    @SuppressWarnings("unused")
    static class FastScanner {
        private BufferedReader reader;
        private StringTokenizer tokenizer;

        FastScanner(InputStream in) {
            reader = new BufferedReader(new InputStreamReader(in));
            tokenizer = null;
        }

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

        String nextLine() {
            if (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    return reader.readLine();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken("\n");
        }

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

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

        int[] nextIntArray(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++) a[i] = nextInt();
            return a;
        }

        int[] nextIntArray(int n, int delta) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++) a[i] = nextInt() + delta;
            return a;
        }

        long[] nextLongArray(int n) {
            long[] a = new long[n];
            for (int i = 0; i < n; i++) a[i] = nextLong();
            return a;
        }
    }

    static void writeLines(int[] as) {
        PrintWriter pw = new PrintWriter(System.out);
        for (int a : as) pw.println(a);
        pw.flush();
    }

    static void writeLines(long[] as) {
        PrintWriter pw = new PrintWriter(System.out);
        for (long a : as) pw.println(a);
        pw.flush();
    }

    static void writeSingleLine(int[] as) {
        PrintWriter pw = new PrintWriter(System.out);
        for (int i = 0; i < as.length; i++) {
            if (i != 0) pw.print(" ");
            pw.print(i);
        }
        pw.println();
        pw.flush();
    }

    static int max(int... as) {
        int max = Integer.MIN_VALUE;
        for (int a : as) max = Math.max(a, max);
        return max;
    }

    static int min(int... as) {
        int min = Integer.MAX_VALUE;
        for (int a : as) min = Math.min(a, min);
        return min;
    }

    static void debug(Object... args) {
        StringJoiner j = new StringJoiner(" ");
        for (Object arg : args) {
            if (arg instanceof int[]) j.add(Arrays.toString((int[]) arg));
            else if (arg instanceof long[]) j.add(Arrays.toString((long[]) arg));
            else if (arg instanceof double[]) j.add(Arrays.toString((double[]) arg));
            else if (arg instanceof Object[]) j.add(Arrays.toString((Object[]) arg));
            else j.add(arg == null ? "null" : arg.toString());
        }
        System.err.println(j.toString());
    }

    static void printSingleLine(int[] array) {
        for (int i = 0; i < array.length; i++) {
            if (i != 0) System.out.print(" ");
            System.out.print(array[i]);
        }
        System.out.println();
    }

    static int lowerBound(int[] array, int value) {
        int low = 0, high = array.length, mid;
        while (low < high) {
            mid = ((high - low) >>> 1) + low;
            if (array[mid] < value) low = mid + 1;
            else high = mid;
        }
        return low;
    }

    static int upperBound(int[] array, int value) {
        int low = 0, high = array.length, mid;
        while (low < high) {
            mid = ((high - low) >>> 1) + low;
            if (array[mid] <= value) low = mid + 1;
            else high = mid;
        }
        return low;
    }
}